2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
20 u32
is_power_of_2(u32 v
)
22 return (v
&& !(v
& (v
- 1)));
25 u32
rotl32 (const u32 a
, const u32 n
)
27 return ((a
<< n
) | (a
>> (32 - n
)));
30 u32
rotr32 (const u32 a
, const u32 n
)
32 return ((a
>> n
) | (a
<< (32 - n
)));
35 u64
rotl64 (const u64 a
, const u64 n
)
37 return ((a
<< n
) | (a
>> (64 - n
)));
40 u64
rotr64 (const u64 a
, const u64 n
)
42 return ((a
>> n
) | (a
<< (64 - n
)));
45 u32
byte_swap_32 (const u32 n
)
47 return (n
& 0xff000000) >> 24
48 | (n
& 0x00ff0000) >> 8
49 | (n
& 0x0000ff00) << 8
50 | (n
& 0x000000ff) << 24;
53 u64
byte_swap_64 (const u64 n
)
55 return (n
& 0xff00000000000000ULL
) >> 56
56 | (n
& 0x00ff000000000000ULL
) >> 40
57 | (n
& 0x0000ff0000000000ULL
) >> 24
58 | (n
& 0x000000ff00000000ULL
) >> 8
59 | (n
& 0x00000000ff000000ULL
) << 8
60 | (n
& 0x0000000000ff0000ULL
) << 24
61 | (n
& 0x000000000000ff00ULL
) << 40
62 | (n
& 0x00000000000000ffULL
) << 56;
66 * ciphers for use on cpu
73 * hashes for use on cpu
78 #include "cpu-sha256.c"
86 int log_final (FILE *fp
, const char *fmt
, va_list ap
)
92 for (int i
= 0; i
< last_len
; i
++)
100 char s
[4096] = { 0 };
102 int max_len
= (int) sizeof (s
);
104 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
106 if (len
> max_len
) len
= max_len
;
108 fwrite (s
, len
, 1, fp
);
117 int log_out_nn (FILE *fp
, const char *fmt
, ...)
119 if (SUPPRESS_OUTPUT
) return 0;
125 const int len
= log_final (fp
, fmt
, ap
);
132 int log_info_nn (const char *fmt
, ...)
134 if (SUPPRESS_OUTPUT
) return 0;
140 const int len
= log_final (stdout
, fmt
, ap
);
147 int log_error_nn (const char *fmt
, ...)
149 if (SUPPRESS_OUTPUT
) return 0;
155 const int len
= log_final (stderr
, fmt
, ap
);
162 int log_out (FILE *fp
, const char *fmt
, ...)
164 if (SUPPRESS_OUTPUT
) return 0;
170 const int len
= log_final (fp
, fmt
, ap
);
181 int log_info (const char *fmt
, ...)
183 if (SUPPRESS_OUTPUT
) return 0;
189 const int len
= log_final (stdout
, fmt
, ap
);
193 fputc ('\n', stdout
);
200 int log_error (const char *fmt
, ...)
202 if (SUPPRESS_OUTPUT
) return 0;
204 fputc ('\n', stderr
);
205 fputc ('\n', stderr
);
211 const int len
= log_final (stderr
, fmt
, ap
);
215 fputc ('\n', stderr
);
216 fputc ('\n', stderr
);
227 u8
int_to_base32 (const u8 c
)
229 static const u8 tbl
[0x20] =
231 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
232 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
238 u8
base32_to_int (const u8 c
)
240 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
241 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
246 u8
int_to_itoa32 (const u8 c
)
248 static const u8 tbl
[0x20] =
250 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
251 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
257 u8
itoa32_to_int (const u8 c
)
259 if ((c
>= '0') && (c
<= '9')) return c
- '0';
260 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
265 u8
int_to_itoa64 (const u8 c
)
267 static const u8 tbl
[0x40] =
269 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
270 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
271 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
272 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
278 u8
itoa64_to_int (const u8 c
)
280 static const u8 tbl
[0x100] =
282 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
283 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
284 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
285 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
286 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
287 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
288 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
289 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
290 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
291 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
292 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
293 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
294 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
295 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
296 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
297 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
303 u8
int_to_base64 (const u8 c
)
305 static const u8 tbl
[0x40] =
307 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
308 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
309 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
310 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
316 u8
base64_to_int (const u8 c
)
318 static const u8 tbl
[0x100] =
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
322 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
323 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
324 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
325 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
326 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
327 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
328 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
329 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
330 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
331 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
332 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
333 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
334 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
335 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
341 u8
int_to_bf64 (const u8 c
)
343 static const u8 tbl
[0x40] =
345 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
346 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
347 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
348 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
354 u8
bf64_to_int (const u8 c
)
356 static const u8 tbl
[0x100] =
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
360 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
361 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
362 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
363 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
364 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
365 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
366 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
367 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
368 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
369 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
370 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
371 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
372 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
373 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
379 u8
int_to_lotus64 (const u8 c
)
381 if (c
< 10) return '0' + c
;
382 else if (c
< 36) return 'A' + c
- 10;
383 else if (c
< 62) return 'a' + c
- 36;
384 else if (c
== 62) return '+';
385 else if (c
== 63) return '/';
390 u8
lotus64_to_int (const u8 c
)
392 if ((c
>= '0') && (c
<= '9')) return c
- '0';
393 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
394 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
395 else if (c
== '+') return 62;
396 else if (c
== '/') return 63;
402 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
404 const u8
*in_ptr
= in_buf
;
406 u8
*out_ptr
= out_buf
;
408 for (int i
= 0; i
< in_len
; i
+= 8)
410 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
411 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
412 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
413 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
414 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
415 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
416 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
417 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
419 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
420 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
421 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
422 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
423 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
429 for (int i
= 0; i
< in_len
; i
++)
431 if (in_buf
[i
] != '=') continue;
436 int out_len
= (in_len
* 5) / 8;
441 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
443 const u8
*in_ptr
= in_buf
;
445 u8
*out_ptr
= out_buf
;
447 for (int i
= 0; i
< in_len
; i
+= 5)
449 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
450 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
451 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
452 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
453 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
454 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
455 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
456 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
458 out_ptr
[0] = out_val0
& 0x7f;
459 out_ptr
[1] = out_val1
& 0x7f;
460 out_ptr
[2] = out_val2
& 0x7f;
461 out_ptr
[3] = out_val3
& 0x7f;
462 out_ptr
[4] = out_val4
& 0x7f;
463 out_ptr
[5] = out_val5
& 0x7f;
464 out_ptr
[6] = out_val6
& 0x7f;
465 out_ptr
[7] = out_val7
& 0x7f;
471 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
475 out_buf
[out_len
] = '=';
483 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
485 const u8
*in_ptr
= in_buf
;
487 u8
*out_ptr
= out_buf
;
489 for (int i
= 0; i
< in_len
; i
+= 4)
491 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
492 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
493 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
494 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
496 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
497 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
498 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
504 for (int i
= 0; i
< in_len
; i
++)
506 if (in_buf
[i
] != '=') continue;
511 int out_len
= (in_len
* 6) / 8;
516 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
518 const u8
*in_ptr
= in_buf
;
520 u8
*out_ptr
= out_buf
;
522 for (int i
= 0; i
< in_len
; i
+= 3)
524 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
525 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
526 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
527 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
529 out_ptr
[0] = out_val0
& 0x7f;
530 out_ptr
[1] = out_val1
& 0x7f;
531 out_ptr
[2] = out_val2
& 0x7f;
532 out_ptr
[3] = out_val3
& 0x7f;
538 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
542 out_buf
[out_len
] = '=';
550 int is_valid_hex_char (const u8 c
)
552 if ((c
>= '0') && (c
<= '9')) return 1;
553 if ((c
>= 'A') && (c
<= 'F')) return 1;
554 if ((c
>= 'a') && (c
<= 'f')) return 1;
559 u8
hex_convert (const u8 c
)
561 return (c
& 15) + (c
>> 6) * 9;
564 u8
hex_to_u8 (const u8 hex
[2])
568 v
|= (hex_convert (hex
[1]) << 0);
569 v
|= (hex_convert (hex
[0]) << 4);
574 u32
hex_to_u32 (const u8 hex
[8])
578 v
|= ((u32
) hex_convert (hex
[7])) << 0;
579 v
|= ((u32
) hex_convert (hex
[6])) << 4;
580 v
|= ((u32
) hex_convert (hex
[5])) << 8;
581 v
|= ((u32
) hex_convert (hex
[4])) << 12;
582 v
|= ((u32
) hex_convert (hex
[3])) << 16;
583 v
|= ((u32
) hex_convert (hex
[2])) << 20;
584 v
|= ((u32
) hex_convert (hex
[1])) << 24;
585 v
|= ((u32
) hex_convert (hex
[0])) << 28;
590 u64
hex_to_u64 (const u8 hex
[16])
594 v
|= ((u64
) hex_convert (hex
[15]) << 0);
595 v
|= ((u64
) hex_convert (hex
[14]) << 4);
596 v
|= ((u64
) hex_convert (hex
[13]) << 8);
597 v
|= ((u64
) hex_convert (hex
[12]) << 12);
598 v
|= ((u64
) hex_convert (hex
[11]) << 16);
599 v
|= ((u64
) hex_convert (hex
[10]) << 20);
600 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
601 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
602 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
603 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
604 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
605 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
606 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
607 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
608 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
609 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
614 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
616 hex
[0] = v
>> 28 & 15;
617 hex
[1] = v
>> 24 & 15;
618 hex
[2] = v
>> 20 & 15;
619 hex
[3] = v
>> 16 & 15;
620 hex
[4] = v
>> 12 & 15;
621 hex
[5] = v
>> 8 & 15;
622 hex
[6] = v
>> 4 & 15;
623 hex
[7] = v
>> 0 & 15;
627 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
628 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
629 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
630 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
631 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
632 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
633 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
634 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
641 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
645 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
654 for (int i
= 0; i
< 16; i
+= 4)
664 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
671 out
[i
+ 0] = _out
[0];
672 out
[i
+ 1] = _out
[1];
673 out
[i
+ 2] = _out
[2];
674 out
[i
+ 3] = _out
[3];
683 static void juniper_decrypt_hash (char *in
, char *out
)
687 u8 base64_buf
[100] = { 0 };
689 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
693 u32 juniper_iv
[4] = { 0 };
695 memcpy (juniper_iv
, base64_buf
, 12);
697 memcpy (out
, juniper_iv
, 12);
701 u32 juniper_key
[4] = { 0 };
703 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
704 juniper_key
[1] = byte_swap_32 (0x8df91059);
705 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
706 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
710 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
711 u32
*out_ptr
= (u32
*) (out
+ 12);
713 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
716 void phpass_decode (u8 digest
[16], u8 buf
[22])
720 l
= itoa64_to_int (buf
[ 0]) << 0;
721 l
|= itoa64_to_int (buf
[ 1]) << 6;
722 l
|= itoa64_to_int (buf
[ 2]) << 12;
723 l
|= itoa64_to_int (buf
[ 3]) << 18;
725 digest
[ 0] = (l
>> 0) & 0xff;
726 digest
[ 1] = (l
>> 8) & 0xff;
727 digest
[ 2] = (l
>> 16) & 0xff;
729 l
= itoa64_to_int (buf
[ 4]) << 0;
730 l
|= itoa64_to_int (buf
[ 5]) << 6;
731 l
|= itoa64_to_int (buf
[ 6]) << 12;
732 l
|= itoa64_to_int (buf
[ 7]) << 18;
734 digest
[ 3] = (l
>> 0) & 0xff;
735 digest
[ 4] = (l
>> 8) & 0xff;
736 digest
[ 5] = (l
>> 16) & 0xff;
738 l
= itoa64_to_int (buf
[ 8]) << 0;
739 l
|= itoa64_to_int (buf
[ 9]) << 6;
740 l
|= itoa64_to_int (buf
[10]) << 12;
741 l
|= itoa64_to_int (buf
[11]) << 18;
743 digest
[ 6] = (l
>> 0) & 0xff;
744 digest
[ 7] = (l
>> 8) & 0xff;
745 digest
[ 8] = (l
>> 16) & 0xff;
747 l
= itoa64_to_int (buf
[12]) << 0;
748 l
|= itoa64_to_int (buf
[13]) << 6;
749 l
|= itoa64_to_int (buf
[14]) << 12;
750 l
|= itoa64_to_int (buf
[15]) << 18;
752 digest
[ 9] = (l
>> 0) & 0xff;
753 digest
[10] = (l
>> 8) & 0xff;
754 digest
[11] = (l
>> 16) & 0xff;
756 l
= itoa64_to_int (buf
[16]) << 0;
757 l
|= itoa64_to_int (buf
[17]) << 6;
758 l
|= itoa64_to_int (buf
[18]) << 12;
759 l
|= itoa64_to_int (buf
[19]) << 18;
761 digest
[12] = (l
>> 0) & 0xff;
762 digest
[13] = (l
>> 8) & 0xff;
763 digest
[14] = (l
>> 16) & 0xff;
765 l
= itoa64_to_int (buf
[20]) << 0;
766 l
|= itoa64_to_int (buf
[21]) << 6;
768 digest
[15] = (l
>> 0) & 0xff;
771 void phpass_encode (u8 digest
[16], u8 buf
[22])
775 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
777 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
784 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
791 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[11] = int_to_itoa64 (l
& 0x3f);
796 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
798 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
800 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
801 buf
[15] = int_to_itoa64 (l
& 0x3f);
803 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
805 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
806 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
807 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
808 buf
[19] = int_to_itoa64 (l
& 0x3f);
810 l
= (digest
[15] << 0);
812 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
813 buf
[21] = int_to_itoa64 (l
& 0x3f);
816 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
820 l
= itoa64_to_int (buf
[ 0]) << 0;
821 l
|= itoa64_to_int (buf
[ 1]) << 6;
822 l
|= itoa64_to_int (buf
[ 2]) << 12;
823 l
|= itoa64_to_int (buf
[ 3]) << 18;
825 digest
[ 0] = (l
>> 16) & 0xff;
826 digest
[ 6] = (l
>> 8) & 0xff;
827 digest
[12] = (l
>> 0) & 0xff;
829 l
= itoa64_to_int (buf
[ 4]) << 0;
830 l
|= itoa64_to_int (buf
[ 5]) << 6;
831 l
|= itoa64_to_int (buf
[ 6]) << 12;
832 l
|= itoa64_to_int (buf
[ 7]) << 18;
834 digest
[ 1] = (l
>> 16) & 0xff;
835 digest
[ 7] = (l
>> 8) & 0xff;
836 digest
[13] = (l
>> 0) & 0xff;
838 l
= itoa64_to_int (buf
[ 8]) << 0;
839 l
|= itoa64_to_int (buf
[ 9]) << 6;
840 l
|= itoa64_to_int (buf
[10]) << 12;
841 l
|= itoa64_to_int (buf
[11]) << 18;
843 digest
[ 2] = (l
>> 16) & 0xff;
844 digest
[ 8] = (l
>> 8) & 0xff;
845 digest
[14] = (l
>> 0) & 0xff;
847 l
= itoa64_to_int (buf
[12]) << 0;
848 l
|= itoa64_to_int (buf
[13]) << 6;
849 l
|= itoa64_to_int (buf
[14]) << 12;
850 l
|= itoa64_to_int (buf
[15]) << 18;
852 digest
[ 3] = (l
>> 16) & 0xff;
853 digest
[ 9] = (l
>> 8) & 0xff;
854 digest
[15] = (l
>> 0) & 0xff;
856 l
= itoa64_to_int (buf
[16]) << 0;
857 l
|= itoa64_to_int (buf
[17]) << 6;
858 l
|= itoa64_to_int (buf
[18]) << 12;
859 l
|= itoa64_to_int (buf
[19]) << 18;
861 digest
[ 4] = (l
>> 16) & 0xff;
862 digest
[10] = (l
>> 8) & 0xff;
863 digest
[ 5] = (l
>> 0) & 0xff;
865 l
= itoa64_to_int (buf
[20]) << 0;
866 l
|= itoa64_to_int (buf
[21]) << 6;
868 digest
[11] = (l
>> 0) & 0xff;
871 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
875 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
877 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
884 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
891 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
898 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
900 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
901 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
903 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
905 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
906 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
907 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
908 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
910 l
= (digest
[11] << 0);
912 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
913 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
916 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
920 l
= itoa64_to_int (buf
[ 0]) << 0;
921 l
|= itoa64_to_int (buf
[ 1]) << 6;
922 l
|= itoa64_to_int (buf
[ 2]) << 12;
923 l
|= itoa64_to_int (buf
[ 3]) << 18;
925 digest
[ 0] = (l
>> 16) & 0xff;
926 digest
[21] = (l
>> 8) & 0xff;
927 digest
[42] = (l
>> 0) & 0xff;
929 l
= itoa64_to_int (buf
[ 4]) << 0;
930 l
|= itoa64_to_int (buf
[ 5]) << 6;
931 l
|= itoa64_to_int (buf
[ 6]) << 12;
932 l
|= itoa64_to_int (buf
[ 7]) << 18;
934 digest
[22] = (l
>> 16) & 0xff;
935 digest
[43] = (l
>> 8) & 0xff;
936 digest
[ 1] = (l
>> 0) & 0xff;
938 l
= itoa64_to_int (buf
[ 8]) << 0;
939 l
|= itoa64_to_int (buf
[ 9]) << 6;
940 l
|= itoa64_to_int (buf
[10]) << 12;
941 l
|= itoa64_to_int (buf
[11]) << 18;
943 digest
[44] = (l
>> 16) & 0xff;
944 digest
[ 2] = (l
>> 8) & 0xff;
945 digest
[23] = (l
>> 0) & 0xff;
947 l
= itoa64_to_int (buf
[12]) << 0;
948 l
|= itoa64_to_int (buf
[13]) << 6;
949 l
|= itoa64_to_int (buf
[14]) << 12;
950 l
|= itoa64_to_int (buf
[15]) << 18;
952 digest
[ 3] = (l
>> 16) & 0xff;
953 digest
[24] = (l
>> 8) & 0xff;
954 digest
[45] = (l
>> 0) & 0xff;
956 l
= itoa64_to_int (buf
[16]) << 0;
957 l
|= itoa64_to_int (buf
[17]) << 6;
958 l
|= itoa64_to_int (buf
[18]) << 12;
959 l
|= itoa64_to_int (buf
[19]) << 18;
961 digest
[25] = (l
>> 16) & 0xff;
962 digest
[46] = (l
>> 8) & 0xff;
963 digest
[ 4] = (l
>> 0) & 0xff;
965 l
= itoa64_to_int (buf
[20]) << 0;
966 l
|= itoa64_to_int (buf
[21]) << 6;
967 l
|= itoa64_to_int (buf
[22]) << 12;
968 l
|= itoa64_to_int (buf
[23]) << 18;
970 digest
[47] = (l
>> 16) & 0xff;
971 digest
[ 5] = (l
>> 8) & 0xff;
972 digest
[26] = (l
>> 0) & 0xff;
974 l
= itoa64_to_int (buf
[24]) << 0;
975 l
|= itoa64_to_int (buf
[25]) << 6;
976 l
|= itoa64_to_int (buf
[26]) << 12;
977 l
|= itoa64_to_int (buf
[27]) << 18;
979 digest
[ 6] = (l
>> 16) & 0xff;
980 digest
[27] = (l
>> 8) & 0xff;
981 digest
[48] = (l
>> 0) & 0xff;
983 l
= itoa64_to_int (buf
[28]) << 0;
984 l
|= itoa64_to_int (buf
[29]) << 6;
985 l
|= itoa64_to_int (buf
[30]) << 12;
986 l
|= itoa64_to_int (buf
[31]) << 18;
988 digest
[28] = (l
>> 16) & 0xff;
989 digest
[49] = (l
>> 8) & 0xff;
990 digest
[ 7] = (l
>> 0) & 0xff;
992 l
= itoa64_to_int (buf
[32]) << 0;
993 l
|= itoa64_to_int (buf
[33]) << 6;
994 l
|= itoa64_to_int (buf
[34]) << 12;
995 l
|= itoa64_to_int (buf
[35]) << 18;
997 digest
[50] = (l
>> 16) & 0xff;
998 digest
[ 8] = (l
>> 8) & 0xff;
999 digest
[29] = (l
>> 0) & 0xff;
1001 l
= itoa64_to_int (buf
[36]) << 0;
1002 l
|= itoa64_to_int (buf
[37]) << 6;
1003 l
|= itoa64_to_int (buf
[38]) << 12;
1004 l
|= itoa64_to_int (buf
[39]) << 18;
1006 digest
[ 9] = (l
>> 16) & 0xff;
1007 digest
[30] = (l
>> 8) & 0xff;
1008 digest
[51] = (l
>> 0) & 0xff;
1010 l
= itoa64_to_int (buf
[40]) << 0;
1011 l
|= itoa64_to_int (buf
[41]) << 6;
1012 l
|= itoa64_to_int (buf
[42]) << 12;
1013 l
|= itoa64_to_int (buf
[43]) << 18;
1015 digest
[31] = (l
>> 16) & 0xff;
1016 digest
[52] = (l
>> 8) & 0xff;
1017 digest
[10] = (l
>> 0) & 0xff;
1019 l
= itoa64_to_int (buf
[44]) << 0;
1020 l
|= itoa64_to_int (buf
[45]) << 6;
1021 l
|= itoa64_to_int (buf
[46]) << 12;
1022 l
|= itoa64_to_int (buf
[47]) << 18;
1024 digest
[53] = (l
>> 16) & 0xff;
1025 digest
[11] = (l
>> 8) & 0xff;
1026 digest
[32] = (l
>> 0) & 0xff;
1028 l
= itoa64_to_int (buf
[48]) << 0;
1029 l
|= itoa64_to_int (buf
[49]) << 6;
1030 l
|= itoa64_to_int (buf
[50]) << 12;
1031 l
|= itoa64_to_int (buf
[51]) << 18;
1033 digest
[12] = (l
>> 16) & 0xff;
1034 digest
[33] = (l
>> 8) & 0xff;
1035 digest
[54] = (l
>> 0) & 0xff;
1037 l
= itoa64_to_int (buf
[52]) << 0;
1038 l
|= itoa64_to_int (buf
[53]) << 6;
1039 l
|= itoa64_to_int (buf
[54]) << 12;
1040 l
|= itoa64_to_int (buf
[55]) << 18;
1042 digest
[34] = (l
>> 16) & 0xff;
1043 digest
[55] = (l
>> 8) & 0xff;
1044 digest
[13] = (l
>> 0) & 0xff;
1046 l
= itoa64_to_int (buf
[56]) << 0;
1047 l
|= itoa64_to_int (buf
[57]) << 6;
1048 l
|= itoa64_to_int (buf
[58]) << 12;
1049 l
|= itoa64_to_int (buf
[59]) << 18;
1051 digest
[56] = (l
>> 16) & 0xff;
1052 digest
[14] = (l
>> 8) & 0xff;
1053 digest
[35] = (l
>> 0) & 0xff;
1055 l
= itoa64_to_int (buf
[60]) << 0;
1056 l
|= itoa64_to_int (buf
[61]) << 6;
1057 l
|= itoa64_to_int (buf
[62]) << 12;
1058 l
|= itoa64_to_int (buf
[63]) << 18;
1060 digest
[15] = (l
>> 16) & 0xff;
1061 digest
[36] = (l
>> 8) & 0xff;
1062 digest
[57] = (l
>> 0) & 0xff;
1064 l
= itoa64_to_int (buf
[64]) << 0;
1065 l
|= itoa64_to_int (buf
[65]) << 6;
1066 l
|= itoa64_to_int (buf
[66]) << 12;
1067 l
|= itoa64_to_int (buf
[67]) << 18;
1069 digest
[37] = (l
>> 16) & 0xff;
1070 digest
[58] = (l
>> 8) & 0xff;
1071 digest
[16] = (l
>> 0) & 0xff;
1073 l
= itoa64_to_int (buf
[68]) << 0;
1074 l
|= itoa64_to_int (buf
[69]) << 6;
1075 l
|= itoa64_to_int (buf
[70]) << 12;
1076 l
|= itoa64_to_int (buf
[71]) << 18;
1078 digest
[59] = (l
>> 16) & 0xff;
1079 digest
[17] = (l
>> 8) & 0xff;
1080 digest
[38] = (l
>> 0) & 0xff;
1082 l
= itoa64_to_int (buf
[72]) << 0;
1083 l
|= itoa64_to_int (buf
[73]) << 6;
1084 l
|= itoa64_to_int (buf
[74]) << 12;
1085 l
|= itoa64_to_int (buf
[75]) << 18;
1087 digest
[18] = (l
>> 16) & 0xff;
1088 digest
[39] = (l
>> 8) & 0xff;
1089 digest
[60] = (l
>> 0) & 0xff;
1091 l
= itoa64_to_int (buf
[76]) << 0;
1092 l
|= itoa64_to_int (buf
[77]) << 6;
1093 l
|= itoa64_to_int (buf
[78]) << 12;
1094 l
|= itoa64_to_int (buf
[79]) << 18;
1096 digest
[40] = (l
>> 16) & 0xff;
1097 digest
[61] = (l
>> 8) & 0xff;
1098 digest
[19] = (l
>> 0) & 0xff;
1100 l
= itoa64_to_int (buf
[80]) << 0;
1101 l
|= itoa64_to_int (buf
[81]) << 6;
1102 l
|= itoa64_to_int (buf
[82]) << 12;
1103 l
|= itoa64_to_int (buf
[83]) << 18;
1105 digest
[62] = (l
>> 16) & 0xff;
1106 digest
[20] = (l
>> 8) & 0xff;
1107 digest
[41] = (l
>> 0) & 0xff;
1109 l
= itoa64_to_int (buf
[84]) << 0;
1110 l
|= itoa64_to_int (buf
[85]) << 6;
1112 digest
[63] = (l
>> 0) & 0xff;
1115 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1119 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1121 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1128 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1135 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1142 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1149 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1156 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1163 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1170 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1177 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1184 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1191 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1198 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1205 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1212 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1219 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1226 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1233 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1240 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1247 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1254 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1256 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1257 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1259 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1261 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1262 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1263 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1264 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1266 l
= 0 | 0 | (digest
[63] << 0);
1268 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1269 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1272 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1276 l
= itoa64_to_int (buf
[ 0]) << 0;
1277 l
|= itoa64_to_int (buf
[ 1]) << 6;
1278 l
|= itoa64_to_int (buf
[ 2]) << 12;
1279 l
|= itoa64_to_int (buf
[ 3]) << 18;
1281 digest
[ 2] = (l
>> 0) & 0xff;
1282 digest
[ 1] = (l
>> 8) & 0xff;
1283 digest
[ 0] = (l
>> 16) & 0xff;
1285 l
= itoa64_to_int (buf
[ 4]) << 0;
1286 l
|= itoa64_to_int (buf
[ 5]) << 6;
1287 l
|= itoa64_to_int (buf
[ 6]) << 12;
1288 l
|= itoa64_to_int (buf
[ 7]) << 18;
1290 digest
[ 5] = (l
>> 0) & 0xff;
1291 digest
[ 4] = (l
>> 8) & 0xff;
1292 digest
[ 3] = (l
>> 16) & 0xff;
1294 l
= itoa64_to_int (buf
[ 8]) << 0;
1295 l
|= itoa64_to_int (buf
[ 9]) << 6;
1296 l
|= itoa64_to_int (buf
[10]) << 12;
1297 l
|= itoa64_to_int (buf
[11]) << 18;
1299 digest
[ 8] = (l
>> 0) & 0xff;
1300 digest
[ 7] = (l
>> 8) & 0xff;
1301 digest
[ 6] = (l
>> 16) & 0xff;
1303 l
= itoa64_to_int (buf
[12]) << 0;
1304 l
|= itoa64_to_int (buf
[13]) << 6;
1305 l
|= itoa64_to_int (buf
[14]) << 12;
1306 l
|= itoa64_to_int (buf
[15]) << 18;
1308 digest
[11] = (l
>> 0) & 0xff;
1309 digest
[10] = (l
>> 8) & 0xff;
1310 digest
[ 9] = (l
>> 16) & 0xff;
1312 l
= itoa64_to_int (buf
[16]) << 0;
1313 l
|= itoa64_to_int (buf
[17]) << 6;
1314 l
|= itoa64_to_int (buf
[18]) << 12;
1315 l
|= itoa64_to_int (buf
[19]) << 18;
1317 digest
[14] = (l
>> 0) & 0xff;
1318 digest
[13] = (l
>> 8) & 0xff;
1319 digest
[12] = (l
>> 16) & 0xff;
1321 l
= itoa64_to_int (buf
[20]) << 0;
1322 l
|= itoa64_to_int (buf
[21]) << 6;
1323 l
|= itoa64_to_int (buf
[22]) << 12;
1324 l
|= itoa64_to_int (buf
[23]) << 18;
1326 digest
[17] = (l
>> 0) & 0xff;
1327 digest
[16] = (l
>> 8) & 0xff;
1328 digest
[15] = (l
>> 16) & 0xff;
1330 l
= itoa64_to_int (buf
[24]) << 0;
1331 l
|= itoa64_to_int (buf
[25]) << 6;
1332 l
|= itoa64_to_int (buf
[26]) << 12;
1334 digest
[19] = (l
>> 8) & 0xff;
1335 digest
[18] = (l
>> 16) & 0xff;
1338 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1342 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1344 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1351 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1358 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[11] = int_to_itoa64 (l
& 0x3f);
1363 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1365 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[15] = int_to_itoa64 (l
& 0x3f);
1370 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1372 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1374 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1375 buf
[19] = int_to_itoa64 (l
& 0x3f);
1377 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1379 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1380 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1381 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1382 buf
[23] = int_to_itoa64 (l
& 0x3f);
1384 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1386 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1387 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1388 buf
[26] = int_to_itoa64 (l
& 0x3f);
1391 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1395 l
= itoa64_to_int (buf
[ 0]) << 0;
1396 l
|= itoa64_to_int (buf
[ 1]) << 6;
1397 l
|= itoa64_to_int (buf
[ 2]) << 12;
1398 l
|= itoa64_to_int (buf
[ 3]) << 18;
1400 digest
[ 2] = (l
>> 0) & 0xff;
1401 digest
[ 1] = (l
>> 8) & 0xff;
1402 digest
[ 0] = (l
>> 16) & 0xff;
1404 l
= itoa64_to_int (buf
[ 4]) << 0;
1405 l
|= itoa64_to_int (buf
[ 5]) << 6;
1406 l
|= itoa64_to_int (buf
[ 6]) << 12;
1407 l
|= itoa64_to_int (buf
[ 7]) << 18;
1409 digest
[ 5] = (l
>> 0) & 0xff;
1410 digest
[ 4] = (l
>> 8) & 0xff;
1411 digest
[ 3] = (l
>> 16) & 0xff;
1413 l
= itoa64_to_int (buf
[ 8]) << 0;
1414 l
|= itoa64_to_int (buf
[ 9]) << 6;
1415 l
|= itoa64_to_int (buf
[10]) << 12;
1416 l
|= itoa64_to_int (buf
[11]) << 18;
1418 digest
[ 8] = (l
>> 0) & 0xff;
1419 digest
[ 7] = (l
>> 8) & 0xff;
1420 digest
[ 6] = (l
>> 16) & 0xff;
1422 l
= itoa64_to_int (buf
[12]) << 0;
1423 l
|= itoa64_to_int (buf
[13]) << 6;
1424 l
|= itoa64_to_int (buf
[14]) << 12;
1425 l
|= itoa64_to_int (buf
[15]) << 18;
1427 digest
[11] = (l
>> 0) & 0xff;
1428 digest
[10] = (l
>> 8) & 0xff;
1429 digest
[ 9] = (l
>> 16) & 0xff;
1431 l
= itoa64_to_int (buf
[16]) << 0;
1432 l
|= itoa64_to_int (buf
[17]) << 6;
1433 l
|= itoa64_to_int (buf
[18]) << 12;
1434 l
|= itoa64_to_int (buf
[19]) << 18;
1436 digest
[14] = (l
>> 0) & 0xff;
1437 digest
[13] = (l
>> 8) & 0xff;
1438 digest
[12] = (l
>> 16) & 0xff;
1440 l
= itoa64_to_int (buf
[20]) << 0;
1441 l
|= itoa64_to_int (buf
[21]) << 6;
1442 l
|= itoa64_to_int (buf
[22]) << 12;
1443 l
|= itoa64_to_int (buf
[23]) << 18;
1445 digest
[17] = (l
>> 0) & 0xff;
1446 digest
[16] = (l
>> 8) & 0xff;
1447 digest
[15] = (l
>> 16) & 0xff;
1449 l
= itoa64_to_int (buf
[24]) << 0;
1450 l
|= itoa64_to_int (buf
[25]) << 6;
1451 l
|= itoa64_to_int (buf
[26]) << 12;
1452 l
|= itoa64_to_int (buf
[27]) << 18;
1454 digest
[20] = (l
>> 0) & 0xff;
1455 digest
[19] = (l
>> 8) & 0xff;
1456 digest
[18] = (l
>> 16) & 0xff;
1458 l
= itoa64_to_int (buf
[28]) << 0;
1459 l
|= itoa64_to_int (buf
[29]) << 6;
1460 l
|= itoa64_to_int (buf
[30]) << 12;
1461 l
|= itoa64_to_int (buf
[31]) << 18;
1463 digest
[23] = (l
>> 0) & 0xff;
1464 digest
[22] = (l
>> 8) & 0xff;
1465 digest
[21] = (l
>> 16) & 0xff;
1467 l
= itoa64_to_int (buf
[32]) << 0;
1468 l
|= itoa64_to_int (buf
[33]) << 6;
1469 l
|= itoa64_to_int (buf
[34]) << 12;
1470 l
|= itoa64_to_int (buf
[35]) << 18;
1472 digest
[26] = (l
>> 0) & 0xff;
1473 digest
[25] = (l
>> 8) & 0xff;
1474 digest
[24] = (l
>> 16) & 0xff;
1476 l
= itoa64_to_int (buf
[36]) << 0;
1477 l
|= itoa64_to_int (buf
[37]) << 6;
1478 l
|= itoa64_to_int (buf
[38]) << 12;
1479 l
|= itoa64_to_int (buf
[39]) << 18;
1481 digest
[29] = (l
>> 0) & 0xff;
1482 digest
[28] = (l
>> 8) & 0xff;
1483 digest
[27] = (l
>> 16) & 0xff;
1485 l
= itoa64_to_int (buf
[40]) << 0;
1486 l
|= itoa64_to_int (buf
[41]) << 6;
1487 l
|= itoa64_to_int (buf
[42]) << 12;
1489 //digest[32] = (l >> 0) & 0xff;
1490 digest
[31] = (l
>> 8) & 0xff;
1491 digest
[30] = (l
>> 16) & 0xff;
1494 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1498 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1500 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1507 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1514 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[11] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1521 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[15] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1528 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[19] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1535 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[23] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1542 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[27] = int_to_itoa64 (l
& 0x3f);
1547 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1549 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[31] = int_to_itoa64 (l
& 0x3f);
1554 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1556 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1558 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1559 buf
[35] = int_to_itoa64 (l
& 0x3f);
1561 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1563 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1564 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1565 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1566 buf
[39] = int_to_itoa64 (l
& 0x3f);
1568 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1570 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1571 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1572 buf
[42] = int_to_itoa64 (l
& 0x3f);
1575 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1579 l
= itoa64_to_int (buf
[ 0]) << 0;
1580 l
|= itoa64_to_int (buf
[ 1]) << 6;
1581 l
|= itoa64_to_int (buf
[ 2]) << 12;
1582 l
|= itoa64_to_int (buf
[ 3]) << 18;
1584 digest
[ 2] = (l
>> 0) & 0xff;
1585 digest
[ 1] = (l
>> 8) & 0xff;
1586 digest
[ 0] = (l
>> 16) & 0xff;
1588 l
= itoa64_to_int (buf
[ 4]) << 0;
1589 l
|= itoa64_to_int (buf
[ 5]) << 6;
1590 l
|= itoa64_to_int (buf
[ 6]) << 12;
1591 l
|= itoa64_to_int (buf
[ 7]) << 18;
1593 digest
[ 5] = (l
>> 0) & 0xff;
1594 digest
[ 4] = (l
>> 8) & 0xff;
1595 digest
[ 3] = (l
>> 16) & 0xff;
1597 l
= itoa64_to_int (buf
[ 8]) << 0;
1598 l
|= itoa64_to_int (buf
[ 9]) << 6;
1599 l
|= itoa64_to_int (buf
[10]) << 12;
1600 l
|= itoa64_to_int (buf
[11]) << 18;
1602 digest
[ 8] = (l
>> 0) & 0xff;
1603 digest
[ 7] = (l
>> 8) & 0xff;
1604 digest
[ 6] = (l
>> 16) & 0xff;
1606 l
= itoa64_to_int (buf
[12]) << 0;
1607 l
|= itoa64_to_int (buf
[13]) << 6;
1608 l
|= itoa64_to_int (buf
[14]) << 12;
1609 l
|= itoa64_to_int (buf
[15]) << 18;
1611 digest
[11] = (l
>> 0) & 0xff;
1612 digest
[10] = (l
>> 8) & 0xff;
1613 digest
[ 9] = (l
>> 16) & 0xff;
1615 l
= itoa64_to_int (buf
[16]) << 0;
1616 l
|= itoa64_to_int (buf
[17]) << 6;
1617 l
|= itoa64_to_int (buf
[18]) << 12;
1618 l
|= itoa64_to_int (buf
[19]) << 18;
1620 digest
[14] = (l
>> 0) & 0xff;
1621 digest
[13] = (l
>> 8) & 0xff;
1622 digest
[12] = (l
>> 16) & 0xff;
1624 l
= itoa64_to_int (buf
[20]) << 0;
1625 l
|= itoa64_to_int (buf
[21]) << 6;
1626 l
|= itoa64_to_int (buf
[22]) << 12;
1627 l
|= itoa64_to_int (buf
[23]) << 18;
1629 digest
[17] = (l
>> 0) & 0xff;
1630 digest
[16] = (l
>> 8) & 0xff;
1631 digest
[15] = (l
>> 16) & 0xff;
1633 l
= itoa64_to_int (buf
[24]) << 0;
1634 l
|= itoa64_to_int (buf
[25]) << 6;
1635 l
|= itoa64_to_int (buf
[26]) << 12;
1636 l
|= itoa64_to_int (buf
[27]) << 18;
1638 digest
[20] = (l
>> 0) & 0xff;
1639 digest
[19] = (l
>> 8) & 0xff;
1640 digest
[18] = (l
>> 16) & 0xff;
1642 l
= itoa64_to_int (buf
[28]) << 0;
1643 l
|= itoa64_to_int (buf
[29]) << 6;
1644 l
|= itoa64_to_int (buf
[30]) << 12;
1645 l
|= itoa64_to_int (buf
[31]) << 18;
1647 digest
[23] = (l
>> 0) & 0xff;
1648 digest
[22] = (l
>> 8) & 0xff;
1649 digest
[21] = (l
>> 16) & 0xff;
1651 l
= itoa64_to_int (buf
[32]) << 0;
1652 l
|= itoa64_to_int (buf
[33]) << 6;
1653 l
|= itoa64_to_int (buf
[34]) << 12;
1654 l
|= itoa64_to_int (buf
[35]) << 18;
1656 digest
[26] = (l
>> 0) & 0xff;
1657 digest
[25] = (l
>> 8) & 0xff;
1658 digest
[24] = (l
>> 16) & 0xff;
1660 l
= itoa64_to_int (buf
[36]) << 0;
1661 l
|= itoa64_to_int (buf
[37]) << 6;
1662 l
|= itoa64_to_int (buf
[38]) << 12;
1663 l
|= itoa64_to_int (buf
[39]) << 18;
1665 digest
[29] = (l
>> 0) & 0xff;
1666 digest
[28] = (l
>> 8) & 0xff;
1667 digest
[27] = (l
>> 16) & 0xff;
1669 l
= itoa64_to_int (buf
[40]) << 0;
1670 l
|= itoa64_to_int (buf
[41]) << 6;
1671 l
|= itoa64_to_int (buf
[42]) << 12;
1672 l
|= itoa64_to_int (buf
[43]) << 18;
1674 digest
[32] = (l
>> 0) & 0xff;
1675 digest
[31] = (l
>> 8) & 0xff;
1676 digest
[30] = (l
>> 16) & 0xff;
1678 l
= itoa64_to_int (buf
[44]) << 0;
1679 l
|= itoa64_to_int (buf
[45]) << 6;
1680 l
|= itoa64_to_int (buf
[46]) << 12;
1681 l
|= itoa64_to_int (buf
[47]) << 18;
1683 digest
[35] = (l
>> 0) & 0xff;
1684 digest
[34] = (l
>> 8) & 0xff;
1685 digest
[33] = (l
>> 16) & 0xff;
1687 l
= itoa64_to_int (buf
[48]) << 0;
1688 l
|= itoa64_to_int (buf
[49]) << 6;
1689 l
|= itoa64_to_int (buf
[50]) << 12;
1690 l
|= itoa64_to_int (buf
[51]) << 18;
1692 digest
[38] = (l
>> 0) & 0xff;
1693 digest
[37] = (l
>> 8) & 0xff;
1694 digest
[36] = (l
>> 16) & 0xff;
1696 l
= itoa64_to_int (buf
[52]) << 0;
1697 l
|= itoa64_to_int (buf
[53]) << 6;
1698 l
|= itoa64_to_int (buf
[54]) << 12;
1699 l
|= itoa64_to_int (buf
[55]) << 18;
1701 digest
[41] = (l
>> 0) & 0xff;
1702 digest
[40] = (l
>> 8) & 0xff;
1703 digest
[39] = (l
>> 16) & 0xff;
1705 l
= itoa64_to_int (buf
[56]) << 0;
1706 l
|= itoa64_to_int (buf
[57]) << 6;
1707 l
|= itoa64_to_int (buf
[58]) << 12;
1708 l
|= itoa64_to_int (buf
[59]) << 18;
1710 digest
[44] = (l
>> 0) & 0xff;
1711 digest
[43] = (l
>> 8) & 0xff;
1712 digest
[42] = (l
>> 16) & 0xff;
1714 l
= itoa64_to_int (buf
[60]) << 0;
1715 l
|= itoa64_to_int (buf
[61]) << 6;
1716 l
|= itoa64_to_int (buf
[62]) << 12;
1717 l
|= itoa64_to_int (buf
[63]) << 18;
1719 digest
[47] = (l
>> 0) & 0xff;
1720 digest
[46] = (l
>> 8) & 0xff;
1721 digest
[45] = (l
>> 16) & 0xff;
1723 l
= itoa64_to_int (buf
[64]) << 0;
1724 l
|= itoa64_to_int (buf
[65]) << 6;
1725 l
|= itoa64_to_int (buf
[66]) << 12;
1726 l
|= itoa64_to_int (buf
[67]) << 18;
1728 digest
[50] = (l
>> 0) & 0xff;
1729 digest
[49] = (l
>> 8) & 0xff;
1730 digest
[48] = (l
>> 16) & 0xff;
1732 l
= itoa64_to_int (buf
[68]) << 0;
1733 l
|= itoa64_to_int (buf
[69]) << 6;
1734 l
|= itoa64_to_int (buf
[70]) << 12;
1735 l
|= itoa64_to_int (buf
[71]) << 18;
1737 digest
[53] = (l
>> 0) & 0xff;
1738 digest
[52] = (l
>> 8) & 0xff;
1739 digest
[51] = (l
>> 16) & 0xff;
1741 l
= itoa64_to_int (buf
[72]) << 0;
1742 l
|= itoa64_to_int (buf
[73]) << 6;
1743 l
|= itoa64_to_int (buf
[74]) << 12;
1744 l
|= itoa64_to_int (buf
[75]) << 18;
1746 digest
[56] = (l
>> 0) & 0xff;
1747 digest
[55] = (l
>> 8) & 0xff;
1748 digest
[54] = (l
>> 16) & 0xff;
1750 l
= itoa64_to_int (buf
[76]) << 0;
1751 l
|= itoa64_to_int (buf
[77]) << 6;
1752 l
|= itoa64_to_int (buf
[78]) << 12;
1753 l
|= itoa64_to_int (buf
[79]) << 18;
1755 digest
[59] = (l
>> 0) & 0xff;
1756 digest
[58] = (l
>> 8) & 0xff;
1757 digest
[57] = (l
>> 16) & 0xff;
1759 l
= itoa64_to_int (buf
[80]) << 0;
1760 l
|= itoa64_to_int (buf
[81]) << 6;
1761 l
|= itoa64_to_int (buf
[82]) << 12;
1762 l
|= itoa64_to_int (buf
[83]) << 18;
1764 digest
[62] = (l
>> 0) & 0xff;
1765 digest
[61] = (l
>> 8) & 0xff;
1766 digest
[60] = (l
>> 16) & 0xff;
1768 l
= itoa64_to_int (buf
[84]) << 0;
1769 l
|= itoa64_to_int (buf
[85]) << 6;
1771 digest
[63] = (l
>> 16) & 0xff;
1774 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1778 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1780 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1787 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1794 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[11] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1801 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[15] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1808 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[19] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1815 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[23] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1822 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[27] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1829 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[31] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1836 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[35] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1843 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[39] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1850 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[43] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1857 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[47] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1864 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[51] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1871 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[55] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1878 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[59] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1885 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[63] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1892 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[67] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1899 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[71] = int_to_itoa64 (l
& 0x3f);
1904 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1906 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[75] = int_to_itoa64 (l
& 0x3f);
1911 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1913 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1915 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1916 buf
[79] = int_to_itoa64 (l
& 0x3f);
1918 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1920 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1921 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1922 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1923 buf
[83] = int_to_itoa64 (l
& 0x3f);
1925 l
= 0 | 0 | (digest
[63] << 16);
1927 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1928 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1931 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1935 l
= itoa64_to_int (buf
[ 0]) << 0;
1936 l
|= itoa64_to_int (buf
[ 1]) << 6;
1937 l
|= itoa64_to_int (buf
[ 2]) << 12;
1938 l
|= itoa64_to_int (buf
[ 3]) << 18;
1940 digest
[ 0] = (l
>> 16) & 0xff;
1941 digest
[10] = (l
>> 8) & 0xff;
1942 digest
[20] = (l
>> 0) & 0xff;
1944 l
= itoa64_to_int (buf
[ 4]) << 0;
1945 l
|= itoa64_to_int (buf
[ 5]) << 6;
1946 l
|= itoa64_to_int (buf
[ 6]) << 12;
1947 l
|= itoa64_to_int (buf
[ 7]) << 18;
1949 digest
[21] = (l
>> 16) & 0xff;
1950 digest
[ 1] = (l
>> 8) & 0xff;
1951 digest
[11] = (l
>> 0) & 0xff;
1953 l
= itoa64_to_int (buf
[ 8]) << 0;
1954 l
|= itoa64_to_int (buf
[ 9]) << 6;
1955 l
|= itoa64_to_int (buf
[10]) << 12;
1956 l
|= itoa64_to_int (buf
[11]) << 18;
1958 digest
[12] = (l
>> 16) & 0xff;
1959 digest
[22] = (l
>> 8) & 0xff;
1960 digest
[ 2] = (l
>> 0) & 0xff;
1962 l
= itoa64_to_int (buf
[12]) << 0;
1963 l
|= itoa64_to_int (buf
[13]) << 6;
1964 l
|= itoa64_to_int (buf
[14]) << 12;
1965 l
|= itoa64_to_int (buf
[15]) << 18;
1967 digest
[ 3] = (l
>> 16) & 0xff;
1968 digest
[13] = (l
>> 8) & 0xff;
1969 digest
[23] = (l
>> 0) & 0xff;
1971 l
= itoa64_to_int (buf
[16]) << 0;
1972 l
|= itoa64_to_int (buf
[17]) << 6;
1973 l
|= itoa64_to_int (buf
[18]) << 12;
1974 l
|= itoa64_to_int (buf
[19]) << 18;
1976 digest
[24] = (l
>> 16) & 0xff;
1977 digest
[ 4] = (l
>> 8) & 0xff;
1978 digest
[14] = (l
>> 0) & 0xff;
1980 l
= itoa64_to_int (buf
[20]) << 0;
1981 l
|= itoa64_to_int (buf
[21]) << 6;
1982 l
|= itoa64_to_int (buf
[22]) << 12;
1983 l
|= itoa64_to_int (buf
[23]) << 18;
1985 digest
[15] = (l
>> 16) & 0xff;
1986 digest
[25] = (l
>> 8) & 0xff;
1987 digest
[ 5] = (l
>> 0) & 0xff;
1989 l
= itoa64_to_int (buf
[24]) << 0;
1990 l
|= itoa64_to_int (buf
[25]) << 6;
1991 l
|= itoa64_to_int (buf
[26]) << 12;
1992 l
|= itoa64_to_int (buf
[27]) << 18;
1994 digest
[ 6] = (l
>> 16) & 0xff;
1995 digest
[16] = (l
>> 8) & 0xff;
1996 digest
[26] = (l
>> 0) & 0xff;
1998 l
= itoa64_to_int (buf
[28]) << 0;
1999 l
|= itoa64_to_int (buf
[29]) << 6;
2000 l
|= itoa64_to_int (buf
[30]) << 12;
2001 l
|= itoa64_to_int (buf
[31]) << 18;
2003 digest
[27] = (l
>> 16) & 0xff;
2004 digest
[ 7] = (l
>> 8) & 0xff;
2005 digest
[17] = (l
>> 0) & 0xff;
2007 l
= itoa64_to_int (buf
[32]) << 0;
2008 l
|= itoa64_to_int (buf
[33]) << 6;
2009 l
|= itoa64_to_int (buf
[34]) << 12;
2010 l
|= itoa64_to_int (buf
[35]) << 18;
2012 digest
[18] = (l
>> 16) & 0xff;
2013 digest
[28] = (l
>> 8) & 0xff;
2014 digest
[ 8] = (l
>> 0) & 0xff;
2016 l
= itoa64_to_int (buf
[36]) << 0;
2017 l
|= itoa64_to_int (buf
[37]) << 6;
2018 l
|= itoa64_to_int (buf
[38]) << 12;
2019 l
|= itoa64_to_int (buf
[39]) << 18;
2021 digest
[ 9] = (l
>> 16) & 0xff;
2022 digest
[19] = (l
>> 8) & 0xff;
2023 digest
[29] = (l
>> 0) & 0xff;
2025 l
= itoa64_to_int (buf
[40]) << 0;
2026 l
|= itoa64_to_int (buf
[41]) << 6;
2027 l
|= itoa64_to_int (buf
[42]) << 12;
2029 digest
[31] = (l
>> 8) & 0xff;
2030 digest
[30] = (l
>> 0) & 0xff;
2033 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2037 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2039 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2046 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2053 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2060 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2067 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2074 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2081 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2088 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2095 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2097 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2098 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2100 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2102 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2103 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2104 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2105 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2107 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2109 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2110 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2111 buf
[42] = int_to_itoa64 (l
& 0x3f);
2114 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2118 l
= itoa64_to_int (buf
[ 0]) << 0;
2119 l
|= itoa64_to_int (buf
[ 1]) << 6;
2120 l
|= itoa64_to_int (buf
[ 2]) << 12;
2121 l
|= itoa64_to_int (buf
[ 3]) << 18;
2123 digest
[ 0] = (l
>> 0) & 0xff;
2124 digest
[ 1] = (l
>> 8) & 0xff;
2125 digest
[ 2] = (l
>> 16) & 0xff;
2127 l
= itoa64_to_int (buf
[ 4]) << 0;
2128 l
|= itoa64_to_int (buf
[ 5]) << 6;
2129 l
|= itoa64_to_int (buf
[ 6]) << 12;
2130 l
|= itoa64_to_int (buf
[ 7]) << 18;
2132 digest
[ 3] = (l
>> 0) & 0xff;
2133 digest
[ 4] = (l
>> 8) & 0xff;
2134 digest
[ 5] = (l
>> 16) & 0xff;
2136 l
= itoa64_to_int (buf
[ 8]) << 0;
2137 l
|= itoa64_to_int (buf
[ 9]) << 6;
2138 l
|= itoa64_to_int (buf
[10]) << 12;
2139 l
|= itoa64_to_int (buf
[11]) << 18;
2141 digest
[ 6] = (l
>> 0) & 0xff;
2142 digest
[ 7] = (l
>> 8) & 0xff;
2143 digest
[ 8] = (l
>> 16) & 0xff;
2145 l
= itoa64_to_int (buf
[12]) << 0;
2146 l
|= itoa64_to_int (buf
[13]) << 6;
2147 l
|= itoa64_to_int (buf
[14]) << 12;
2148 l
|= itoa64_to_int (buf
[15]) << 18;
2150 digest
[ 9] = (l
>> 0) & 0xff;
2151 digest
[10] = (l
>> 8) & 0xff;
2152 digest
[11] = (l
>> 16) & 0xff;
2154 l
= itoa64_to_int (buf
[16]) << 0;
2155 l
|= itoa64_to_int (buf
[17]) << 6;
2156 l
|= itoa64_to_int (buf
[18]) << 12;
2157 l
|= itoa64_to_int (buf
[19]) << 18;
2159 digest
[12] = (l
>> 0) & 0xff;
2160 digest
[13] = (l
>> 8) & 0xff;
2161 digest
[14] = (l
>> 16) & 0xff;
2163 l
= itoa64_to_int (buf
[20]) << 0;
2164 l
|= itoa64_to_int (buf
[21]) << 6;
2165 l
|= itoa64_to_int (buf
[22]) << 12;
2166 l
|= itoa64_to_int (buf
[23]) << 18;
2168 digest
[15] = (l
>> 0) & 0xff;
2169 digest
[16] = (l
>> 8) & 0xff;
2170 digest
[17] = (l
>> 16) & 0xff;
2172 l
= itoa64_to_int (buf
[24]) << 0;
2173 l
|= itoa64_to_int (buf
[25]) << 6;
2174 l
|= itoa64_to_int (buf
[26]) << 12;
2175 l
|= itoa64_to_int (buf
[27]) << 18;
2177 digest
[18] = (l
>> 0) & 0xff;
2178 digest
[19] = (l
>> 8) & 0xff;
2179 digest
[20] = (l
>> 16) & 0xff;
2181 l
= itoa64_to_int (buf
[28]) << 0;
2182 l
|= itoa64_to_int (buf
[29]) << 6;
2183 l
|= itoa64_to_int (buf
[30]) << 12;
2184 l
|= itoa64_to_int (buf
[31]) << 18;
2186 digest
[21] = (l
>> 0) & 0xff;
2187 digest
[22] = (l
>> 8) & 0xff;
2188 digest
[23] = (l
>> 16) & 0xff;
2190 l
= itoa64_to_int (buf
[32]) << 0;
2191 l
|= itoa64_to_int (buf
[33]) << 6;
2192 l
|= itoa64_to_int (buf
[34]) << 12;
2193 l
|= itoa64_to_int (buf
[35]) << 18;
2195 digest
[24] = (l
>> 0) & 0xff;
2196 digest
[25] = (l
>> 8) & 0xff;
2197 digest
[26] = (l
>> 16) & 0xff;
2199 l
= itoa64_to_int (buf
[36]) << 0;
2200 l
|= itoa64_to_int (buf
[37]) << 6;
2201 l
|= itoa64_to_int (buf
[38]) << 12;
2202 l
|= itoa64_to_int (buf
[39]) << 18;
2204 digest
[27] = (l
>> 0) & 0xff;
2205 digest
[28] = (l
>> 8) & 0xff;
2206 digest
[29] = (l
>> 16) & 0xff;
2208 l
= itoa64_to_int (buf
[40]) << 0;
2209 l
|= itoa64_to_int (buf
[41]) << 6;
2210 l
|= itoa64_to_int (buf
[42]) << 12;
2211 l
|= itoa64_to_int (buf
[43]) << 18;
2213 digest
[30] = (l
>> 0) & 0xff;
2214 digest
[31] = (l
>> 8) & 0xff;
2215 digest
[32] = (l
>> 16) & 0xff;
2250 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2254 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2256 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2263 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2270 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[11] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2277 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[15] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2284 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[19] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2291 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[23] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2298 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[27] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2305 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[31] = int_to_itoa64 (l
& 0x3f);
2310 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2312 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2315 buf
[35] = int_to_itoa64 (l
& 0x3f);
2317 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2319 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2320 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2321 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2322 buf
[39] = int_to_itoa64 (l
& 0x3f);
2324 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2326 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2327 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2328 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2329 //buf[43] = int_to_itoa64 (l & 0x3f);
2337 static struct termio savemodes
;
2338 static int havemodes
= 0;
2342 struct termio modmodes
;
2344 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2348 modmodes
= savemodes
;
2349 modmodes
.c_lflag
&= ~ICANON
;
2350 modmodes
.c_cc
[VMIN
] = 1;
2351 modmodes
.c_cc
[VTIME
] = 0;
2353 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2362 FD_SET (fileno (stdin
), &rfds
);
2369 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2371 if (retval
== 0) return 0;
2372 if (retval
== -1) return -1;
2379 if (!havemodes
) return 0;
2381 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2386 static struct termios savemodes
;
2387 static int havemodes
= 0;
2391 struct termios modmodes
;
2393 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2397 modmodes
= savemodes
;
2398 modmodes
.c_lflag
&= ~ICANON
;
2399 modmodes
.c_cc
[VMIN
] = 1;
2400 modmodes
.c_cc
[VTIME
] = 0;
2402 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2411 FD_SET (fileno (stdin
), &rfds
);
2418 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2420 if (retval
== 0) return 0;
2421 if (retval
== -1) return -1;
2428 if (!havemodes
) return 0;
2430 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2435 static DWORD saveMode
= 0;
2439 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2441 GetConsoleMode (stdinHandle
, &saveMode
);
2442 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2449 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2451 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2453 if (rc
== WAIT_TIMEOUT
) return 0;
2454 if (rc
== WAIT_ABANDONED
) return -1;
2455 if (rc
== WAIT_FAILED
) return -1;
2457 // The whole ReadConsoleInput () part is a workaround.
2458 // For some unknown reason, maybe a mingw bug, a random signal
2459 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2460 // Then it wants to read with getche () a keyboard input
2461 // which has never been made.
2463 INPUT_RECORD buf
[100];
2467 memset (buf
, 0, sizeof (buf
));
2469 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2471 FlushConsoleInputBuffer (stdinHandle
);
2473 for (uint i
= 0; i
< num
; i
++)
2475 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2477 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2479 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2481 return KeyEvent
.uChar
.AsciiChar
;
2489 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2491 SetConsoleMode (stdinHandle
, saveMode
);
2501 #define MSG_ENOMEM "Insufficient memory available"
2503 void *mycalloc (size_t nmemb
, size_t size
)
2505 void *p
= calloc (nmemb
, size
);
2509 log_error ("ERROR: %s", MSG_ENOMEM
);
2517 void *mymalloc (size_t size
)
2519 void *p
= malloc (size
);
2523 log_error ("ERROR: %s", MSG_ENOMEM
);
2528 memset (p
, 0, size
);
2533 void myfree (void *ptr
)
2535 if (ptr
== NULL
) return;
2540 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2542 void *p
= realloc (ptr
, oldsz
+ add
);
2546 log_error ("ERROR: %s", MSG_ENOMEM
);
2551 memset ((char *) p
+ oldsz
, 0, add
);
2556 char *mystrdup (const char *s
)
2558 const size_t len
= strlen (s
);
2560 char *b
= (char *) mymalloc (len
+ 1);
2567 FILE *logfile_open (char *logfile
)
2569 FILE *fp
= fopen (logfile
, "ab");
2579 void logfile_close (FILE *fp
)
2581 if (fp
== stdout
) return;
2586 void logfile_append (const char *fmt
, ...)
2588 if (data
.logfile_disable
== 1) return;
2590 FILE *fp
= logfile_open (data
.logfile
);
2596 vfprintf (fp
, fmt
, ap
);
2607 int logfile_generate_id ()
2609 const int n
= rand ();
2618 char *logfile_generate_topid ()
2620 const int id
= logfile_generate_id ();
2622 char *topid
= (char *) mymalloc (1 + 16 + 1);
2624 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2629 char *logfile_generate_subid ()
2631 const int id
= logfile_generate_id ();
2633 char *subid
= (char *) mymalloc (1 + 16 + 1);
2635 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2645 void lock_file (FILE *fp
)
2649 memset (&lock
, 0, sizeof (struct flock
));
2651 lock
.l_type
= F_WRLCK
;
2652 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2656 log_error ("ERROR: Failed acquiring write lock: %s", strerror (errno
));
2663 void unlock_file (FILE *fp
)
2667 memset (&lock
, 0, sizeof (struct flock
));
2669 lock
.l_type
= F_UNLCK
;
2670 fcntl(fileno(fp
), F_SETLK
, &lock
);
2677 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2679 FlushFileBuffers (h
);
2689 int get_adapters_num_adl (void *adl
, int *iNumberAdapters
)
2691 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2693 if (iNumberAdapters
== 0)
2695 log_info ("WARN: No ADL adapters found.");
2704 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2706 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2707 ADLODParameters lpOdParameters;
2709 lpOdParameters.iSize = sizeof (ADLODParameters);
2710 size_t plevels_size = 0;
2712 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2714 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2715 __func__, iAdapterIndex,
2716 lpOdParameters.iNumberOfPerformanceLevels,
2717 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2718 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2720 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2722 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2724 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2726 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2728 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2729 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2730 __func__, iAdapterIndex, j,
2731 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2733 myfree (lpOdPerformanceLevels);
2739 LPAdapterInfo
hm_get_adapter_info_adl (void *adl
, int iNumberAdapters
)
2741 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2743 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2745 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2747 return lpAdapterInfo
;
2750 int hm_get_adapter_index_nvapi (HM_ADAPTER_NVAPI nvapiGPUHandle
[DEVICES_MAX
])
2754 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nvapi
, nvapiGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2758 log_info ("WARN: No NvAPI adapters found");
2766 int hm_get_adapter_index_nvml (HM_ADAPTER_NVML nvmlGPUHandle
[DEVICES_MAX
])
2770 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2772 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nvml
, 1, i
, &nvmlGPUHandle
[i
]) != NVML_SUCCESS
) break;
2774 // can be used to determine if the device by index matches the cuda device by index
2775 // char name[100]; memset (name, 0, sizeof (name));
2776 // hm_NVML_nvmlDeviceGetName (data.hm_nvml, nvGPUHandle[i], name, sizeof (name) - 1);
2783 log_info ("WARN: No NVML adapters found");
2793 // does not help at all, since ADL does not assign different bus id, device id when we have multi GPU setups
2796 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2800 for (uint i = 0; i < num_adl_adapters; i++)
2802 int opencl_bus_num = hm_device[i].busid;
2803 int opencl_dev_num = hm_device[i].devid;
2805 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2813 if (idx >= DEVICES_MAX) return -1;
2818 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2820 for (uint i = 0; i < opencl_num_devices; i++)
2822 cl_device_topology_amd device_topology;
2824 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2826 hm_device[i].busid = device_topology.pcie.bus;
2827 hm_device[i].devid = device_topology.pcie.device;
2832 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2834 // basically bubble sort
2836 for (int i
= 0; i
< num_adl_adapters
; i
++)
2838 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2840 // get info of adapter [x]
2842 u32 adapter_index_x
= valid_adl_device_list
[j
];
2843 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2845 u32 bus_num_x
= info_x
.iBusNumber
;
2846 u32 dev_num_x
= info_x
.iDeviceNumber
;
2848 // get info of adapter [y]
2850 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2851 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2853 u32 bus_num_y
= info_y
.iBusNumber
;
2854 u32 dev_num_y
= info_y
.iDeviceNumber
;
2858 if (bus_num_y
< bus_num_x
)
2862 else if (bus_num_y
== bus_num_x
)
2864 if (dev_num_y
< dev_num_x
)
2872 u32 temp
= valid_adl_device_list
[j
+ 1];
2874 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2875 valid_adl_device_list
[j
+ 0] = temp
;
2881 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2883 *num_adl_adapters
= 0;
2885 u32
*adl_adapters
= NULL
;
2887 int *bus_numbers
= NULL
;
2888 int *device_numbers
= NULL
;
2890 for (int i
= 0; i
< iNumberAdapters
; i
++)
2892 AdapterInfo info
= lpAdapterInfo
[i
];
2894 if (strlen (info
.strUDID
) < 1) continue;
2897 if (info
.iVendorID
!= 1002) continue;
2899 if (info
.iVendorID
!= 0x1002) continue;
2902 if (info
.iBusNumber
< 0) continue;
2903 if (info
.iDeviceNumber
< 0) continue;
2907 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2909 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2916 if (found
) continue;
2918 // add it to the list
2920 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2922 adl_adapters
[*num_adl_adapters
] = i
;
2924 // rest is just bookkeeping
2926 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2927 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2929 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2930 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2932 (*num_adl_adapters
)++;
2935 myfree (bus_numbers
);
2936 myfree (device_numbers
);
2938 // sort the list by increasing bus id, device id number
2940 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2942 return adl_adapters
;
2945 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2947 // loop through all valid devices
2949 for (int i
= 0; i
< num_adl_adapters
; i
++)
2951 u32 adapter_index
= valid_adl_device_list
[i
];
2955 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2957 // unfortunately this doesn't work since bus id and dev id are not unique
2958 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2959 // if (opencl_device_index == -1) continue;
2961 int opencl_device_index
= i
;
2963 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2965 // get fanspeed info
2967 if (hm_device
[opencl_device_index
].od_version
== 5)
2969 ADLFanSpeedInfo FanSpeedInfo
;
2971 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2973 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2975 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2977 // check read and write capability in fanspeedinfo
2979 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2980 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2982 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2986 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2989 else // od_version == 6
2991 ADLOD6FanSpeedInfo faninfo
;
2993 memset (&faninfo
, 0, sizeof (faninfo
));
2995 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2997 // check read capability in fanspeedinfo
2999 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
3001 hm_device
[opencl_device_index
].fan_get_supported
= 1;
3005 hm_device
[opencl_device_index
].fan_get_supported
= 0;
3013 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3015 for (int i
= 0; i
< num_adl_adapters
; i
++)
3017 u32 adapter_index
= valid_adl_device_list
[i
];
3021 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3023 // get overdrive version
3025 int od_supported
= 0;
3029 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3031 // store the overdrive version in hm_device
3033 // unfortunately this doesn't work since bus id and dev id are not unique
3034 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3035 // if (opencl_device_index == -1) continue;
3037 int opencl_device_index
= i
;
3039 hm_device
[opencl_device_index
].od_version
= od_version
;
3045 int hm_get_adapter_index_adl (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3047 for (int i
= 0; i
< num_adl_adapters
; i
++)
3049 u32 adapter_index
= valid_adl_device_list
[i
];
3053 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3055 // store the iAdapterIndex in hm_device
3057 // unfortunately this doesn't work since bus id and dev id are not unique
3058 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3059 // if (opencl_device_index == -1) continue;
3061 int opencl_device_index
= i
;
3063 hm_device
[opencl_device_index
].adl
= info
.iAdapterIndex
;
3066 return num_adl_adapters
;
3069 int hm_get_threshold_slowdown_with_device_id (const uint device_id
)
3071 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3073 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3077 if (data
.hm_device
[device_id
].od_version
== 5)
3081 else if (data
.hm_device
[device_id
].od_version
== 6)
3083 int CurrentValue
= 0;
3084 int DefaultValue
= 0;
3086 if (hm_ADL_Overdrive6_TargetTemperatureData_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &CurrentValue
, &DefaultValue
) != ADL_OK
) return -1;
3088 // the return value has never been tested since hm_ADL_Overdrive6_TargetTemperatureData_Get() never worked on any system. expect problems.
3090 return DefaultValue
;
3095 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3099 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SLOWDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3107 int hm_get_threshold_shutdown_with_device_id (const uint device_id
)
3109 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3111 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3115 if (data
.hm_device
[device_id
].od_version
== 5)
3119 else if (data
.hm_device
[device_id
].od_version
== 6)
3126 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3130 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SHUTDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3138 int hm_get_temperature_with_device_id (const uint device_id
)
3140 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3142 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3146 if (data
.hm_device
[device_id
].od_version
== 5)
3148 ADLTemperature Temperature
;
3150 Temperature
.iSize
= sizeof (ADLTemperature
);
3152 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &Temperature
) != ADL_OK
) return -1;
3154 return Temperature
.iTemperature
/ 1000;
3156 else if (data
.hm_device
[device_id
].od_version
== 6)
3158 int Temperature
= 0;
3160 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &Temperature
) != ADL_OK
) return -1;
3162 return Temperature
/ 1000;
3167 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3169 int temperature
= 0;
3171 if (hm_NVML_nvmlDeviceGetTemperature (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
) != NVML_SUCCESS
) return -1;
3179 int hm_get_fanpolicy_with_device_id (const uint device_id
)
3181 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3183 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3185 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3189 if (data
.hm_device
[device_id
].od_version
== 5)
3191 ADLFanSpeedValue lpFanSpeedValue
;
3193 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3195 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3196 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3198 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3200 return (lpFanSpeedValue
.iFanSpeed
& ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
) ? 0 : 1;
3202 else // od_version == 6
3209 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3218 int hm_get_fanspeed_with_device_id (const uint device_id
)
3220 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3222 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3224 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3228 if (data
.hm_device
[device_id
].od_version
== 5)
3230 ADLFanSpeedValue lpFanSpeedValue
;
3232 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3234 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3235 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3236 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3238 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3240 return lpFanSpeedValue
.iFanSpeed
;
3242 else // od_version == 6
3244 ADLOD6FanSpeedInfo faninfo
;
3246 memset (&faninfo
, 0, sizeof (faninfo
));
3248 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &faninfo
) != ADL_OK
) return -1;
3250 return faninfo
.iFanSpeedPercent
;
3255 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3259 if (hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nvml
, 0, data
.hm_device
[device_id
].nvml
, (uint
*) &speed
) != NVML_SUCCESS
) return -1;
3268 int hm_get_buslanes_with_device_id (const uint device_id
)
3270 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3272 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3276 ADLPMActivity PMActivity
;
3278 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3280 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3282 return PMActivity
.iCurrentBusLanes
;
3286 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3288 unsigned int currLinkWidth
;
3290 if (hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &currLinkWidth
) != NVML_SUCCESS
) return -1;
3292 return currLinkWidth
;
3298 int hm_get_utilization_with_device_id (const uint device_id
)
3300 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3302 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3306 ADLPMActivity PMActivity
;
3308 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3310 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3312 return PMActivity
.iActivityPercent
;
3316 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3318 nvmlUtilization_t utilization
;
3320 if (hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &utilization
) != NVML_SUCCESS
) return -1;
3322 return utilization
.gpu
;
3328 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3330 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3332 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3336 ADLPMActivity PMActivity
;
3338 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3340 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3342 return PMActivity
.iMemoryClock
/ 100;
3346 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3350 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_MEM
, &clock
) != NVML_SUCCESS
) return -1;
3358 int hm_get_corespeed_with_device_id (const uint device_id
)
3360 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3362 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3366 ADLPMActivity PMActivity
;
3368 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3370 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3372 return PMActivity
.iEngineClock
/ 100;
3376 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3380 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_SM
, &clock
) != NVML_SUCCESS
) return -1;
3388 int hm_get_throttle_with_device_id (const uint device_id
)
3390 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3392 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3397 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3399 unsigned long long clocksThrottleReasons
= 0;
3400 unsigned long long supportedThrottleReasons
= 0;
3402 if (hm_NVML_nvmlDeviceGetCurrentClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &clocksThrottleReasons
) != NVML_SUCCESS
) return -1;
3403 if (hm_NVML_nvmlDeviceGetSupportedClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &supportedThrottleReasons
) != NVML_SUCCESS
) return -1;
3405 clocksThrottleReasons
&= supportedThrottleReasons
;
3407 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonUnknown
;
3409 return (clocksThrottleReasons
> 0);
3415 int hm_set_fanspeed_with_device_id_adl (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3417 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3421 if (data
.hm_device
[device_id
].od_version
== 5)
3423 ADLFanSpeedValue lpFanSpeedValue
;
3425 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3427 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3428 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3429 lpFanSpeedValue
.iFlags
= (fanpolicy
== 1) ? ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
: 0;
3430 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3432 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3436 else // od_version == 6
3438 ADLOD6FanSpeedValue fan_speed_value
;
3440 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3442 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3443 fan_speed_value
.iFanSpeed
= fanspeed
;
3445 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &fan_speed_value
) != ADL_OK
) return -1;
3455 int hm_set_fanspeed_with_device_id_nvapi (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3457 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3461 NV_GPU_COOLER_LEVELS CoolerLevels
= { 0 };
3463 CoolerLevels
.Version
= GPU_COOLER_LEVELS_VER
| sizeof (NV_GPU_COOLER_LEVELS
);
3465 CoolerLevels
.Levels
[0].Level
= fanspeed
;
3466 CoolerLevels
.Levels
[0].Policy
= fanpolicy
;
3468 if (hm_NvAPI_GPU_SetCoolerLevels (data
.hm_nvapi
, data
.hm_device
[device_id
].nvapi
, 0, &CoolerLevels
) != NVAPI_OK
) return -1;
3477 int hm_set_fanspeed_with_device_id_xnvctrl (const uint device_id
, const int fanspeed
)
3479 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3481 if (data
.hm_xnvctrl
)
3483 if (set_fan_speed_target (data
.hm_xnvctrl
, data
.hm_device
[device_id
].xnvctrl
, fanspeed
) != 0) return -1;
3492 #endif // HAVE_HWMON
3498 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3500 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3502 if (css_cnt
> SP_PW_MAX
)
3504 log_error ("ERROR: Mask length is too long");
3509 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3511 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3513 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3514 uint cs_len
= css
[css_pos
].cs_len
;
3516 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3518 uint c
= cs_buf
[cs_pos
] & 0xff;
3525 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3527 cs_t
*cs
= &css
[css_cnt
];
3529 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3531 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3535 for (i
= 0; i
< cs
->cs_len
; i
++)
3537 const uint u
= cs
->cs_buf
[i
];
3542 for (i
= 0; i
< in_len
; i
++)
3544 uint u
= in_buf
[i
] & 0xff;
3546 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3548 if (css_uniq
[u
] == 1) continue;
3552 cs
->cs_buf
[cs
->cs_len
] = u
;
3560 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3564 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3566 uint p0
= in_buf
[in_pos
] & 0xff;
3568 if (interpret
== 1 && p0
== '?')
3572 if (in_pos
== in_len
) break;
3574 uint p1
= in_buf
[in_pos
] & 0xff;
3578 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3580 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3582 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3584 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3586 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3588 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3590 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3591 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3593 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3594 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3596 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3597 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3599 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3600 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3602 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3604 default: log_error ("Syntax error: %s", in_buf
);
3610 if (data
.hex_charset
)
3614 if (in_pos
== in_len
)
3616 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3621 uint p1
= in_buf
[in_pos
] & 0xff;
3623 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3625 log_error ("ERROR: Invalid hex character detected in mask %s", in_buf
);
3632 chr
= hex_convert (p1
) << 0;
3633 chr
|= hex_convert (p0
) << 4;
3635 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3641 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3647 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3651 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3653 sum
*= css
[css_pos
].cs_len
;
3659 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3661 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3666 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3668 char p0
= mask_buf
[mask_pos
];
3674 if (mask_pos
== mask_len
) break;
3676 char p1
= mask_buf
[mask_pos
];
3682 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3684 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3686 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3688 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3690 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3692 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3694 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3695 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3697 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3698 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3700 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3701 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3703 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3704 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3706 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3708 default: log_error ("ERROR: Syntax error: %s", mask_buf
);
3714 if (data
.hex_charset
)
3718 // if there is no 2nd hex character, show an error:
3720 if (mask_pos
== mask_len
)
3722 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3727 char p1
= mask_buf
[mask_pos
];
3729 // if they are not valid hex character, show an error:
3731 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3733 log_error ("ERROR: Invalid hex character detected in mask %s", mask_buf
);
3740 chr
|= hex_convert (p1
) << 0;
3741 chr
|= hex_convert (p0
) << 4;
3743 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3749 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3756 log_error ("ERROR: Invalid mask length (0)");
3766 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3768 for (int i
= 0; i
< css_cnt
; i
++)
3770 uint len
= css
[i
].cs_len
;
3771 u64 next
= val
/ len
;
3772 uint pos
= val
% len
;
3773 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3778 void mp_cut_at (char *mask
, uint max
)
3782 uint mask_len
= strlen (mask
);
3784 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3786 if (mask
[i
] == '?') i
++;
3792 void mp_setup_sys (cs_t
*mp_sys
)
3796 uint donec
[CHARSIZ
] = { 0 };
3798 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3799 mp_sys
[0].cs_buf
[pos
++] = chr
;
3800 mp_sys
[0].cs_len
= pos
; }
3802 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3803 mp_sys
[1].cs_buf
[pos
++] = chr
;
3804 mp_sys
[1].cs_len
= pos
; }
3806 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3807 mp_sys
[2].cs_buf
[pos
++] = chr
;
3808 mp_sys
[2].cs_len
= pos
; }
3810 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3811 mp_sys
[3].cs_buf
[pos
++] = chr
;
3812 mp_sys
[3].cs_len
= pos
; }
3814 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3815 mp_sys
[4].cs_len
= pos
; }
3817 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3818 mp_sys
[5].cs_len
= pos
; }
3821 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3823 FILE *fp
= fopen (buf
, "rb");
3825 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3827 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3831 char mp_file
[1024] = { 0 };
3833 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3837 len
= in_superchop (mp_file
);
3841 log_info ("WARNING: Charset file corrupted");
3843 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3847 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3852 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3854 mp_usr
[index
].cs_len
= 0;
3856 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3859 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3861 char *new_mask_buf
= (char *) mymalloc (256);
3867 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3869 if (css_pos
== len
) break;
3871 char p0
= mask_buf
[mask_pos
];
3873 new_mask_buf
[mask_pos
] = p0
;
3879 if (mask_pos
== mask_len
) break;
3881 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3885 if (data
.hex_charset
)
3889 if (mask_pos
== mask_len
)
3891 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3896 char p1
= mask_buf
[mask_pos
];
3898 // if they are not valid hex character, show an error:
3900 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3902 log_error ("ERROR: Invalid hex character detected in mask: %s", mask_buf
);
3907 new_mask_buf
[mask_pos
] = p1
;
3912 if (css_pos
== len
) return (new_mask_buf
);
3914 myfree (new_mask_buf
);
3923 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3929 for (i
= start
; i
< stop
; i
++)
3931 sum
*= root_css_buf
[i
].cs_len
;
3937 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3941 cs_t
*cs
= &root_css_buf
[start
];
3945 for (i
= start
; i
< stop
; i
++)
3947 const u64 m
= v
% cs
->cs_len
;
3948 const u64 d
= v
/ cs
->cs_len
;
3952 const uint k
= cs
->cs_buf
[m
];
3954 pw_buf
[i
- start
] = (char) k
;
3956 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3960 int sp_comp_val (const void *p1
, const void *p2
)
3962 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3963 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3965 return b2
->val
- b1
->val
;
3968 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3975 * Initialize hcstats
3978 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3980 u64
*root_stats_ptr
= root_stats_buf
;
3982 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3984 for (i
= 0; i
< SP_PW_MAX
; i
++)
3986 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3988 root_stats_ptr
+= CHARSIZ
;
3991 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3993 u64
*markov_stats_ptr
= markov_stats_buf
;
3995 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3997 for (i
= 0; i
< SP_PW_MAX
; i
++)
3999 for (j
= 0; j
< CHARSIZ
; j
++)
4001 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
4003 markov_stats_ptr
+= CHARSIZ
;
4013 char hcstat_tmp
[256] = { 0 };
4015 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
4017 hcstat
= hcstat_tmp
;
4020 FILE *fd
= fopen (hcstat
, "rb");
4024 log_error ("%s: %s", hcstat
, strerror (errno
));
4029 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
4031 log_error ("%s: Could not load data", hcstat
);
4038 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
4040 log_error ("%s: Could not load data", hcstat
);
4050 * Markov modifier of hcstat_table on user request
4055 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4056 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4061 /* Add all stats to first position */
4063 for (i
= 1; i
< SP_PW_MAX
; i
++)
4065 u64
*out
= root_stats_buf_by_pos
[0];
4066 u64
*in
= root_stats_buf_by_pos
[i
];
4068 for (j
= 0; j
< CHARSIZ
; j
++)
4074 for (i
= 1; i
< SP_PW_MAX
; i
++)
4076 u64
*out
= markov_stats_buf_by_key
[0][0];
4077 u64
*in
= markov_stats_buf_by_key
[i
][0];
4079 for (j
= 0; j
< CHARSIZ
; j
++)
4081 for (k
= 0; k
< CHARSIZ
; k
++)
4088 /* copy them to all pw_positions */
4090 for (i
= 1; i
< SP_PW_MAX
; i
++)
4092 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4095 for (i
= 1; i
< SP_PW_MAX
; i
++)
4097 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4105 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4107 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4109 for (i
= 0; i
< SP_PW_MAX
; i
++)
4111 root_table_buf_by_pos
[i
] = root_table_ptr
;
4113 root_table_ptr
+= CHARSIZ
;
4116 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4118 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4120 for (i
= 0; i
< SP_PW_MAX
; i
++)
4122 for (j
= 0; j
< CHARSIZ
; j
++)
4124 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4126 markov_table_ptr
+= CHARSIZ
;
4131 * Convert hcstat to tables
4134 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4136 uint key
= i
% CHARSIZ
;
4138 root_table_buf
[i
].key
= key
;
4139 root_table_buf
[i
].val
= root_stats_buf
[i
];
4142 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4144 uint key
= i
% CHARSIZ
;
4146 markov_table_buf
[i
].key
= key
;
4147 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4150 myfree (root_stats_buf
);
4151 myfree (markov_stats_buf
);
4157 for (i
= 0; i
< SP_PW_MAX
; i
++)
4159 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4162 for (i
= 0; i
< SP_PW_MAX
; i
++)
4164 for (j
= 0; j
< CHARSIZ
; j
++)
4166 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4171 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
4174 * Convert tables to css
4177 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4179 uint pw_pos
= i
/ CHARSIZ
;
4181 cs_t
*cs
= &root_css_buf
[pw_pos
];
4183 if (cs
->cs_len
== threshold
) continue;
4185 uint key
= root_table_buf
[i
].key
;
4187 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4189 cs
->cs_buf
[cs
->cs_len
] = key
;
4195 * Convert table to css
4198 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4200 uint c
= i
/ CHARSIZ
;
4202 cs_t
*cs
= &markov_css_buf
[c
];
4204 if (cs
->cs_len
== threshold
) continue;
4206 uint pw_pos
= c
/ CHARSIZ
;
4208 uint key
= markov_table_buf
[i
].key
;
4210 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4212 cs
->cs_buf
[cs
->cs_len
] = key
;
4218 for (uint i = 0; i < 8; i++)
4220 for (uint j = 0x20; j < 0x80; j++)
4222 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4224 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4226 for (uint k = 0; k < 10; k++)
4228 printf (" %u\n", ptr->cs_buf[k]);
4235 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4237 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4239 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4249 for (uint j
= 1; j
< CHARSIZ
; j
++)
4259 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4261 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4263 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4265 out
+= CHARSIZ
* CHARSIZ
;
4266 in
+= CHARSIZ
* CHARSIZ
;
4268 for (uint j
= 0; j
< CHARSIZ
; j
++)
4275 for (uint k
= 1; k
< CHARSIZ
; k
++)
4287 * mixed shared functions
4290 void dump_hex (const u8
*s
, const int sz
)
4292 for (int i
= 0; i
< sz
; i
++)
4294 log_info_nn ("%02x ", s
[i
]);
4300 void usage_mini_print (const char *progname
)
4302 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4305 void usage_big_print (const char *progname
)
4307 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4310 char *get_exec_path ()
4312 int exec_path_len
= 1024;
4314 char *exec_path
= (char *) mymalloc (exec_path_len
);
4318 char tmp
[32] = { 0 };
4320 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4322 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4326 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4330 uint size
= exec_path_len
;
4332 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4334 log_error("! executable path buffer too small\n");
4339 const int len
= strlen (exec_path
);
4342 #error Your Operating System is not supported or detected
4350 char *get_install_dir (const char *progname
)
4352 char *install_dir
= mystrdup (progname
);
4353 char *last_slash
= NULL
;
4355 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4359 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4365 install_dir
[0] = '.';
4369 return (install_dir
);
4372 char *get_profile_dir (const char *homedir
)
4374 #define DOT_HASHCAT ".hashcat"
4376 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4378 char *profile_dir
= (char *) mymalloc (len
+ 1);
4380 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4385 char *get_session_dir (const char *profile_dir
)
4387 #define SESSIONS_FOLDER "sessions"
4389 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4391 char *session_dir
= (char *) mymalloc (len
+ 1);
4393 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4398 uint
count_lines (FILE *fd
)
4402 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4408 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4410 if (nread
< 1) continue;
4414 for (i
= 0; i
< nread
; i
++)
4416 if (prev
== '\n') cnt
++;
4427 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4431 FILE *fd
= fopen (filename
, "rb");
4435 log_error ("%s: %s", filename
, strerror (errno
));
4440 #define MAX_KEY_SIZE (1024 * 1024)
4442 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4444 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4450 for (int fpos
= 0; fpos
< nread
; fpos
++)
4452 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4454 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4455 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4456 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4457 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4459 if (kpos
>= 64) kpos
= 0;
4466 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4470 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4471 if (CPU_ISSET(core
, cpu_set
)) break;
4473 thread_affinity_policy_data_t policy
= { core
};
4475 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4477 if (data
.quiet
== 0)
4479 if (rc
!= KERN_SUCCESS
)
4481 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4489 void set_cpu_affinity (char *cpu_affinity
)
4492 DWORD_PTR aff_mask
= 0;
4500 char *devices
= strdup (cpu_affinity
);
4502 char *next
= strtok (devices
, ",");
4506 uint cpu_id
= atoi (next
);
4521 log_error ("ERROR: Invalid cpu_id %u specified", cpu_id
);
4527 aff_mask
|= 1 << (cpu_id
- 1);
4529 CPU_SET ((cpu_id
- 1), &cpuset
);
4532 } while ((next
= strtok (NULL
, ",")) != NULL
);
4538 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4539 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4541 pthread_t thread
= pthread_self ();
4542 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4546 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4548 char *element
, *end
;
4550 end
= (char *) base
+ nmemb
* size
;
4552 for (element
= (char *) base
; element
< end
; element
+= size
)
4553 if (!compar (element
, key
))
4559 int sort_by_u32 (const void *v1
, const void *v2
)
4561 const u32
*s1
= (const u32
*) v1
;
4562 const u32
*s2
= (const u32
*) v2
;
4567 int sort_by_salt (const void *v1
, const void *v2
)
4569 const salt_t
*s1
= (const salt_t
*) v1
;
4570 const salt_t
*s2
= (const salt_t
*) v2
;
4572 const int res1
= s1
->salt_len
- s2
->salt_len
;
4574 if (res1
!= 0) return (res1
);
4576 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4578 if (res2
!= 0) return (res2
);
4586 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4587 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4594 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4595 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4601 int sort_by_salt_buf (const void *v1
, const void *v2
)
4603 const pot_t
*p1
= (const pot_t
*) v1
;
4604 const pot_t
*p2
= (const pot_t
*) v2
;
4606 const hash_t
*h1
= &p1
->hash
;
4607 const hash_t
*h2
= &p2
->hash
;
4609 const salt_t
*s1
= h1
->salt
;
4610 const salt_t
*s2
= h2
->salt
;
4616 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4617 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4623 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4625 const hash_t
*h1
= (const hash_t
*) v1
;
4626 const hash_t
*h2
= (const hash_t
*) v2
;
4628 const salt_t
*s1
= h1
->salt
;
4629 const salt_t
*s2
= h2
->salt
;
4631 // testphase: this should work
4636 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4637 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4640 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4641 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4642 if (s1->salt_len > s2->salt_len) return ( 1);
4643 if (s1->salt_len < s2->salt_len) return (-1);
4645 uint n = s1->salt_len;
4649 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4650 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4657 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4659 const hash_t
*h1
= (const hash_t
*) v1
;
4660 const hash_t
*h2
= (const hash_t
*) v2
;
4662 const salt_t
*s1
= h1
->salt
;
4663 const salt_t
*s2
= h2
->salt
;
4665 // 16 - 2 (since last 2 uints contain the digest)
4670 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4671 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4677 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4679 const hash_t
*h1
= (const hash_t
*) v1
;
4680 const hash_t
*h2
= (const hash_t
*) v2
;
4682 const void *d1
= h1
->digest
;
4683 const void *d2
= h2
->digest
;
4685 return data
.sort_by_digest (d1
, d2
);
4688 int sort_by_hash (const void *v1
, const void *v2
)
4690 const hash_t
*h1
= (const hash_t
*) v1
;
4691 const hash_t
*h2
= (const hash_t
*) v2
;
4695 const salt_t
*s1
= h1
->salt
;
4696 const salt_t
*s2
= h2
->salt
;
4698 int res
= sort_by_salt (s1
, s2
);
4700 if (res
!= 0) return (res
);
4703 const void *d1
= h1
->digest
;
4704 const void *d2
= h2
->digest
;
4706 return data
.sort_by_digest (d1
, d2
);
4709 int sort_by_pot (const void *v1
, const void *v2
)
4711 const pot_t
*p1
= (const pot_t
*) v1
;
4712 const pot_t
*p2
= (const pot_t
*) v2
;
4714 const hash_t
*h1
= &p1
->hash
;
4715 const hash_t
*h2
= &p2
->hash
;
4717 return sort_by_hash (h1
, h2
);
4720 int sort_by_mtime (const void *p1
, const void *p2
)
4722 const char **f1
= (const char **) p1
;
4723 const char **f2
= (const char **) p2
;
4725 struct stat s1
; stat (*f1
, &s1
);
4726 struct stat s2
; stat (*f2
, &s2
);
4728 return s2
.st_mtime
- s1
.st_mtime
;
4731 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4733 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4734 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4736 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4739 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4741 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4742 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4744 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4747 int sort_by_stringptr (const void *p1
, const void *p2
)
4749 const char **s1
= (const char **) p1
;
4750 const char **s2
= (const char **) p2
;
4752 return strcmp (*s1
, *s2
);
4755 int sort_by_dictstat (const void *s1
, const void *s2
)
4757 dictstat_t
*d1
= (dictstat_t
*) s1
;
4758 dictstat_t
*d2
= (dictstat_t
*) s2
;
4761 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4763 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4766 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4769 int sort_by_bitmap (const void *p1
, const void *p2
)
4771 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4772 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4774 return b1
->collisions
- b2
->collisions
;
4777 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4779 const u32
*d1
= (const u32
*) v1
;
4780 const u32
*d2
= (const u32
*) v2
;
4786 if (d1
[n
] > d2
[n
]) return ( 1);
4787 if (d1
[n
] < d2
[n
]) return (-1);
4793 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4795 const u32
*d1
= (const u32
*) v1
;
4796 const u32
*d2
= (const u32
*) v2
;
4802 if (d1
[n
] > d2
[n
]) return ( 1);
4803 if (d1
[n
] < d2
[n
]) return (-1);
4809 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4811 const u32
*d1
= (const u32
*) v1
;
4812 const u32
*d2
= (const u32
*) v2
;
4818 if (d1
[n
] > d2
[n
]) return ( 1);
4819 if (d1
[n
] < d2
[n
]) return (-1);
4825 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4827 const u32
*d1
= (const u32
*) v1
;
4828 const u32
*d2
= (const u32
*) v2
;
4834 if (d1
[n
] > d2
[n
]) return ( 1);
4835 if (d1
[n
] < d2
[n
]) return (-1);
4841 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4843 const u32
*d1
= (const u32
*) v1
;
4844 const u32
*d2
= (const u32
*) v2
;
4850 if (d1
[n
] > d2
[n
]) return ( 1);
4851 if (d1
[n
] < d2
[n
]) return (-1);
4857 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4859 const u32
*d1
= (const u32
*) v1
;
4860 const u32
*d2
= (const u32
*) v2
;
4866 if (d1
[n
] > d2
[n
]) return ( 1);
4867 if (d1
[n
] < d2
[n
]) return (-1);
4873 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4875 const u32
*d1
= (const u32
*) v1
;
4876 const u32
*d2
= (const u32
*) v2
;
4882 if (d1
[n
] > d2
[n
]) return ( 1);
4883 if (d1
[n
] < d2
[n
]) return (-1);
4889 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4891 const u32
*d1
= (const u32
*) v1
;
4892 const u32
*d2
= (const u32
*) v2
;
4898 if (d1
[n
] > d2
[n
]) return ( 1);
4899 if (d1
[n
] < d2
[n
]) return (-1);
4905 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4907 const u64
*d1
= (const u64
*) v1
;
4908 const u64
*d2
= (const u64
*) v2
;
4914 if (d1
[n
] > d2
[n
]) return ( 1);
4915 if (d1
[n
] < d2
[n
]) return (-1);
4921 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4923 const u64
*d1
= (const u64
*) v1
;
4924 const u64
*d2
= (const u64
*) v2
;
4930 if (d1
[n
] > d2
[n
]) return ( 1);
4931 if (d1
[n
] < d2
[n
]) return (-1);
4937 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4939 const u64
*d1
= (const u64
*) v1
;
4940 const u64
*d2
= (const u64
*) v2
;
4946 if (d1
[n
] > d2
[n
]) return ( 1);
4947 if (d1
[n
] < d2
[n
]) return (-1);
4953 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4955 const u32
*d1
= (const u32
*) v1
;
4956 const u32
*d2
= (const u32
*) v2
;
4958 const uint dgst_pos0
= data
.dgst_pos0
;
4959 const uint dgst_pos1
= data
.dgst_pos1
;
4960 const uint dgst_pos2
= data
.dgst_pos2
;
4961 const uint dgst_pos3
= data
.dgst_pos3
;
4963 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4964 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4965 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4966 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4967 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4968 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4969 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4970 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4975 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4977 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4978 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4980 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4982 if (res1
!= 0) return (res1
);
4987 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4989 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4990 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4992 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4994 if (res1
!= 0) return (res1
);
4996 const int res2
= t1
->attack_mode
4999 if (res2
!= 0) return (res2
);
5001 const int res3
= t1
->hash_type
5004 if (res3
!= 0) return (res3
);
5009 void format_debug (char *debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
5011 uint outfile_autohex
= data
.outfile_autohex
;
5013 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
5015 FILE *debug_fp
= NULL
;
5017 if (debug_file
!= NULL
)
5019 debug_fp
= fopen (debug_file
, "ab");
5021 lock_file (debug_fp
);
5028 if (debug_fp
== NULL
)
5030 log_info ("WARNING: Could not open debug-file for writing");
5034 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
5036 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
5038 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
5041 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
5043 if (debug_mode
== 4)
5045 fputc (':', debug_fp
);
5047 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5050 fputc ('\n', debug_fp
);
5052 if (debug_file
!= NULL
) fclose (debug_fp
);
5056 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5058 int needs_hexify
= 0;
5060 if (outfile_autohex
== 1)
5062 for (uint i
= 0; i
< plain_len
; i
++)
5064 if (plain_ptr
[i
] < 0x20)
5071 if (plain_ptr
[i
] > 0x7f)
5080 if (needs_hexify
== 1)
5082 fprintf (fp
, "$HEX[");
5084 for (uint i
= 0; i
< plain_len
; i
++)
5086 fprintf (fp
, "%02x", plain_ptr
[i
]);
5093 fwrite (plain_ptr
, plain_len
, 1, fp
);
5097 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const u64 crackpos
, unsigned char *username
, const uint user_len
)
5099 uint outfile_format
= data
.outfile_format
;
5101 char separator
= data
.separator
;
5103 if (outfile_format
& OUTFILE_FMT_HASH
)
5105 fprintf (out_fp
, "%s", out_buf
);
5107 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5109 fputc (separator
, out_fp
);
5112 else if (data
.username
)
5114 if (username
!= NULL
)
5116 for (uint i
= 0; i
< user_len
; i
++)
5118 fprintf (out_fp
, "%c", username
[i
]);
5121 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5123 fputc (separator
, out_fp
);
5128 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5130 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5132 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5134 fputc (separator
, out_fp
);
5138 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5140 for (uint i
= 0; i
< plain_len
; i
++)
5142 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5145 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5147 fputc (separator
, out_fp
);
5151 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5154 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5159 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5161 fprintf (out_fp
, "%llu", crackpos
);
5166 fputc ('\n', out_fp
);
5169 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5173 pot_key
.hash
.salt
= hashes_buf
->salt
;
5174 pot_key
.hash
.digest
= hashes_buf
->digest
;
5176 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5182 input_buf
[input_len
] = 0;
5185 unsigned char *username
= NULL
;
5190 user_t
*user
= hashes_buf
->hash_info
->user
;
5194 username
= (unsigned char *) (user
->user_name
);
5196 user_len
= user
->user_len
;
5200 // do output the line
5201 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5205 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5206 #define LM_MASKED_PLAIN "[notfound]"
5208 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5214 pot_left_key
.hash
.salt
= hash_left
->salt
;
5215 pot_left_key
.hash
.digest
= hash_left
->digest
;
5217 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5221 uint weak_hash_found
= 0;
5223 pot_t pot_right_key
;
5225 pot_right_key
.hash
.salt
= hash_right
->salt
;
5226 pot_right_key
.hash
.digest
= hash_right
->digest
;
5228 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5230 if (pot_right_ptr
== NULL
)
5232 // special case, if "weak hash"
5234 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5236 weak_hash_found
= 1;
5238 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5240 // in theory this is not needed, but we are paranoia:
5242 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5243 pot_right_ptr
->plain_len
= 0;
5247 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5249 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
5254 // at least one half was found:
5258 input_buf
[input_len
] = 0;
5262 unsigned char *username
= NULL
;
5267 user_t
*user
= hash_left
->hash_info
->user
;
5271 username
= (unsigned char *) (user
->user_name
);
5273 user_len
= user
->user_len
;
5277 // mask the part which was not found
5279 uint left_part_masked
= 0;
5280 uint right_part_masked
= 0;
5282 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5284 if (pot_left_ptr
== NULL
)
5286 left_part_masked
= 1;
5288 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5290 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5292 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5293 pot_left_ptr
->plain_len
= mask_plain_len
;
5296 if (pot_right_ptr
== NULL
)
5298 right_part_masked
= 1;
5300 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5302 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5304 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5305 pot_right_ptr
->plain_len
= mask_plain_len
;
5308 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5312 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5314 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5316 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5318 // do output the line
5320 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5322 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5324 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5325 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5328 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5332 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5334 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5336 if (pot_ptr
== NULL
)
5340 input_buf
[input_len
] = 0;
5342 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5346 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5352 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5354 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5358 pot_t pot_right_key
;
5360 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5362 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5364 uint weak_hash_found
= 0;
5366 if (pot_right_ptr
== NULL
)
5368 // special case, if "weak hash"
5370 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5372 weak_hash_found
= 1;
5374 // we just need that pot_right_ptr is not a NULL pointer
5376 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5380 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5382 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5387 // ... at least one part was not cracked
5391 input_buf
[input_len
] = 0;
5393 // only show the hash part which is still not cracked
5395 uint user_len
= input_len
- 32;
5397 char *hash_output
= (char *) mymalloc (33);
5399 memcpy (hash_output
, input_buf
, input_len
);
5401 if (pot_left_ptr
!= NULL
)
5403 // only show right part (because left part was already found)
5405 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5407 hash_output
[user_len
+ 16] = 0;
5410 if (pot_right_ptr
!= NULL
)
5412 // only show left part (because right part was already found)
5414 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5416 hash_output
[user_len
+ 16] = 0;
5419 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5421 myfree (hash_output
);
5423 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5426 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5428 uint opencl_platforms_filter
= 0;
5430 if (opencl_platforms
)
5432 char *platforms
= strdup (opencl_platforms
);
5434 char *next
= strtok (platforms
, ",");
5438 int platform
= atoi (next
);
5440 if (platform
< 1 || platform
> 32)
5442 log_error ("ERROR: Invalid OpenCL platform %u specified", platform
);
5447 opencl_platforms_filter
|= 1 << (platform
- 1);
5449 } while ((next
= strtok (NULL
, ",")) != NULL
);
5455 opencl_platforms_filter
= -1;
5458 return opencl_platforms_filter
;
5461 u32
setup_devices_filter (char *opencl_devices
)
5463 u32 devices_filter
= 0;
5467 char *devices
= strdup (opencl_devices
);
5469 char *next
= strtok (devices
, ",");
5473 int device_id
= atoi (next
);
5475 if (device_id
< 1 || device_id
> 32)
5477 log_error ("ERROR: Invalid device_id %u specified", device_id
);
5482 devices_filter
|= 1 << (device_id
- 1);
5484 } while ((next
= strtok (NULL
, ",")) != NULL
);
5490 devices_filter
= -1;
5493 return devices_filter
;
5496 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5498 cl_device_type device_types_filter
= 0;
5500 if (opencl_device_types
)
5502 char *device_types
= strdup (opencl_device_types
);
5504 char *next
= strtok (device_types
, ",");
5508 int device_type
= atoi (next
);
5510 if (device_type
< 1 || device_type
> 3)
5512 log_error ("ERROR: Invalid device_type %u specified", device_type
);
5517 device_types_filter
|= 1 << device_type
;
5519 } while ((next
= strtok (NULL
, ",")) != NULL
);
5521 free (device_types
);
5525 // Do not use CPU by default, this often reduces GPU performance because
5526 // the CPU is too busy to handle GPU synchronization
5528 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5531 return device_types_filter
;
5534 u32
get_random_num (const u32 min
, const u32 max
)
5536 if (min
== max
) return (min
);
5538 return ((rand () % (max
- min
)) + min
);
5541 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5543 u32 quotient
= dividend
/ divisor
;
5545 if (dividend
% divisor
) quotient
++;
5550 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5552 u64 quotient
= dividend
/ divisor
;
5554 if (dividend
% divisor
) quotient
++;
5559 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5561 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5562 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5564 if (tm
->tm_year
- 70)
5566 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5567 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5569 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5571 else if (tm
->tm_yday
)
5573 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5574 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5576 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5578 else if (tm
->tm_hour
)
5580 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5581 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5583 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5585 else if (tm
->tm_min
)
5587 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5588 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5590 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5594 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5596 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5600 void format_speed_display (float val
, char *buf
, size_t len
)
5611 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5622 /* generate output */
5626 snprintf (buf
, len
- 1, "%.0f ", val
);
5630 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5634 void lowercase (u8
*buf
, int len
)
5636 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5639 void uppercase (u8
*buf
, int len
)
5641 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5644 int fgetl (FILE *fp
, char *line_buf
)
5650 const int c
= fgetc (fp
);
5652 if (c
== EOF
) break;
5654 line_buf
[line_len
] = (char) c
;
5658 if (line_len
== HCBUFSIZ
) line_len
--;
5660 if (c
== '\n') break;
5663 if (line_len
== 0) return 0;
5665 if (line_buf
[line_len
- 1] == '\n')
5669 line_buf
[line_len
] = 0;
5672 if (line_len
== 0) return 0;
5674 if (line_buf
[line_len
- 1] == '\r')
5678 line_buf
[line_len
] = 0;
5684 int in_superchop (char *buf
)
5686 int len
= strlen (buf
);
5690 if (buf
[len
- 1] == '\n')
5697 if (buf
[len
- 1] == '\r')
5712 char **scan_directory (const char *path
)
5714 char *tmp_path
= mystrdup (path
);
5716 size_t tmp_path_len
= strlen (tmp_path
);
5718 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5720 tmp_path
[tmp_path_len
- 1] = 0;
5722 tmp_path_len
= strlen (tmp_path
);
5725 char **files
= NULL
;
5731 if ((d
= opendir (tmp_path
)) != NULL
)
5737 memset (&e
, 0, sizeof (e
));
5738 struct dirent
*de
= NULL
;
5740 if (readdir_r (d
, &e
, &de
) != 0)
5742 log_error ("ERROR: readdir_r() failed");
5747 if (de
== NULL
) break;
5751 while ((de
= readdir (d
)) != NULL
)
5754 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5756 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5758 char *path_file
= (char *) mymalloc (path_size
+ 1);
5760 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5762 path_file
[path_size
] = 0;
5766 if ((d_test
= opendir (path_file
)) != NULL
)
5774 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5778 files
[num_files
- 1] = path_file
;
5784 else if (errno
== ENOTDIR
)
5786 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5790 files
[num_files
- 1] = mystrdup (path
);
5793 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5797 files
[num_files
- 1] = NULL
;
5804 int count_dictionaries (char **dictionary_files
)
5806 if (dictionary_files
== NULL
) return 0;
5810 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5818 char *stroptitype (const uint opti_type
)
5822 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5823 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5824 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5825 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5826 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5827 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5828 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5829 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5830 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5831 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5832 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5833 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5834 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5835 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5836 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5837 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5838 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5839 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5840 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5846 char *strparser (const uint parser_status
)
5848 switch (parser_status
)
5850 case PARSER_OK
: return ((char *) PA_000
); break;
5851 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5852 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5853 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5854 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5855 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5856 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5857 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5858 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5859 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5860 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5861 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5862 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5863 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5864 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5865 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5866 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5869 return ((char *) PA_255
);
5872 char *strhashtype (const uint hash_mode
)
5876 case 0: return ((char *) HT_00000
); break;
5877 case 10: return ((char *) HT_00010
); break;
5878 case 11: return ((char *) HT_00011
); break;
5879 case 12: return ((char *) HT_00012
); break;
5880 case 20: return ((char *) HT_00020
); break;
5881 case 21: return ((char *) HT_00021
); break;
5882 case 22: return ((char *) HT_00022
); break;
5883 case 23: return ((char *) HT_00023
); break;
5884 case 30: return ((char *) HT_00030
); break;
5885 case 40: return ((char *) HT_00040
); break;
5886 case 50: return ((char *) HT_00050
); break;
5887 case 60: return ((char *) HT_00060
); break;
5888 case 100: return ((char *) HT_00100
); break;
5889 case 101: return ((char *) HT_00101
); break;
5890 case 110: return ((char *) HT_00110
); break;
5891 case 111: return ((char *) HT_00111
); break;
5892 case 112: return ((char *) HT_00112
); break;
5893 case 120: return ((char *) HT_00120
); break;
5894 case 121: return ((char *) HT_00121
); break;
5895 case 122: return ((char *) HT_00122
); break;
5896 case 124: return ((char *) HT_00124
); break;
5897 case 125: return ((char *) HT_00125
); break;
5898 case 130: return ((char *) HT_00130
); break;
5899 case 131: return ((char *) HT_00131
); break;
5900 case 132: return ((char *) HT_00132
); break;
5901 case 133: return ((char *) HT_00133
); break;
5902 case 140: return ((char *) HT_00140
); break;
5903 case 141: return ((char *) HT_00141
); break;
5904 case 150: return ((char *) HT_00150
); break;
5905 case 160: return ((char *) HT_00160
); break;
5906 case 200: return ((char *) HT_00200
); break;
5907 case 300: return ((char *) HT_00300
); break;
5908 case 400: return ((char *) HT_00400
); break;
5909 case 500: return ((char *) HT_00500
); break;
5910 case 501: return ((char *) HT_00501
); break;
5911 case 900: return ((char *) HT_00900
); break;
5912 case 910: return ((char *) HT_00910
); break;
5913 case 1000: return ((char *) HT_01000
); break;
5914 case 1100: return ((char *) HT_01100
); break;
5915 case 1400: return ((char *) HT_01400
); break;
5916 case 1410: return ((char *) HT_01410
); break;
5917 case 1420: return ((char *) HT_01420
); break;
5918 case 1421: return ((char *) HT_01421
); break;
5919 case 1430: return ((char *) HT_01430
); break;
5920 case 1440: return ((char *) HT_01440
); break;
5921 case 1441: return ((char *) HT_01441
); break;
5922 case 1450: return ((char *) HT_01450
); break;
5923 case 1460: return ((char *) HT_01460
); break;
5924 case 1500: return ((char *) HT_01500
); break;
5925 case 1600: return ((char *) HT_01600
); break;
5926 case 1700: return ((char *) HT_01700
); break;
5927 case 1710: return ((char *) HT_01710
); break;
5928 case 1711: return ((char *) HT_01711
); break;
5929 case 1720: return ((char *) HT_01720
); break;
5930 case 1722: return ((char *) HT_01722
); break;
5931 case 1730: return ((char *) HT_01730
); break;
5932 case 1731: return ((char *) HT_01731
); break;
5933 case 1740: return ((char *) HT_01740
); break;
5934 case 1750: return ((char *) HT_01750
); break;
5935 case 1760: return ((char *) HT_01760
); break;
5936 case 1800: return ((char *) HT_01800
); break;
5937 case 2100: return ((char *) HT_02100
); break;
5938 case 2400: return ((char *) HT_02400
); break;
5939 case 2410: return ((char *) HT_02410
); break;
5940 case 2500: return ((char *) HT_02500
); break;
5941 case 2600: return ((char *) HT_02600
); break;
5942 case 2611: return ((char *) HT_02611
); break;
5943 case 2612: return ((char *) HT_02612
); break;
5944 case 2711: return ((char *) HT_02711
); break;
5945 case 2811: return ((char *) HT_02811
); break;
5946 case 3000: return ((char *) HT_03000
); break;
5947 case 3100: return ((char *) HT_03100
); break;
5948 case 3200: return ((char *) HT_03200
); break;
5949 case 3710: return ((char *) HT_03710
); break;
5950 case 3711: return ((char *) HT_03711
); break;
5951 case 3800: return ((char *) HT_03800
); break;
5952 case 4300: return ((char *) HT_04300
); break;
5953 case 4400: return ((char *) HT_04400
); break;
5954 case 4500: return ((char *) HT_04500
); break;
5955 case 4700: return ((char *) HT_04700
); break;
5956 case 4800: return ((char *) HT_04800
); break;
5957 case 4900: return ((char *) HT_04900
); break;
5958 case 5000: return ((char *) HT_05000
); break;
5959 case 5100: return ((char *) HT_05100
); break;
5960 case 5200: return ((char *) HT_05200
); break;
5961 case 5300: return ((char *) HT_05300
); break;
5962 case 5400: return ((char *) HT_05400
); break;
5963 case 5500: return ((char *) HT_05500
); break;
5964 case 5600: return ((char *) HT_05600
); break;
5965 case 5700: return ((char *) HT_05700
); break;
5966 case 5800: return ((char *) HT_05800
); break;
5967 case 6000: return ((char *) HT_06000
); break;
5968 case 6100: return ((char *) HT_06100
); break;
5969 case 6211: return ((char *) HT_06211
); break;
5970 case 6212: return ((char *) HT_06212
); break;
5971 case 6213: return ((char *) HT_06213
); break;
5972 case 6221: return ((char *) HT_06221
); break;
5973 case 6222: return ((char *) HT_06222
); break;
5974 case 6223: return ((char *) HT_06223
); break;
5975 case 6231: return ((char *) HT_06231
); break;
5976 case 6232: return ((char *) HT_06232
); break;
5977 case 6233: return ((char *) HT_06233
); break;
5978 case 6241: return ((char *) HT_06241
); break;
5979 case 6242: return ((char *) HT_06242
); break;
5980 case 6243: return ((char *) HT_06243
); break;
5981 case 6300: return ((char *) HT_06300
); break;
5982 case 6400: return ((char *) HT_06400
); break;
5983 case 6500: return ((char *) HT_06500
); break;
5984 case 6600: return ((char *) HT_06600
); break;
5985 case 6700: return ((char *) HT_06700
); break;
5986 case 6800: return ((char *) HT_06800
); break;
5987 case 6900: return ((char *) HT_06900
); break;
5988 case 7100: return ((char *) HT_07100
); break;
5989 case 7200: return ((char *) HT_07200
); break;
5990 case 7300: return ((char *) HT_07300
); break;
5991 case 7400: return ((char *) HT_07400
); break;
5992 case 7500: return ((char *) HT_07500
); break;
5993 case 7600: return ((char *) HT_07600
); break;
5994 case 7700: return ((char *) HT_07700
); break;
5995 case 7800: return ((char *) HT_07800
); break;
5996 case 7900: return ((char *) HT_07900
); break;
5997 case 8000: return ((char *) HT_08000
); break;
5998 case 8100: return ((char *) HT_08100
); break;
5999 case 8200: return ((char *) HT_08200
); break;
6000 case 8300: return ((char *) HT_08300
); break;
6001 case 8400: return ((char *) HT_08400
); break;
6002 case 8500: return ((char *) HT_08500
); break;
6003 case 8600: return ((char *) HT_08600
); break;
6004 case 8700: return ((char *) HT_08700
); break;
6005 case 8800: return ((char *) HT_08800
); break;
6006 case 8900: return ((char *) HT_08900
); break;
6007 case 9000: return ((char *) HT_09000
); break;
6008 case 9100: return ((char *) HT_09100
); break;
6009 case 9200: return ((char *) HT_09200
); break;
6010 case 9300: return ((char *) HT_09300
); break;
6011 case 9400: return ((char *) HT_09400
); break;
6012 case 9500: return ((char *) HT_09500
); break;
6013 case 9600: return ((char *) HT_09600
); break;
6014 case 9700: return ((char *) HT_09700
); break;
6015 case 9710: return ((char *) HT_09710
); break;
6016 case 9720: return ((char *) HT_09720
); break;
6017 case 9800: return ((char *) HT_09800
); break;
6018 case 9810: return ((char *) HT_09810
); break;
6019 case 9820: return ((char *) HT_09820
); break;
6020 case 9900: return ((char *) HT_09900
); break;
6021 case 10000: return ((char *) HT_10000
); break;
6022 case 10100: return ((char *) HT_10100
); break;
6023 case 10200: return ((char *) HT_10200
); break;
6024 case 10300: return ((char *) HT_10300
); break;
6025 case 10400: return ((char *) HT_10400
); break;
6026 case 10410: return ((char *) HT_10410
); break;
6027 case 10420: return ((char *) HT_10420
); break;
6028 case 10500: return ((char *) HT_10500
); break;
6029 case 10600: return ((char *) HT_10600
); break;
6030 case 10700: return ((char *) HT_10700
); break;
6031 case 10800: return ((char *) HT_10800
); break;
6032 case 10900: return ((char *) HT_10900
); break;
6033 case 11000: return ((char *) HT_11000
); break;
6034 case 11100: return ((char *) HT_11100
); break;
6035 case 11200: return ((char *) HT_11200
); break;
6036 case 11300: return ((char *) HT_11300
); break;
6037 case 11400: return ((char *) HT_11400
); break;
6038 case 11500: return ((char *) HT_11500
); break;
6039 case 11600: return ((char *) HT_11600
); break;
6040 case 11700: return ((char *) HT_11700
); break;
6041 case 11800: return ((char *) HT_11800
); break;
6042 case 11900: return ((char *) HT_11900
); break;
6043 case 12000: return ((char *) HT_12000
); break;
6044 case 12100: return ((char *) HT_12100
); break;
6045 case 12200: return ((char *) HT_12200
); break;
6046 case 12300: return ((char *) HT_12300
); break;
6047 case 12400: return ((char *) HT_12400
); break;
6048 case 12500: return ((char *) HT_12500
); break;
6049 case 12600: return ((char *) HT_12600
); break;
6050 case 12700: return ((char *) HT_12700
); break;
6051 case 12800: return ((char *) HT_12800
); break;
6052 case 12900: return ((char *) HT_12900
); break;
6053 case 13000: return ((char *) HT_13000
); break;
6054 case 13100: return ((char *) HT_13100
); break;
6055 case 13200: return ((char *) HT_13200
); break;
6056 case 13300: return ((char *) HT_13300
); break;
6057 case 13400: return ((char *) HT_13400
); break;
6058 case 13500: return ((char *) HT_13500
); break;
6059 case 13600: return ((char *) HT_13600
); break;
6060 case 13711: return ((char *) HT_13711
); break;
6061 case 13712: return ((char *) HT_13712
); break;
6062 case 13713: return ((char *) HT_13713
); break;
6063 case 13721: return ((char *) HT_13721
); break;
6064 case 13722: return ((char *) HT_13722
); break;
6065 case 13723: return ((char *) HT_13723
); break;
6066 case 13731: return ((char *) HT_13731
); break;
6067 case 13732: return ((char *) HT_13732
); break;
6068 case 13733: return ((char *) HT_13733
); break;
6069 case 13741: return ((char *) HT_13741
); break;
6070 case 13742: return ((char *) HT_13742
); break;
6071 case 13743: return ((char *) HT_13743
); break;
6072 case 13751: return ((char *) HT_13751
); break;
6073 case 13752: return ((char *) HT_13752
); break;
6074 case 13753: return ((char *) HT_13753
); break;
6075 case 13761: return ((char *) HT_13761
); break;
6076 case 13762: return ((char *) HT_13762
); break;
6077 case 13763: return ((char *) HT_13763
); break;
6078 case 13800: return ((char *) HT_13800
); break;
6081 return ((char *) "Unknown");
6084 char *strstatus (const uint devices_status
)
6086 switch (devices_status
)
6088 case STATUS_INIT
: return ((char *) ST_0000
); break;
6089 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6090 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6091 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6092 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6093 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6094 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6095 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6096 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6097 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6098 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6101 return ((char *) "Unknown");
6104 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6106 uint hash_type
= data
.hash_type
;
6107 uint hash_mode
= data
.hash_mode
;
6108 uint salt_type
= data
.salt_type
;
6109 uint opts_type
= data
.opts_type
;
6110 uint opti_type
= data
.opti_type
;
6111 uint dgst_size
= data
.dgst_size
;
6113 char *hashfile
= data
.hashfile
;
6117 uint digest_buf
[64] = { 0 };
6119 u64
*digest_buf64
= (u64
*) digest_buf
;
6121 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6123 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6125 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6131 case HASH_TYPE_DESCRYPT
:
6132 FP (digest_buf
[1], digest_buf
[0], tt
);
6135 case HASH_TYPE_DESRACF
:
6136 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6137 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6139 FP (digest_buf
[1], digest_buf
[0], tt
);
6143 FP (digest_buf
[1], digest_buf
[0], tt
);
6146 case HASH_TYPE_NETNTLM
:
6147 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6148 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6149 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6150 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6152 FP (digest_buf
[1], digest_buf
[0], tt
);
6153 FP (digest_buf
[3], digest_buf
[2], tt
);
6156 case HASH_TYPE_BSDICRYPT
:
6157 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6158 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6160 FP (digest_buf
[1], digest_buf
[0], tt
);
6165 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6170 digest_buf
[0] += MD4M_A
;
6171 digest_buf
[1] += MD4M_B
;
6172 digest_buf
[2] += MD4M_C
;
6173 digest_buf
[3] += MD4M_D
;
6177 digest_buf
[0] += MD5M_A
;
6178 digest_buf
[1] += MD5M_B
;
6179 digest_buf
[2] += MD5M_C
;
6180 digest_buf
[3] += MD5M_D
;
6183 case HASH_TYPE_SHA1
:
6184 digest_buf
[0] += SHA1M_A
;
6185 digest_buf
[1] += SHA1M_B
;
6186 digest_buf
[2] += SHA1M_C
;
6187 digest_buf
[3] += SHA1M_D
;
6188 digest_buf
[4] += SHA1M_E
;
6191 case HASH_TYPE_SHA256
:
6192 digest_buf
[0] += SHA256M_A
;
6193 digest_buf
[1] += SHA256M_B
;
6194 digest_buf
[2] += SHA256M_C
;
6195 digest_buf
[3] += SHA256M_D
;
6196 digest_buf
[4] += SHA256M_E
;
6197 digest_buf
[5] += SHA256M_F
;
6198 digest_buf
[6] += SHA256M_G
;
6199 digest_buf
[7] += SHA256M_H
;
6202 case HASH_TYPE_SHA384
:
6203 digest_buf64
[0] += SHA384M_A
;
6204 digest_buf64
[1] += SHA384M_B
;
6205 digest_buf64
[2] += SHA384M_C
;
6206 digest_buf64
[3] += SHA384M_D
;
6207 digest_buf64
[4] += SHA384M_E
;
6208 digest_buf64
[5] += SHA384M_F
;
6209 digest_buf64
[6] += 0;
6210 digest_buf64
[7] += 0;
6213 case HASH_TYPE_SHA512
:
6214 digest_buf64
[0] += SHA512M_A
;
6215 digest_buf64
[1] += SHA512M_B
;
6216 digest_buf64
[2] += SHA512M_C
;
6217 digest_buf64
[3] += SHA512M_D
;
6218 digest_buf64
[4] += SHA512M_E
;
6219 digest_buf64
[5] += SHA512M_F
;
6220 digest_buf64
[6] += SHA512M_G
;
6221 digest_buf64
[7] += SHA512M_H
;
6226 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6228 if (dgst_size
== DGST_SIZE_4_2
)
6230 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6232 else if (dgst_size
== DGST_SIZE_4_4
)
6234 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6236 else if (dgst_size
== DGST_SIZE_4_5
)
6238 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6240 else if (dgst_size
== DGST_SIZE_4_6
)
6242 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6244 else if (dgst_size
== DGST_SIZE_4_8
)
6246 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6248 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6250 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6252 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6254 else if (hash_type
== HASH_TYPE_SHA384
)
6256 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6258 else if (hash_type
== HASH_TYPE_SHA512
)
6260 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6262 else if (hash_type
== HASH_TYPE_GOST
)
6264 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6267 else if (dgst_size
== DGST_SIZE_4_64
)
6269 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6271 else if (dgst_size
== DGST_SIZE_8_25
)
6273 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6277 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6278 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6279 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6285 memset (&salt
, 0, sizeof (salt_t
));
6287 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6289 char *ptr
= (char *) salt
.salt_buf
;
6291 uint len
= salt
.salt_len
;
6293 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6299 case HASH_TYPE_NETNTLM
:
6301 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6302 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6304 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6310 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6312 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6320 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6322 uint max
= salt
.salt_len
/ 4;
6326 for (uint i
= 0; i
< max
; i
++)
6328 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6332 if (opts_type
& OPTS_TYPE_ST_HEX
)
6334 char tmp
[64] = { 0 };
6336 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6338 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6343 memcpy (ptr
, tmp
, len
);
6346 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6348 memset (ptr
+ len
, 0, memset_size
);
6350 salt
.salt_len
= len
;
6354 // some modes require special encoding
6357 uint out_buf_plain
[256] = { 0 };
6358 uint out_buf_salt
[256] = { 0 };
6360 char tmp_buf
[1024] = { 0 };
6362 char *ptr_plain
= (char *) out_buf_plain
;
6363 char *ptr_salt
= (char *) out_buf_salt
;
6365 if (hash_mode
== 22)
6367 char username
[30] = { 0 };
6369 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6371 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6373 u16
*ptr
= (u16
*) digest_buf
;
6375 tmp_buf
[ 0] = sig
[0];
6376 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6377 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6378 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6379 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6380 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6381 tmp_buf
[ 6] = sig
[1];
6382 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6383 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6384 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6385 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6386 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6387 tmp_buf
[12] = sig
[2];
6388 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6389 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6390 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6391 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6392 tmp_buf
[17] = sig
[3];
6393 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6394 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6395 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6396 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6397 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6398 tmp_buf
[23] = sig
[4];
6399 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6400 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6401 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6402 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6403 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6404 tmp_buf
[29] = sig
[5];
6406 snprintf (out_buf
, len
-1, "%s:%s",
6410 else if (hash_mode
== 23)
6412 // do not show the skyper part in output
6414 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6416 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6418 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6425 else if (hash_mode
== 101)
6427 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6429 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6430 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6431 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6432 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6433 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6435 memcpy (tmp_buf
, digest_buf
, 20);
6437 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6439 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6441 else if (hash_mode
== 111)
6443 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6445 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6446 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6447 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6448 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6449 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6451 memcpy (tmp_buf
, digest_buf
, 20);
6452 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6454 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6456 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6458 else if ((hash_mode
== 122) || (hash_mode
== 125))
6460 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6461 (char *) salt
.salt_buf
,
6468 else if (hash_mode
== 124)
6470 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6471 (char *) salt
.salt_buf
,
6478 else if (hash_mode
== 131)
6480 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6481 (char *) salt
.salt_buf
,
6489 else if (hash_mode
== 132)
6491 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6492 (char *) salt
.salt_buf
,
6499 else if (hash_mode
== 133)
6501 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6503 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6504 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6505 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6506 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6507 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6509 memcpy (tmp_buf
, digest_buf
, 20);
6511 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6513 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6515 else if (hash_mode
== 141)
6517 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6519 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6521 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6523 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6525 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6526 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6527 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6528 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6529 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6531 memcpy (tmp_buf
, digest_buf
, 20);
6533 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6537 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6539 else if (hash_mode
== 400)
6541 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6543 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6544 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6545 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6546 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6548 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6550 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6552 else if (hash_mode
== 500)
6554 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6556 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6557 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6558 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6559 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6561 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6563 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6565 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6569 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6572 else if (hash_mode
== 501)
6574 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6576 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6577 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6579 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6581 else if (hash_mode
== 1421)
6583 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6585 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6601 else if (hash_mode
== 1441)
6603 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6605 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6607 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6609 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6611 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6612 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6613 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6614 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6615 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6616 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6617 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6618 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6620 memcpy (tmp_buf
, digest_buf
, 32);
6622 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6626 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6628 else if (hash_mode
== 1500)
6630 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6631 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6632 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6633 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6634 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6636 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6638 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6640 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6641 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6643 memcpy (tmp_buf
, digest_buf
, 8);
6645 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6647 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6651 else if (hash_mode
== 1600)
6653 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6655 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6656 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6657 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6658 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6660 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6662 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6664 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6668 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6671 else if (hash_mode
== 1711)
6673 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6675 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6676 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6677 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6678 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6679 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6680 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6681 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6682 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6684 memcpy (tmp_buf
, digest_buf
, 64);
6685 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6687 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6689 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6691 else if (hash_mode
== 1722)
6693 uint
*ptr
= digest_buf
;
6695 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6696 (unsigned char *) salt
.salt_buf
,
6706 else if (hash_mode
== 1731)
6708 uint
*ptr
= digest_buf
;
6710 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6711 (unsigned char *) salt
.salt_buf
,
6721 else if (hash_mode
== 1800)
6725 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6726 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6727 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6728 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6729 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6730 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6731 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6732 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6734 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6736 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6738 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6742 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6745 else if (hash_mode
== 2100)
6749 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6751 salt
.salt_iter
+ 1);
6753 uint signature_len
= strlen (out_buf
);
6755 pos
+= signature_len
;
6756 len
-= signature_len
;
6758 char *salt_ptr
= (char *) salt
.salt_buf
;
6760 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6762 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6763 byte_swap_32 (digest_buf
[0]),
6764 byte_swap_32 (digest_buf
[1]),
6765 byte_swap_32 (digest_buf
[2]),
6766 byte_swap_32 (digest_buf
[3]));
6768 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6770 memcpy (tmp_buf
, digest_buf
, 16);
6772 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6774 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6775 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6776 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6777 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6779 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6780 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6781 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6782 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6784 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6785 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6786 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6787 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6789 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6790 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6791 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6792 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6794 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6795 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6796 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6797 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6801 else if (hash_mode
== 2500)
6803 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6805 wpa_t
*wpa
= &wpas
[salt_pos
];
6807 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6808 (char *) salt
.salt_buf
,
6822 else if (hash_mode
== 4400)
6824 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6825 byte_swap_32 (digest_buf
[0]),
6826 byte_swap_32 (digest_buf
[1]),
6827 byte_swap_32 (digest_buf
[2]),
6828 byte_swap_32 (digest_buf
[3]));
6830 else if (hash_mode
== 4700)
6832 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6833 byte_swap_32 (digest_buf
[0]),
6834 byte_swap_32 (digest_buf
[1]),
6835 byte_swap_32 (digest_buf
[2]),
6836 byte_swap_32 (digest_buf
[3]),
6837 byte_swap_32 (digest_buf
[4]));
6839 else if (hash_mode
== 4800)
6841 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6843 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6848 byte_swap_32 (salt
.salt_buf
[0]),
6849 byte_swap_32 (salt
.salt_buf
[1]),
6850 byte_swap_32 (salt
.salt_buf
[2]),
6851 byte_swap_32 (salt
.salt_buf
[3]),
6854 else if (hash_mode
== 4900)
6856 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6857 byte_swap_32 (digest_buf
[0]),
6858 byte_swap_32 (digest_buf
[1]),
6859 byte_swap_32 (digest_buf
[2]),
6860 byte_swap_32 (digest_buf
[3]),
6861 byte_swap_32 (digest_buf
[4]));
6863 else if (hash_mode
== 5100)
6865 snprintf (out_buf
, len
-1, "%08x%08x",
6869 else if (hash_mode
== 5200)
6871 snprintf (out_buf
, len
-1, "%s", hashfile
);
6873 else if (hash_mode
== 5300)
6875 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6877 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6879 int buf_len
= len
-1;
6883 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6885 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6887 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6889 snprintf (out_buf
, buf_len
, ":");
6895 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6903 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6905 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6907 if ((i
== 0) || (i
== 5))
6909 snprintf (out_buf
, buf_len
, ":");
6915 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6923 for (uint i
= 0; i
< 4; i
++)
6927 snprintf (out_buf
, buf_len
, ":");
6933 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6939 else if (hash_mode
== 5400)
6941 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6943 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6945 int buf_len
= len
-1;
6949 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6951 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6953 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6955 snprintf (out_buf
, buf_len
, ":");
6961 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6969 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6971 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6973 if ((i
== 0) || (i
== 5))
6975 snprintf (out_buf
, buf_len
, ":");
6981 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6989 for (uint i
= 0; i
< 5; i
++)
6993 snprintf (out_buf
, buf_len
, ":");
6999 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
7005 else if (hash_mode
== 5500)
7007 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7009 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7011 char user_buf
[64] = { 0 };
7012 char domain_buf
[64] = { 0 };
7013 char srvchall_buf
[1024] = { 0 };
7014 char clichall_buf
[1024] = { 0 };
7016 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7018 char *ptr
= (char *) netntlm
->userdomain_buf
;
7020 user_buf
[i
] = ptr
[j
];
7023 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7025 char *ptr
= (char *) netntlm
->userdomain_buf
;
7027 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7030 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7032 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7034 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7037 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7039 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7041 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7044 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7052 byte_swap_32 (salt
.salt_buf_pc
[0]),
7053 byte_swap_32 (salt
.salt_buf_pc
[1]),
7056 else if (hash_mode
== 5600)
7058 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7060 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7062 char user_buf
[64] = { 0 };
7063 char domain_buf
[64] = { 0 };
7064 char srvchall_buf
[1024] = { 0 };
7065 char clichall_buf
[1024] = { 0 };
7067 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7069 char *ptr
= (char *) netntlm
->userdomain_buf
;
7071 user_buf
[i
] = ptr
[j
];
7074 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7076 char *ptr
= (char *) netntlm
->userdomain_buf
;
7078 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7081 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7083 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7085 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7088 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7090 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7092 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7095 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7105 else if (hash_mode
== 5700)
7107 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7109 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7110 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7111 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7112 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7113 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7114 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7115 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7116 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7118 memcpy (tmp_buf
, digest_buf
, 32);
7120 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7124 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7126 else if (hash_mode
== 5800)
7128 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7129 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7130 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7131 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7132 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7134 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7141 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7143 snprintf (out_buf
, len
-1, "%s", hashfile
);
7145 else if (hash_mode
== 6300)
7147 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7149 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7150 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7151 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7152 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7154 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7156 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7158 else if (hash_mode
== 6400)
7160 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7162 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7164 else if (hash_mode
== 6500)
7166 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7168 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7170 else if (hash_mode
== 6600)
7172 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7174 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7176 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7177 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7179 uint buf_len
= len
- 1;
7181 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7184 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7186 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7191 else if (hash_mode
== 6700)
7193 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7195 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7197 else if (hash_mode
== 6800)
7199 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7201 else if (hash_mode
== 7100)
7203 uint
*ptr
= digest_buf
;
7205 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7207 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7209 uint esalt
[8] = { 0 };
7211 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7212 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7213 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7214 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7215 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7216 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7217 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7218 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7220 snprintf (out_buf
, len
-1, "%s%i$%08x%08x%08x%08x%08x%08x%08x%08x$%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7221 SIGNATURE_SHA512OSX
,
7223 esalt
[ 0], esalt
[ 1],
7224 esalt
[ 2], esalt
[ 3],
7225 esalt
[ 4], esalt
[ 5],
7226 esalt
[ 6], esalt
[ 7],
7234 ptr
[15], ptr
[14]);
7236 else if (hash_mode
== 7200)
7238 uint
*ptr
= digest_buf
;
7240 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7242 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7246 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7248 len_used
= strlen (out_buf
);
7250 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7252 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7254 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7257 snprintf (out_buf
+ len_used
, len
- len_used
- 1, ".%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7265 ptr
[15], ptr
[14]);
7267 else if (hash_mode
== 7300)
7269 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7271 rakp_t
*rakp
= &rakps
[salt_pos
];
7273 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7275 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7278 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7285 else if (hash_mode
== 7400)
7287 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7289 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7290 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7291 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7292 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7293 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7294 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7295 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7296 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7298 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7300 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7302 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7306 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7309 else if (hash_mode
== 7500)
7311 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7313 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7315 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7316 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7318 char data
[128] = { 0 };
7320 char *ptr_data
= data
;
7322 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7324 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7327 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7329 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7334 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7336 (char *) krb5pa
->user
,
7337 (char *) krb5pa
->realm
,
7338 (char *) krb5pa
->salt
,
7341 else if (hash_mode
== 7700)
7343 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7344 (char *) salt
.salt_buf
,
7348 else if (hash_mode
== 7800)
7350 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7351 (char *) salt
.salt_buf
,
7358 else if (hash_mode
== 7900)
7360 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7364 char *tmp
= (char *) salt
.salt_buf_pc
;
7366 ptr_plain
[42] = tmp
[0];
7372 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7374 else if (hash_mode
== 8000)
7376 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7377 (unsigned char *) salt
.salt_buf
,
7387 else if (hash_mode
== 8100)
7389 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7390 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7392 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7393 (unsigned char *) salt
.salt_buf
,
7400 else if (hash_mode
== 8200)
7402 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7404 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7406 char data_buf
[4096] = { 0 };
7408 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7410 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7413 data_buf
[cloudkey
->data_len
* 2] = 0;
7415 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7416 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7417 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7418 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7419 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7420 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7421 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7422 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7424 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7425 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7426 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7427 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7429 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7445 else if (hash_mode
== 8300)
7447 char digest_buf_c
[34] = { 0 };
7449 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7450 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7451 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7452 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7453 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7455 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7457 digest_buf_c
[32] = 0;
7461 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7463 char domain_buf_c
[33] = { 0 };
7465 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7467 for (uint i
= 0; i
< salt_pc_len
; i
++)
7469 const char next
= domain_buf_c
[i
];
7471 domain_buf_c
[i
] = '.';
7476 domain_buf_c
[salt_pc_len
] = 0;
7480 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7482 else if (hash_mode
== 8500)
7484 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7486 else if (hash_mode
== 2612)
7488 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7490 (char *) salt
.salt_buf
,
7496 else if (hash_mode
== 3711)
7498 char *salt_ptr
= (char *) salt
.salt_buf
;
7500 salt_ptr
[salt
.salt_len
- 1] = 0;
7502 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7503 SIGNATURE_MEDIAWIKI_B
,
7510 else if (hash_mode
== 8800)
7512 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7514 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7516 char tmp
[3073] = { 0 };
7518 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7520 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7525 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7526 SIGNATURE_ANDROIDFDE
,
7527 byte_swap_32 (salt
.salt_buf
[0]),
7528 byte_swap_32 (salt
.salt_buf
[1]),
7529 byte_swap_32 (salt
.salt_buf
[2]),
7530 byte_swap_32 (salt
.salt_buf
[3]),
7531 byte_swap_32 (digest_buf
[0]),
7532 byte_swap_32 (digest_buf
[1]),
7533 byte_swap_32 (digest_buf
[2]),
7534 byte_swap_32 (digest_buf
[3]),
7537 else if (hash_mode
== 8900)
7539 uint N
= salt
.scrypt_N
;
7540 uint r
= salt
.scrypt_r
;
7541 uint p
= salt
.scrypt_p
;
7543 char base64_salt
[32] = { 0 };
7545 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7547 memset (tmp_buf
, 0, 46);
7549 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7550 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7551 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7552 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7553 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7554 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7555 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7556 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7557 digest_buf
[8] = 0; // needed for base64_encode ()
7559 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7561 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7569 else if (hash_mode
== 9000)
7571 snprintf (out_buf
, len
-1, "%s", hashfile
);
7573 else if (hash_mode
== 9200)
7577 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7579 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7581 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7585 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7586 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7587 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7588 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7589 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7590 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7591 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7592 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7593 digest_buf
[8] = 0; // needed for base64_encode ()
7595 char tmp_buf
[64] = { 0 };
7597 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7598 tmp_buf
[43] = 0; // cut it here
7602 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7604 else if (hash_mode
== 9300)
7606 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7607 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7608 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7609 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7610 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7611 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7612 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7613 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7614 digest_buf
[8] = 0; // needed for base64_encode ()
7616 char tmp_buf
[64] = { 0 };
7618 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7619 tmp_buf
[43] = 0; // cut it here
7621 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7623 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7625 else if (hash_mode
== 9400)
7627 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7629 office2007_t
*office2007
= &office2007s
[salt_pos
];
7631 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7632 SIGNATURE_OFFICE2007
,
7635 office2007
->keySize
,
7641 office2007
->encryptedVerifier
[0],
7642 office2007
->encryptedVerifier
[1],
7643 office2007
->encryptedVerifier
[2],
7644 office2007
->encryptedVerifier
[3],
7645 office2007
->encryptedVerifierHash
[0],
7646 office2007
->encryptedVerifierHash
[1],
7647 office2007
->encryptedVerifierHash
[2],
7648 office2007
->encryptedVerifierHash
[3],
7649 office2007
->encryptedVerifierHash
[4]);
7651 else if (hash_mode
== 9500)
7653 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7655 office2010_t
*office2010
= &office2010s
[salt_pos
];
7657 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x%08x%08x", SIGNATURE_OFFICE2010
, 2010, 100000, 128, 16,
7663 office2010
->encryptedVerifier
[0],
7664 office2010
->encryptedVerifier
[1],
7665 office2010
->encryptedVerifier
[2],
7666 office2010
->encryptedVerifier
[3],
7667 office2010
->encryptedVerifierHash
[0],
7668 office2010
->encryptedVerifierHash
[1],
7669 office2010
->encryptedVerifierHash
[2],
7670 office2010
->encryptedVerifierHash
[3],
7671 office2010
->encryptedVerifierHash
[4],
7672 office2010
->encryptedVerifierHash
[5],
7673 office2010
->encryptedVerifierHash
[6],
7674 office2010
->encryptedVerifierHash
[7]);
7676 else if (hash_mode
== 9600)
7678 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7680 office2013_t
*office2013
= &office2013s
[salt_pos
];
7682 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x%08x%08x", SIGNATURE_OFFICE2013
, 2013, 100000, 256, 16,
7688 office2013
->encryptedVerifier
[0],
7689 office2013
->encryptedVerifier
[1],
7690 office2013
->encryptedVerifier
[2],
7691 office2013
->encryptedVerifier
[3],
7692 office2013
->encryptedVerifierHash
[0],
7693 office2013
->encryptedVerifierHash
[1],
7694 office2013
->encryptedVerifierHash
[2],
7695 office2013
->encryptedVerifierHash
[3],
7696 office2013
->encryptedVerifierHash
[4],
7697 office2013
->encryptedVerifierHash
[5],
7698 office2013
->encryptedVerifierHash
[6],
7699 office2013
->encryptedVerifierHash
[7]);
7701 else if (hash_mode
== 9700)
7703 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7705 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7707 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7708 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7709 byte_swap_32 (salt
.salt_buf
[0]),
7710 byte_swap_32 (salt
.salt_buf
[1]),
7711 byte_swap_32 (salt
.salt_buf
[2]),
7712 byte_swap_32 (salt
.salt_buf
[3]),
7713 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7714 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7715 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7716 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7717 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7718 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7719 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7720 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7722 else if (hash_mode
== 9710)
7724 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7726 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7728 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7729 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7730 byte_swap_32 (salt
.salt_buf
[0]),
7731 byte_swap_32 (salt
.salt_buf
[1]),
7732 byte_swap_32 (salt
.salt_buf
[2]),
7733 byte_swap_32 (salt
.salt_buf
[3]),
7734 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7735 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7736 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7737 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7738 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7739 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7740 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7741 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7743 else if (hash_mode
== 9720)
7745 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7747 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7749 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7751 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7752 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7753 byte_swap_32 (salt
.salt_buf
[0]),
7754 byte_swap_32 (salt
.salt_buf
[1]),
7755 byte_swap_32 (salt
.salt_buf
[2]),
7756 byte_swap_32 (salt
.salt_buf
[3]),
7757 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7758 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7759 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7760 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7761 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7762 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7763 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7764 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7771 else if (hash_mode
== 9800)
7773 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7775 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7777 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7778 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7783 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7784 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7785 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7786 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7787 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7788 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7789 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7790 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7791 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7793 else if (hash_mode
== 9810)
7795 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7797 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7799 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7800 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7805 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7806 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7807 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7808 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7809 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7810 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7811 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7812 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7813 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7815 else if (hash_mode
== 9820)
7817 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7819 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7821 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7823 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7824 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7829 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7830 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7831 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7832 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7833 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7834 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7835 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7836 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7837 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7844 else if (hash_mode
== 10000)
7848 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7850 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7852 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7856 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7857 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7858 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7859 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7860 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7861 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7862 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7863 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7864 digest_buf
[8] = 0; // needed for base64_encode ()
7866 char tmp_buf
[64] = { 0 };
7868 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7872 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7874 else if (hash_mode
== 10100)
7876 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7881 byte_swap_32 (salt
.salt_buf
[0]),
7882 byte_swap_32 (salt
.salt_buf
[1]),
7883 byte_swap_32 (salt
.salt_buf
[2]),
7884 byte_swap_32 (salt
.salt_buf
[3]));
7886 else if (hash_mode
== 10200)
7888 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7890 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7894 char challenge
[100] = { 0 };
7896 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7900 char tmp_buf
[100] = { 0 };
7902 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7903 (char *) cram_md5
->user
,
7909 char response
[100] = { 0 };
7911 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7913 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7915 else if (hash_mode
== 10300)
7917 char tmp_buf
[100] = { 0 };
7919 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7920 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7922 uint tmp_len
= 20 + salt
.salt_len
;
7926 char base64_encoded
[100] = { 0 };
7928 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7930 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7932 else if (hash_mode
== 10400)
7934 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7936 pdf_t
*pdf
= &pdfs
[salt_pos
];
7938 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7946 byte_swap_32 (pdf
->id_buf
[0]),
7947 byte_swap_32 (pdf
->id_buf
[1]),
7948 byte_swap_32 (pdf
->id_buf
[2]),
7949 byte_swap_32 (pdf
->id_buf
[3]),
7951 byte_swap_32 (pdf
->u_buf
[0]),
7952 byte_swap_32 (pdf
->u_buf
[1]),
7953 byte_swap_32 (pdf
->u_buf
[2]),
7954 byte_swap_32 (pdf
->u_buf
[3]),
7955 byte_swap_32 (pdf
->u_buf
[4]),
7956 byte_swap_32 (pdf
->u_buf
[5]),
7957 byte_swap_32 (pdf
->u_buf
[6]),
7958 byte_swap_32 (pdf
->u_buf
[7]),
7960 byte_swap_32 (pdf
->o_buf
[0]),
7961 byte_swap_32 (pdf
->o_buf
[1]),
7962 byte_swap_32 (pdf
->o_buf
[2]),
7963 byte_swap_32 (pdf
->o_buf
[3]),
7964 byte_swap_32 (pdf
->o_buf
[4]),
7965 byte_swap_32 (pdf
->o_buf
[5]),
7966 byte_swap_32 (pdf
->o_buf
[6]),
7967 byte_swap_32 (pdf
->o_buf
[7])
7970 else if (hash_mode
== 10410)
7972 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7974 pdf_t
*pdf
= &pdfs
[salt_pos
];
7976 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7984 byte_swap_32 (pdf
->id_buf
[0]),
7985 byte_swap_32 (pdf
->id_buf
[1]),
7986 byte_swap_32 (pdf
->id_buf
[2]),
7987 byte_swap_32 (pdf
->id_buf
[3]),
7989 byte_swap_32 (pdf
->u_buf
[0]),
7990 byte_swap_32 (pdf
->u_buf
[1]),
7991 byte_swap_32 (pdf
->u_buf
[2]),
7992 byte_swap_32 (pdf
->u_buf
[3]),
7993 byte_swap_32 (pdf
->u_buf
[4]),
7994 byte_swap_32 (pdf
->u_buf
[5]),
7995 byte_swap_32 (pdf
->u_buf
[6]),
7996 byte_swap_32 (pdf
->u_buf
[7]),
7998 byte_swap_32 (pdf
->o_buf
[0]),
7999 byte_swap_32 (pdf
->o_buf
[1]),
8000 byte_swap_32 (pdf
->o_buf
[2]),
8001 byte_swap_32 (pdf
->o_buf
[3]),
8002 byte_swap_32 (pdf
->o_buf
[4]),
8003 byte_swap_32 (pdf
->o_buf
[5]),
8004 byte_swap_32 (pdf
->o_buf
[6]),
8005 byte_swap_32 (pdf
->o_buf
[7])
8008 else if (hash_mode
== 10420)
8010 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8012 pdf_t
*pdf
= &pdfs
[salt_pos
];
8014 u8
*rc4key
= (u8
*) pdf
->rc4key
;
8016 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
8024 byte_swap_32 (pdf
->id_buf
[0]),
8025 byte_swap_32 (pdf
->id_buf
[1]),
8026 byte_swap_32 (pdf
->id_buf
[2]),
8027 byte_swap_32 (pdf
->id_buf
[3]),
8029 byte_swap_32 (pdf
->u_buf
[0]),
8030 byte_swap_32 (pdf
->u_buf
[1]),
8031 byte_swap_32 (pdf
->u_buf
[2]),
8032 byte_swap_32 (pdf
->u_buf
[3]),
8033 byte_swap_32 (pdf
->u_buf
[4]),
8034 byte_swap_32 (pdf
->u_buf
[5]),
8035 byte_swap_32 (pdf
->u_buf
[6]),
8036 byte_swap_32 (pdf
->u_buf
[7]),
8038 byte_swap_32 (pdf
->o_buf
[0]),
8039 byte_swap_32 (pdf
->o_buf
[1]),
8040 byte_swap_32 (pdf
->o_buf
[2]),
8041 byte_swap_32 (pdf
->o_buf
[3]),
8042 byte_swap_32 (pdf
->o_buf
[4]),
8043 byte_swap_32 (pdf
->o_buf
[5]),
8044 byte_swap_32 (pdf
->o_buf
[6]),
8045 byte_swap_32 (pdf
->o_buf
[7]),
8053 else if (hash_mode
== 10500)
8055 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8057 pdf_t
*pdf
= &pdfs
[salt_pos
];
8059 if (pdf
->id_len
== 32)
8061 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
8069 byte_swap_32 (pdf
->id_buf
[0]),
8070 byte_swap_32 (pdf
->id_buf
[1]),
8071 byte_swap_32 (pdf
->id_buf
[2]),
8072 byte_swap_32 (pdf
->id_buf
[3]),
8073 byte_swap_32 (pdf
->id_buf
[4]),
8074 byte_swap_32 (pdf
->id_buf
[5]),
8075 byte_swap_32 (pdf
->id_buf
[6]),
8076 byte_swap_32 (pdf
->id_buf
[7]),
8078 byte_swap_32 (pdf
->u_buf
[0]),
8079 byte_swap_32 (pdf
->u_buf
[1]),
8080 byte_swap_32 (pdf
->u_buf
[2]),
8081 byte_swap_32 (pdf
->u_buf
[3]),
8082 byte_swap_32 (pdf
->u_buf
[4]),
8083 byte_swap_32 (pdf
->u_buf
[5]),
8084 byte_swap_32 (pdf
->u_buf
[6]),
8085 byte_swap_32 (pdf
->u_buf
[7]),
8087 byte_swap_32 (pdf
->o_buf
[0]),
8088 byte_swap_32 (pdf
->o_buf
[1]),
8089 byte_swap_32 (pdf
->o_buf
[2]),
8090 byte_swap_32 (pdf
->o_buf
[3]),
8091 byte_swap_32 (pdf
->o_buf
[4]),
8092 byte_swap_32 (pdf
->o_buf
[5]),
8093 byte_swap_32 (pdf
->o_buf
[6]),
8094 byte_swap_32 (pdf
->o_buf
[7])
8099 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
8107 byte_swap_32 (pdf
->id_buf
[0]),
8108 byte_swap_32 (pdf
->id_buf
[1]),
8109 byte_swap_32 (pdf
->id_buf
[2]),
8110 byte_swap_32 (pdf
->id_buf
[3]),
8112 byte_swap_32 (pdf
->u_buf
[0]),
8113 byte_swap_32 (pdf
->u_buf
[1]),
8114 byte_swap_32 (pdf
->u_buf
[2]),
8115 byte_swap_32 (pdf
->u_buf
[3]),
8116 byte_swap_32 (pdf
->u_buf
[4]),
8117 byte_swap_32 (pdf
->u_buf
[5]),
8118 byte_swap_32 (pdf
->u_buf
[6]),
8119 byte_swap_32 (pdf
->u_buf
[7]),
8121 byte_swap_32 (pdf
->o_buf
[0]),
8122 byte_swap_32 (pdf
->o_buf
[1]),
8123 byte_swap_32 (pdf
->o_buf
[2]),
8124 byte_swap_32 (pdf
->o_buf
[3]),
8125 byte_swap_32 (pdf
->o_buf
[4]),
8126 byte_swap_32 (pdf
->o_buf
[5]),
8127 byte_swap_32 (pdf
->o_buf
[6]),
8128 byte_swap_32 (pdf
->o_buf
[7])
8132 else if (hash_mode
== 10600)
8134 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8136 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8137 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8139 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8141 else if (hash_mode
== 10700)
8143 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8145 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8146 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8148 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8150 else if (hash_mode
== 10900)
8152 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8154 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8155 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8157 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8159 else if (hash_mode
== 11100)
8161 u32 salt_challenge
= salt
.salt_buf
[0];
8163 salt_challenge
= byte_swap_32 (salt_challenge
);
8165 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8167 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8168 SIGNATURE_POSTGRESQL_AUTH
,
8176 else if (hash_mode
== 11200)
8178 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8179 SIGNATURE_MYSQL_AUTH
,
8180 (unsigned char *) salt
.salt_buf
,
8187 else if (hash_mode
== 11300)
8189 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8191 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8193 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8194 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8195 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8197 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8198 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8199 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8201 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8203 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8205 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8208 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8210 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8212 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8215 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8217 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8219 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8222 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8223 SIGNATURE_BITCOIN_WALLET
,
8227 (unsigned char *) salt
.salt_buf
,
8235 free (cry_master_buf
);
8237 free (public_key_buf
);
8239 else if (hash_mode
== 11400)
8241 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8243 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8244 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8246 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8248 else if (hash_mode
== 11600)
8250 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8252 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8254 const uint data_len
= seven_zip
->data_len
;
8256 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8258 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8260 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8262 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8265 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8266 SIGNATURE_SEVEN_ZIP
,
8270 (char *) seven_zip
->salt_buf
,
8272 seven_zip
->iv_buf
[0],
8273 seven_zip
->iv_buf
[1],
8274 seven_zip
->iv_buf
[2],
8275 seven_zip
->iv_buf
[3],
8277 seven_zip
->data_len
,
8278 seven_zip
->unpack_size
,
8283 else if (hash_mode
== 11700)
8285 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8295 else if (hash_mode
== 11800)
8297 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8315 else if (hash_mode
== 11900)
8317 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8319 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8320 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8322 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8324 else if (hash_mode
== 12000)
8326 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8328 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8329 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8331 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8333 else if (hash_mode
== 12100)
8335 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8337 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8338 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8340 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8342 else if (hash_mode
== 12200)
8344 uint
*ptr_digest
= digest_buf
;
8345 uint
*ptr_salt
= salt
.salt_buf
;
8347 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8354 else if (hash_mode
== 12300)
8356 uint
*ptr_digest
= digest_buf
;
8357 uint
*ptr_salt
= salt
.salt_buf
;
8359 snprintf (out_buf
, len
-1, "%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X",
8360 ptr_digest
[ 0], ptr_digest
[ 1],
8361 ptr_digest
[ 2], ptr_digest
[ 3],
8362 ptr_digest
[ 4], ptr_digest
[ 5],
8363 ptr_digest
[ 6], ptr_digest
[ 7],
8364 ptr_digest
[ 8], ptr_digest
[ 9],
8365 ptr_digest
[10], ptr_digest
[11],
8366 ptr_digest
[12], ptr_digest
[13],
8367 ptr_digest
[14], ptr_digest
[15],
8373 else if (hash_mode
== 12400)
8375 // encode iteration count
8377 char salt_iter
[5] = { 0 };
8379 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8380 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8381 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8382 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8387 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8388 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8389 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8390 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8395 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8397 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8398 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8400 memcpy (tmp_buf
, digest_buf
, 8);
8402 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8406 // fill the resulting buffer
8408 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8410 else if (hash_mode
== 12500)
8412 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8414 byte_swap_32 (salt
.salt_buf
[0]),
8415 byte_swap_32 (salt
.salt_buf
[1]),
8421 else if (hash_mode
== 12600)
8423 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8424 digest_buf
[0] + salt
.salt_buf_pc
[0],
8425 digest_buf
[1] + salt
.salt_buf_pc
[1],
8426 digest_buf
[2] + salt
.salt_buf_pc
[2],
8427 digest_buf
[3] + salt
.salt_buf_pc
[3],
8428 digest_buf
[4] + salt
.salt_buf_pc
[4],
8429 digest_buf
[5] + salt
.salt_buf_pc
[5],
8430 digest_buf
[6] + salt
.salt_buf_pc
[6],
8431 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8433 else if (hash_mode
== 12700)
8435 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8437 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8438 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8440 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8442 else if (hash_mode
== 12800)
8444 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8446 snprintf (out_buf
, len
-1, "%s,%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x,%d,%08x%08x%08x%08x%08x%08x%08x%08x",
8459 byte_swap_32 (digest_buf
[0]),
8460 byte_swap_32 (digest_buf
[1]),
8461 byte_swap_32 (digest_buf
[2]),
8462 byte_swap_32 (digest_buf
[3]),
8463 byte_swap_32 (digest_buf
[4]),
8464 byte_swap_32 (digest_buf
[5]),
8465 byte_swap_32 (digest_buf
[6]),
8466 byte_swap_32 (digest_buf
[7])
8469 else if (hash_mode
== 12900)
8471 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8480 byte_swap_32 (digest_buf
[0]),
8481 byte_swap_32 (digest_buf
[1]),
8482 byte_swap_32 (digest_buf
[2]),
8483 byte_swap_32 (digest_buf
[3]),
8484 byte_swap_32 (digest_buf
[4]),
8485 byte_swap_32 (digest_buf
[5]),
8486 byte_swap_32 (digest_buf
[6]),
8487 byte_swap_32 (digest_buf
[7]),
8494 else if (hash_mode
== 13000)
8496 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8498 rar5_t
*rar5
= &rar5s
[salt_pos
];
8500 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8510 byte_swap_32 (digest_buf
[0]),
8511 byte_swap_32 (digest_buf
[1])
8514 else if (hash_mode
== 13100)
8516 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8518 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8520 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8521 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8523 char data
[2560 * 4 * 2] = { 0 };
8525 char *ptr_data
= data
;
8527 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8528 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8533 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8534 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8536 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8538 (char *) krb5tgs
->account_info
,
8542 else if (hash_mode
== 13200)
8544 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8558 else if (hash_mode
== 13300)
8560 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8561 SIGNATURE_AXCRYPT_SHA1
,
8567 else if (hash_mode
== 13400)
8569 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8571 keepass_t
*keepass
= &keepasss
[salt_pos
];
8573 u32 version
= (u32
) keepass
->version
;
8574 u32 rounds
= salt
.salt_iter
;
8575 u32 algorithm
= (u32
) keepass
->algorithm
;
8576 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8578 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8579 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8580 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8581 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8582 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8584 /* specific to version 1 */
8588 /* specific to version 2 */
8589 u32 expected_bytes_len
;
8590 u32
*ptr_expected_bytes
;
8592 u32 final_random_seed_len
;
8593 u32 transf_random_seed_len
;
8595 u32 contents_hash_len
;
8597 transf_random_seed_len
= 8;
8599 contents_hash_len
= 8;
8600 final_random_seed_len
= 8;
8603 final_random_seed_len
= 4;
8605 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8611 char *ptr_data
= out_buf
;
8613 ptr_data
+= strlen(out_buf
);
8618 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8619 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8624 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8625 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8630 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8631 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8638 contents_len
= (u32
) keepass
->contents_len
;
8639 ptr_contents
= (u32
*) keepass
->contents
;
8641 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8642 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8654 char ptr_contents_len
[10] = { 0 };
8656 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8658 sprintf (ptr_data
, "%d", contents_len
);
8660 ptr_data
+= strlen(ptr_contents_len
);
8665 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8666 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8668 else if (version
== 2)
8670 expected_bytes_len
= 8;
8671 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8673 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8674 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8679 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8680 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8694 sprintf (ptr_data
, "%d", keyfile_len
);
8701 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8702 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8705 else if (hash_mode
== 13500)
8707 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8709 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8711 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8713 char pstoken_tmp
[1024 + 1] = { 0 };
8715 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8717 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8719 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8722 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8730 else if (hash_mode
== 13600)
8732 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8734 zip2_t
*zip2
= &zip2s
[salt_pos
];
8736 const u32 salt_len
= zip2
->salt_len
;
8738 char salt_tmp
[32 + 1] = { 0 };
8740 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8742 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8744 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8747 const u32 data_len
= zip2
->data_len
;
8749 char data_tmp
[8192 + 1] = { 0 };
8751 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8753 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8755 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8758 const u32 auth_len
= zip2
->auth_len
;
8760 char auth_tmp
[20 + 1] = { 0 };
8762 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8764 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8766 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8769 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8770 SIGNATURE_ZIP2_START
,
8776 zip2
->compress_length
,
8779 SIGNATURE_ZIP2_STOP
);
8781 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8783 snprintf (out_buf
, len
-1, "%s", hashfile
);
8785 else if (hash_mode
== 13800)
8787 win8phone_t
*esalts
= (win8phone_t
*) data
.esalts_buf
;
8789 win8phone_t
*esalt
= &esalts
[salt_pos
];
8791 char buf
[256 + 1] = { 0 };
8793 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
8795 sprintf (buf
+ j
, "%08x", esalt
->salt_buf
[i
]);
8798 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%s",
8811 if (hash_type
== HASH_TYPE_MD4
)
8813 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8819 else if (hash_type
== HASH_TYPE_MD5
)
8821 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8827 else if (hash_type
== HASH_TYPE_SHA1
)
8829 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8836 else if (hash_type
== HASH_TYPE_SHA256
)
8838 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8848 else if (hash_type
== HASH_TYPE_SHA384
)
8850 uint
*ptr
= digest_buf
;
8852 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8860 else if (hash_type
== HASH_TYPE_SHA512
)
8862 uint
*ptr
= digest_buf
;
8864 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8874 else if (hash_type
== HASH_TYPE_LM
)
8876 snprintf (out_buf
, len
-1, "%08x%08x",
8880 else if (hash_type
== HASH_TYPE_ORACLEH
)
8882 snprintf (out_buf
, len
-1, "%08X%08X",
8886 else if (hash_type
== HASH_TYPE_BCRYPT
)
8888 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8889 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8891 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8893 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8895 else if (hash_type
== HASH_TYPE_KECCAK
)
8897 uint
*ptr
= digest_buf
;
8899 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8927 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8929 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8931 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8938 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8940 digest_buf
[ 0] = digest_buf
[ 0];
8941 digest_buf
[ 1] = digest_buf
[ 1];
8942 digest_buf
[ 2] = digest_buf
[ 2];
8943 digest_buf
[ 3] = digest_buf
[ 3];
8944 digest_buf
[ 4] = digest_buf
[ 4];
8945 digest_buf
[ 5] = digest_buf
[ 5];
8946 digest_buf
[ 6] = digest_buf
[ 6];
8947 digest_buf
[ 7] = digest_buf
[ 7];
8948 digest_buf
[ 8] = digest_buf
[ 8];
8949 digest_buf
[ 9] = digest_buf
[ 9];
8950 digest_buf
[10] = digest_buf
[10];
8951 digest_buf
[11] = digest_buf
[11];
8952 digest_buf
[12] = digest_buf
[12];
8953 digest_buf
[13] = digest_buf
[13];
8954 digest_buf
[14] = digest_buf
[14];
8955 digest_buf
[15] = digest_buf
[15];
8957 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8975 else if (hash_type
== HASH_TYPE_GOST
)
8977 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8987 else if (hash_type
== HASH_TYPE_MYSQL
)
8989 snprintf (out_buf
, len
-1, "%08x%08x",
8993 else if (hash_type
== HASH_TYPE_LOTUS5
)
8995 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
9001 else if (hash_type
== HASH_TYPE_LOTUS6
)
9003 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
9004 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
9005 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
9006 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
9008 char buf
[16] = { 0 };
9010 memcpy (buf
+ 0, salt
.salt_buf
, 5);
9011 memcpy (buf
+ 5, digest_buf
, 9);
9015 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
9017 tmp_buf
[18] = salt
.salt_buf_pc
[7];
9020 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
9022 else if (hash_type
== HASH_TYPE_LOTUS8
)
9024 char buf
[52] = { 0 };
9028 memcpy (buf
+ 0, salt
.salt_buf
, 16);
9034 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
9038 buf
[26] = salt
.salt_buf_pc
[0];
9039 buf
[27] = salt
.salt_buf_pc
[1];
9043 memcpy (buf
+ 28, digest_buf
, 8);
9045 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9049 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9051 else if (hash_type
== HASH_TYPE_CRC32
)
9053 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9057 if (salt_type
== SALT_TYPE_INTERN
)
9059 size_t pos
= strlen (out_buf
);
9061 out_buf
[pos
] = data
.separator
;
9063 char *ptr
= (char *) salt
.salt_buf
;
9065 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9067 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9071 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9073 memset (hccap
, 0, sizeof (hccap_t
));
9075 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9077 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9079 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9080 wpa_t
*wpa
= &wpas
[salt_pos
];
9082 hccap
->keyver
= wpa
->keyver
;
9084 hccap
->eapol_size
= wpa
->eapol_size
;
9086 if (wpa
->keyver
!= 1)
9088 uint eapol_tmp
[64] = { 0 };
9090 for (uint i
= 0; i
< 64; i
++)
9092 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9095 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9099 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9102 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9103 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9104 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9105 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9107 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9109 uint dgst_size
= data
.dgst_size
;
9111 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9113 if (wpa
->keyver
!= 1)
9115 uint digest_tmp
[4] = { 0 };
9117 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9118 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9119 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9120 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9122 memcpy (hccap
->keymic
, digest_tmp
, 16);
9126 memcpy (hccap
->keymic
, digest_ptr
, 16);
9130 void SuspendThreads ()
9132 if (data
.devices_status
== STATUS_RUNNING
)
9134 hc_timer_set (&data
.timer_paused
);
9136 data
.devices_status
= STATUS_PAUSED
;
9138 log_info ("Paused");
9142 void ResumeThreads ()
9144 if (data
.devices_status
== STATUS_PAUSED
)
9148 hc_timer_get (data
.timer_paused
, ms_paused
);
9150 data
.ms_paused
+= ms_paused
;
9152 data
.devices_status
= STATUS_RUNNING
;
9154 log_info ("Resumed");
9160 if (data
.devices_status
!= STATUS_RUNNING
) return;
9162 data
.devices_status
= STATUS_BYPASS
;
9164 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9167 void stop_at_checkpoint ()
9169 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9171 if (data
.devices_status
!= STATUS_RUNNING
) return;
9174 // this feature only makes sense if --restore-disable was not specified
9176 if (data
.restore_disable
== 1)
9178 log_info ("WARNING: This feature is disabled when --restore-disable is specified");
9183 // check if monitoring of Restore Point updates should be enabled or disabled
9185 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9187 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9189 // save the current restore point value
9191 data
.checkpoint_cur_words
= get_lowest_words_done ();
9193 log_info ("Checkpoint enabled: Will quit at next Restore Point update");
9197 data
.devices_status
= STATUS_RUNNING
;
9199 // reset the global value for checkpoint checks
9201 data
.checkpoint_cur_words
= 0;
9203 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9209 if (data
.devices_status
== STATUS_INIT
) return;
9210 if (data
.devices_status
== STATUS_STARTING
) return;
9212 data
.devices_status
= STATUS_ABORTED
;
9217 if (data
.devices_status
== STATUS_INIT
) return;
9218 if (data
.devices_status
== STATUS_STARTING
) return;
9220 data
.devices_status
= STATUS_QUIT
;
9223 void naive_escape (const char *cpath_real
, char *cpath_escaped
)
9225 const size_t len
= MIN (strlen (cpath_real
), 1024);
9227 for (size_t in
= 0, out
= 0; in
< len
; in
++, out
++)
9229 const u8 c
= cpath_real
[in
];
9234 cpath_escaped
[out
] = '^';
9236 cpath_escaped
[out
] = '\\';
9242 cpath_escaped
[out
] = c
;
9246 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9248 FILE *fp
= fopen (kernel_file
, "rb");
9254 memset (&st
, 0, sizeof (st
));
9256 stat (kernel_file
, &st
);
9258 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9260 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9262 if (num_read
!= (size_t) st
.st_size
)
9264 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9271 buf
[st
.st_size
] = 0;
9273 for (int i
= 0; i
< num_devices
; i
++)
9275 kernel_lengths
[i
] = (size_t) st
.st_size
;
9277 kernel_sources
[i
] = buf
;
9282 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9290 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9292 if (binary_size
> 0)
9294 FILE *fp
= fopen (dst
, "wb");
9297 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9308 restore_data_t
*init_restore (int argc
, char **argv
)
9310 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9312 if (data
.restore_disable
== 0)
9314 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9318 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9322 log_error ("ERROR: Cannot read %s", data
.eff_restore_file
);
9331 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9333 int pidbin_len
= -1;
9336 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9338 FILE *fd
= fopen (pidbin
, "rb");
9342 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9344 pidbin
[pidbin_len
] = 0;
9348 char *argv0_r
= strrchr (argv
[0], '/');
9350 char *pidbin_r
= strrchr (pidbin
, '/');
9352 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9354 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9356 if (strcmp (argv0_r
, pidbin_r
) == 0)
9358 log_error ("ERROR: Already an instance %s running on pid %d", pidbin
, rd
->pid
);
9365 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9367 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9369 int pidbin2_len
= -1;
9371 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9372 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9374 pidbin
[pidbin_len
] = 0;
9375 pidbin2
[pidbin2_len
] = 0;
9379 if (strcmp (pidbin
, pidbin2
) == 0)
9381 log_error ("ERROR: Already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9394 if (rd
->version_bin
< RESTORE_MIN
)
9396 log_error ("ERROR: Cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9403 memset (rd
, 0, sizeof (restore_data_t
));
9405 rd
->version_bin
= VERSION_BIN
;
9408 rd
->pid
= getpid ();
9410 rd
->pid
= GetCurrentProcessId ();
9413 if (getcwd (rd
->cwd
, 255) == NULL
)
9426 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9428 FILE *fp
= fopen (eff_restore_file
, "rb");
9432 log_error ("ERROR: Restore file '%s': %s", eff_restore_file
, strerror (errno
));
9437 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9439 log_error ("ERROR: Can't read %s", eff_restore_file
);
9444 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9446 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9448 for (uint i
= 0; i
< rd
->argc
; i
++)
9450 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9452 log_error ("ERROR: Can't read %s", eff_restore_file
);
9457 size_t len
= strlen (buf
);
9459 if (len
) buf
[len
- 1] = 0;
9461 rd
->argv
[i
] = mystrdup (buf
);
9468 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9470 if (chdir (rd
->cwd
))
9472 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9473 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9474 " https://github.com/philsmd/analyze_hc_restore\n"
9475 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9481 u64
get_lowest_words_done ()
9485 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9487 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9489 if (device_param
->skipped
) continue;
9491 const u64 words_done
= device_param
->words_done
;
9493 if (words_done
< words_cur
) words_cur
= words_done
;
9496 // It's possible that a device's workload isn't finished right after a restore-case.
9497 // In that case, this function would return 0 and overwrite the real restore point
9498 // There's also data.words_cur which is set to rd->words_cur but it changes while
9499 // the attack is running therefore we should stick to rd->words_cur.
9500 // Note that -s influences rd->words_cur we should keep a close look on that.
9502 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9507 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9509 u64 words_cur
= get_lowest_words_done ();
9511 rd
->words_cur
= words_cur
;
9513 FILE *fp
= fopen (new_restore_file
, "wb");
9517 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9522 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9524 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9529 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9531 for (uint i
= 0; i
< rd
->argc
; i
++)
9533 fprintf (fp
, "%s", rd
->argv
[i
]);
9539 fsync (fileno (fp
));
9544 void cycle_restore ()
9546 const char *eff_restore_file
= data
.eff_restore_file
;
9547 const char *new_restore_file
= data
.new_restore_file
;
9549 restore_data_t
*rd
= data
.rd
;
9551 write_restore (new_restore_file
, rd
);
9555 memset (&st
, 0, sizeof(st
));
9557 if (stat (eff_restore_file
, &st
) == 0)
9559 if (unlink (eff_restore_file
))
9561 log_info ("WARN: Unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9565 if (rename (new_restore_file
, eff_restore_file
))
9567 log_info ("WARN: Rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9571 void check_checkpoint ()
9573 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9575 u64 words_cur
= get_lowest_words_done ();
9577 if (words_cur
!= data
.checkpoint_cur_words
)
9587 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9591 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9593 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9595 myfree (alias
->device_name
);
9596 myfree (alias
->alias_name
);
9599 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9601 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9603 myfree (entry
->device_name
);
9606 myfree (tuning_db
->alias_buf
);
9607 myfree (tuning_db
->entry_buf
);
9612 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9614 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9616 int num_lines
= count_lines (fp
);
9618 // a bit over-allocated
9620 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9621 tuning_db
->alias_cnt
= 0;
9623 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9624 tuning_db
->entry_cnt
= 0;
9629 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9631 FILE *fp
= fopen (tuning_db_file
, "rb");
9635 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9640 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9646 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9650 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9652 if (line_buf
== NULL
) break;
9656 const int line_len
= in_superchop (line_buf
);
9658 if (line_len
== 0) continue;
9660 if (line_buf
[0] == '#') continue;
9664 char *token_ptr
[7] = { NULL
};
9668 char *next
= strtok (line_buf
, "\t ");
9670 token_ptr
[token_cnt
] = next
;
9674 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9676 token_ptr
[token_cnt
] = next
;
9683 char *device_name
= token_ptr
[0];
9684 char *alias_name
= token_ptr
[1];
9686 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9688 alias
->device_name
= mystrdup (device_name
);
9689 alias
->alias_name
= mystrdup (alias_name
);
9691 tuning_db
->alias_cnt
++;
9693 else if (token_cnt
== 6)
9695 if ((token_ptr
[1][0] != '0') &&
9696 (token_ptr
[1][0] != '1') &&
9697 (token_ptr
[1][0] != '3') &&
9698 (token_ptr
[1][0] != '*'))
9700 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9705 if ((token_ptr
[3][0] != '1') &&
9706 (token_ptr
[3][0] != '2') &&
9707 (token_ptr
[3][0] != '4') &&
9708 (token_ptr
[3][0] != '8') &&
9709 (token_ptr
[3][0] != 'N'))
9711 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9716 char *device_name
= token_ptr
[0];
9718 int attack_mode
= -1;
9720 int vector_width
= -1;
9721 int kernel_accel
= -1;
9722 int kernel_loops
= -1;
9724 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9725 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9726 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9728 if (token_ptr
[4][0] != 'A')
9730 kernel_accel
= atoi (token_ptr
[4]);
9732 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9734 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9744 if (token_ptr
[5][0] != 'A')
9746 kernel_loops
= atoi (token_ptr
[5]);
9748 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9750 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9760 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9762 entry
->device_name
= mystrdup (device_name
);
9763 entry
->attack_mode
= attack_mode
;
9764 entry
->hash_type
= hash_type
;
9765 entry
->vector_width
= vector_width
;
9766 entry
->kernel_accel
= kernel_accel
;
9767 entry
->kernel_loops
= kernel_loops
;
9769 tuning_db
->entry_cnt
++;
9773 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9783 // todo: print loaded 'cnt' message
9785 // sort the database
9787 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9788 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9793 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9795 static tuning_db_entry_t s
;
9797 // first we need to convert all spaces in the device_name to underscore
9799 char *device_name_nospace
= strdup (device_param
->device_name
);
9801 int device_name_length
= strlen (device_name_nospace
);
9805 for (i
= 0; i
< device_name_length
; i
++)
9807 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9810 // find out if there's an alias configured
9812 tuning_db_alias_t a
;
9814 a
.device_name
= device_name_nospace
;
9816 tuning_db_alias_t
*alias
= bsearch (&a
, tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9818 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9820 // attack-mode 6 and 7 are attack-mode 1 basically
9822 if (attack_mode
== 6) attack_mode
= 1;
9823 if (attack_mode
== 7) attack_mode
= 1;
9825 // bsearch is not ideal but fast enough
9827 s
.device_name
= device_name_nospace
;
9828 s
.attack_mode
= attack_mode
;
9829 s
.hash_type
= hash_type
;
9831 tuning_db_entry_t
*entry
= NULL
;
9833 // this will produce all 2^3 combinations required
9835 for (i
= 0; i
< 8; i
++)
9837 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9838 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9839 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9841 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9843 if (entry
!= NULL
) break;
9845 // in non-wildcard mode do some additional checks:
9849 // in case we have an alias-name
9851 if (alias_name
!= NULL
)
9853 s
.device_name
= alias_name
;
9855 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9857 if (entry
!= NULL
) break;
9860 // or by device type
9862 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9864 s
.device_name
= "DEVICE_TYPE_CPU";
9866 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9868 s
.device_name
= "DEVICE_TYPE_GPU";
9870 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9872 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9875 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9877 if (entry
!= NULL
) break;
9881 // free converted device_name
9883 myfree (device_name_nospace
);
9892 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9894 u8 tmp
[256] = { 0 };
9896 if (salt_len
> sizeof (tmp
))
9901 memcpy (tmp
, in
, salt_len
);
9903 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9905 if ((salt_len
% 2) == 0)
9907 u32 new_salt_len
= salt_len
/ 2;
9909 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9914 tmp
[i
] = hex_convert (p1
) << 0;
9915 tmp
[i
] |= hex_convert (p0
) << 4;
9918 salt_len
= new_salt_len
;
9925 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9927 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9930 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9932 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9936 u32
*tmp_uint
= (u32
*) tmp
;
9938 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9939 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9940 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9941 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9942 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9943 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9944 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9945 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9946 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9947 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9949 salt_len
= salt_len
* 2;
9957 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9959 lowercase (tmp
, salt_len
);
9962 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9964 uppercase (tmp
, salt_len
);
9969 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9974 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9979 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9981 u32
*tmp_uint
= (uint
*) tmp
;
9987 for (u32 i
= 0; i
< max
; i
++)
9989 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9992 // Important: we may need to increase the length of memcpy since
9993 // we don't want to "loose" some swapped bytes (could happen if
9994 // they do not perfectly fit in the 4-byte blocks)
9995 // Memcpy does always copy the bytes in the BE order, but since
9996 // we swapped them, some important bytes could be in positions
9997 // we normally skip with the original len
9999 if (len
% 4) len
+= 4 - (len
% 4);
10002 memcpy (out
, tmp
, len
);
10007 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10009 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
10011 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
10013 u32
*digest
= (u32
*) hash_buf
->digest
;
10015 salt_t
*salt
= hash_buf
->salt
;
10017 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
10019 char *iter_pos
= input_buf
+ 4;
10021 salt
->salt_iter
= 1 << atoi (iter_pos
);
10023 char *salt_pos
= strchr (iter_pos
, '$');
10025 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10029 uint salt_len
= 16;
10031 salt
->salt_len
= salt_len
;
10033 u8 tmp_buf
[100] = { 0 };
10035 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
10037 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10039 memcpy (salt_buf_ptr
, tmp_buf
, 16);
10041 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
10042 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
10043 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
10044 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
10046 char *hash_pos
= salt_pos
+ 22;
10048 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10050 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
10052 memcpy (digest
, tmp_buf
, 24);
10054 digest
[0] = byte_swap_32 (digest
[0]);
10055 digest
[1] = byte_swap_32 (digest
[1]);
10056 digest
[2] = byte_swap_32 (digest
[2]);
10057 digest
[3] = byte_swap_32 (digest
[3]);
10058 digest
[4] = byte_swap_32 (digest
[4]);
10059 digest
[5] = byte_swap_32 (digest
[5]);
10061 digest
[5] &= ~0xff; // its just 23 not 24 !
10063 return (PARSER_OK
);
10066 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10068 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10070 u32
*digest
= (u32
*) hash_buf
->digest
;
10072 u8 tmp_buf
[100] = { 0 };
10074 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10076 memcpy (digest
, tmp_buf
, 32);
10078 digest
[0] = byte_swap_32 (digest
[0]);
10079 digest
[1] = byte_swap_32 (digest
[1]);
10080 digest
[2] = byte_swap_32 (digest
[2]);
10081 digest
[3] = byte_swap_32 (digest
[3]);
10082 digest
[4] = byte_swap_32 (digest
[4]);
10083 digest
[5] = byte_swap_32 (digest
[5]);
10084 digest
[6] = byte_swap_32 (digest
[6]);
10085 digest
[7] = byte_swap_32 (digest
[7]);
10087 digest
[0] -= SHA256M_A
;
10088 digest
[1] -= SHA256M_B
;
10089 digest
[2] -= SHA256M_C
;
10090 digest
[3] -= SHA256M_D
;
10091 digest
[4] -= SHA256M_E
;
10092 digest
[5] -= SHA256M_F
;
10093 digest
[6] -= SHA256M_G
;
10094 digest
[7] -= SHA256M_H
;
10096 return (PARSER_OK
);
10099 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10101 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10103 u32
*digest
= (u32
*) hash_buf
->digest
;
10105 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10106 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10108 digest
[0] = byte_swap_32 (digest
[0]);
10109 digest
[1] = byte_swap_32 (digest
[1]);
10113 IP (digest
[0], digest
[1], tt
);
10115 digest
[0] = digest
[0];
10116 digest
[1] = digest
[1];
10120 return (PARSER_OK
);
10123 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10125 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10127 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10129 u32
*digest
= (u32
*) hash_buf
->digest
;
10131 salt_t
*salt
= hash_buf
->salt
;
10133 char *hash_pos
= input_buf
+ 10;
10135 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10136 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10137 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10138 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10139 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10141 digest
[0] -= SHA1M_A
;
10142 digest
[1] -= SHA1M_B
;
10143 digest
[2] -= SHA1M_C
;
10144 digest
[3] -= SHA1M_D
;
10145 digest
[4] -= SHA1M_E
;
10147 uint salt_len
= 10;
10149 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10151 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10153 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10155 salt
->salt_len
= salt_len
;
10157 return (PARSER_OK
);
10160 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10162 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10164 u32
*digest
= (u32
*) hash_buf
->digest
;
10166 salt_t
*salt
= hash_buf
->salt
;
10168 char *hash_pos
= input_buf
+ 8;
10170 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10171 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10172 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10173 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10174 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10176 digest
[0] -= SHA1M_A
;
10177 digest
[1] -= SHA1M_B
;
10178 digest
[2] -= SHA1M_C
;
10179 digest
[3] -= SHA1M_D
;
10180 digest
[4] -= SHA1M_E
;
10184 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10186 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10188 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10190 salt
->salt_len
= salt_len
;
10192 return (PARSER_OK
);
10195 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10197 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10199 u64
*digest
= (u64
*) hash_buf
->digest
;
10201 salt_t
*salt
= hash_buf
->salt
;
10203 char *hash_pos
= input_buf
+ 8;
10205 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10206 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10207 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10208 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10209 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10210 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10211 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10212 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10214 digest
[0] -= SHA512M_A
;
10215 digest
[1] -= SHA512M_B
;
10216 digest
[2] -= SHA512M_C
;
10217 digest
[3] -= SHA512M_D
;
10218 digest
[4] -= SHA512M_E
;
10219 digest
[5] -= SHA512M_F
;
10220 digest
[6] -= SHA512M_G
;
10221 digest
[7] -= SHA512M_H
;
10225 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10227 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10229 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10231 salt
->salt_len
= salt_len
;
10233 return (PARSER_OK
);
10236 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10238 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10240 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10244 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10247 u32
*digest
= (u32
*) hash_buf
->digest
;
10249 salt_t
*salt
= hash_buf
->salt
;
10251 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10252 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10253 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10254 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10256 digest
[0] = byte_swap_32 (digest
[0]);
10257 digest
[1] = byte_swap_32 (digest
[1]);
10258 digest
[2] = byte_swap_32 (digest
[2]);
10259 digest
[3] = byte_swap_32 (digest
[3]);
10261 digest
[0] -= MD5M_A
;
10262 digest
[1] -= MD5M_B
;
10263 digest
[2] -= MD5M_C
;
10264 digest
[3] -= MD5M_D
;
10266 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10268 uint salt_len
= input_len
- 32 - 1;
10270 char *salt_buf
= input_buf
+ 32 + 1;
10272 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10274 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10276 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10278 salt
->salt_len
= salt_len
;
10280 return (PARSER_OK
);
10283 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10285 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10287 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10291 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10296 char clean_input_buf
[32] = { 0 };
10298 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10299 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10301 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10305 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10311 clean_input_buf
[k
] = input_buf
[i
];
10319 u32
*digest
= (u32
*) hash_buf
->digest
;
10321 salt_t
*salt
= hash_buf
->salt
;
10323 u32 a
, b
, c
, d
, e
, f
;
10325 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10326 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10327 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10328 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10329 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10330 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10332 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10333 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10335 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10336 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10337 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10338 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10339 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10340 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10342 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10343 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10345 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10346 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10347 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10348 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10349 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10350 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10352 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10353 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10355 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10356 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10357 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10358 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10359 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10360 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10362 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10363 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10365 digest
[0] = byte_swap_32 (digest
[0]);
10366 digest
[1] = byte_swap_32 (digest
[1]);
10367 digest
[2] = byte_swap_32 (digest
[2]);
10368 digest
[3] = byte_swap_32 (digest
[3]);
10370 digest
[0] -= MD5M_A
;
10371 digest
[1] -= MD5M_B
;
10372 digest
[2] -= MD5M_C
;
10373 digest
[3] -= MD5M_D
;
10375 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10377 uint salt_len
= input_len
- 30 - 1;
10379 char *salt_buf
= input_buf
+ 30 + 1;
10381 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10383 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10385 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10386 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10388 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10390 salt
->salt_len
= salt_len
;
10392 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10394 salt
->salt_len
+= 22;
10396 return (PARSER_OK
);
10399 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10401 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10403 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10407 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10410 u32
*digest
= (u32
*) hash_buf
->digest
;
10412 salt_t
*salt
= hash_buf
->salt
;
10414 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10415 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10416 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10417 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10418 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10420 digest
[0] -= SHA1M_A
;
10421 digest
[1] -= SHA1M_B
;
10422 digest
[2] -= SHA1M_C
;
10423 digest
[3] -= SHA1M_D
;
10424 digest
[4] -= SHA1M_E
;
10426 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10428 uint salt_len
= input_len
- 40 - 1;
10430 char *salt_buf
= input_buf
+ 40 + 1;
10432 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10434 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10436 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10438 salt
->salt_len
= salt_len
;
10440 return (PARSER_OK
);
10443 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10445 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10447 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10451 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10454 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10456 char *iter_pos
= input_buf
+ 6;
10458 salt_t
*salt
= hash_buf
->salt
;
10460 uint iter
= atoi (iter_pos
);
10464 iter
= ROUNDS_DCC2
;
10467 salt
->salt_iter
= iter
- 1;
10469 char *salt_pos
= strchr (iter_pos
, '#');
10471 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10475 char *digest_pos
= strchr (salt_pos
, '#');
10477 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10481 uint salt_len
= digest_pos
- salt_pos
- 1;
10483 u32
*digest
= (u32
*) hash_buf
->digest
;
10485 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10486 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10487 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10488 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10490 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10492 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10494 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10496 salt
->salt_len
= salt_len
;
10498 return (PARSER_OK
);
10501 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10503 u32
*digest
= (u32
*) hash_buf
->digest
;
10505 salt_t
*salt
= hash_buf
->salt
;
10507 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10511 memcpy (&in
, input_buf
, input_len
);
10513 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10515 memcpy (digest
, in
.keymic
, 16);
10518 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10519 The phrase "Pairwise key expansion"
10520 Access Point Address (referred to as Authenticator Address AA)
10521 Supplicant Address (referred to as Supplicant Address SA)
10522 Access Point Nonce (referred to as Authenticator Anonce)
10523 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10526 uint salt_len
= strlen (in
.essid
);
10530 log_info ("WARNING: The ESSID length is too long, the hccap file may be invalid or corrupted");
10532 return (PARSER_SALT_LENGTH
);
10535 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10537 salt
->salt_len
= salt_len
;
10539 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10541 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10543 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10545 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10547 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10548 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10552 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10553 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10556 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10558 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10559 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10563 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10564 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10567 for (int i
= 0; i
< 25; i
++)
10569 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10572 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10573 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10574 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10575 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10577 wpa
->keyver
= in
.keyver
;
10579 if (wpa
->keyver
> 255)
10581 log_info ("ATTENTION!");
10582 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10583 log_info (" This could be due to a recent aircrack-ng bug.");
10584 log_info (" The key version was automatically reset to a reasonable value.");
10587 wpa
->keyver
&= 0xff;
10590 wpa
->eapol_size
= in
.eapol_size
;
10592 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10594 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10596 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10598 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10600 if (wpa
->keyver
== 1)
10606 digest
[0] = byte_swap_32 (digest
[0]);
10607 digest
[1] = byte_swap_32 (digest
[1]);
10608 digest
[2] = byte_swap_32 (digest
[2]);
10609 digest
[3] = byte_swap_32 (digest
[3]);
10611 for (int i
= 0; i
< 64; i
++)
10613 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10617 uint32_t *p0
= (uint32_t *) in
.essid
;
10621 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10622 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10624 salt
->salt_buf
[10] = c0
;
10625 salt
->salt_buf
[11] = c1
;
10627 return (PARSER_OK
);
10630 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10632 u32
*digest
= (u32
*) hash_buf
->digest
;
10634 salt_t
*salt
= hash_buf
->salt
;
10636 if (input_len
== 0)
10638 log_error ("Password Safe v2 container not specified");
10643 FILE *fp
= fopen (input_buf
, "rb");
10647 log_error ("%s: %s", input_buf
, strerror (errno
));
10654 memset (&buf
, 0, sizeof (psafe2_hdr
));
10656 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10660 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10662 salt
->salt_buf
[0] = buf
.random
[0];
10663 salt
->salt_buf
[1] = buf
.random
[1];
10665 salt
->salt_len
= 8;
10666 salt
->salt_iter
= 1000;
10668 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10669 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10670 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10671 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10672 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10674 return (PARSER_OK
);
10677 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10679 u32
*digest
= (u32
*) hash_buf
->digest
;
10681 salt_t
*salt
= hash_buf
->salt
;
10683 if (input_len
== 0)
10685 log_error (".psafe3 not specified");
10690 FILE *fp
= fopen (input_buf
, "rb");
10694 log_error ("%s: %s", input_buf
, strerror (errno
));
10701 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10705 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10707 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10709 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10711 salt
->salt_iter
= in
.iterations
+ 1;
10713 salt
->salt_buf
[0] = in
.salt_buf
[0];
10714 salt
->salt_buf
[1] = in
.salt_buf
[1];
10715 salt
->salt_buf
[2] = in
.salt_buf
[2];
10716 salt
->salt_buf
[3] = in
.salt_buf
[3];
10717 salt
->salt_buf
[4] = in
.salt_buf
[4];
10718 salt
->salt_buf
[5] = in
.salt_buf
[5];
10719 salt
->salt_buf
[6] = in
.salt_buf
[6];
10720 salt
->salt_buf
[7] = in
.salt_buf
[7];
10722 salt
->salt_len
= 32;
10724 digest
[0] = in
.hash_buf
[0];
10725 digest
[1] = in
.hash_buf
[1];
10726 digest
[2] = in
.hash_buf
[2];
10727 digest
[3] = in
.hash_buf
[3];
10728 digest
[4] = in
.hash_buf
[4];
10729 digest
[5] = in
.hash_buf
[5];
10730 digest
[6] = in
.hash_buf
[6];
10731 digest
[7] = in
.hash_buf
[7];
10733 digest
[0] = byte_swap_32 (digest
[0]);
10734 digest
[1] = byte_swap_32 (digest
[1]);
10735 digest
[2] = byte_swap_32 (digest
[2]);
10736 digest
[3] = byte_swap_32 (digest
[3]);
10737 digest
[4] = byte_swap_32 (digest
[4]);
10738 digest
[5] = byte_swap_32 (digest
[5]);
10739 digest
[6] = byte_swap_32 (digest
[6]);
10740 digest
[7] = byte_swap_32 (digest
[7]);
10742 return (PARSER_OK
);
10745 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10747 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10749 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10751 u32
*digest
= (u32
*) hash_buf
->digest
;
10753 salt_t
*salt
= hash_buf
->salt
;
10755 char *iter_pos
= input_buf
+ 3;
10757 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10759 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10761 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10763 salt
->salt_iter
= salt_iter
;
10765 char *salt_pos
= iter_pos
+ 1;
10769 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10771 salt
->salt_len
= salt_len
;
10773 char *hash_pos
= salt_pos
+ salt_len
;
10775 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10777 return (PARSER_OK
);
10780 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10782 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10784 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10786 u32
*digest
= (u32
*) hash_buf
->digest
;
10788 salt_t
*salt
= hash_buf
->salt
;
10790 char *salt_pos
= input_buf
+ 3;
10792 uint iterations_len
= 0;
10794 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10798 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10800 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10801 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10805 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10809 iterations_len
+= 8;
10813 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10816 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10818 char *hash_pos
= strchr (salt_pos
, '$');
10820 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10822 uint salt_len
= hash_pos
- salt_pos
;
10824 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10826 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10828 salt
->salt_len
= salt_len
;
10832 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10834 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10836 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10838 return (PARSER_OK
);
10841 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10843 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10845 u32
*digest
= (u32
*) hash_buf
->digest
;
10847 salt_t
*salt
= hash_buf
->salt
;
10849 char *salt_pos
= input_buf
+ 6;
10851 uint iterations_len
= 0;
10853 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10857 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10859 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10860 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10864 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10868 iterations_len
+= 8;
10872 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10875 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10877 char *hash_pos
= strchr (salt_pos
, '$');
10879 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10881 uint salt_len
= hash_pos
- salt_pos
;
10883 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10885 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10887 salt
->salt_len
= salt_len
;
10891 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10893 return (PARSER_OK
);
10896 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10898 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10900 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10902 u32
*digest
= (u32
*) hash_buf
->digest
;
10904 salt_t
*salt
= hash_buf
->salt
;
10906 char *salt_pos
= input_buf
+ 14;
10908 char *hash_pos
= strchr (salt_pos
, '*');
10910 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10914 uint salt_len
= hash_pos
- salt_pos
- 1;
10916 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10918 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10920 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10922 salt
->salt_len
= salt_len
;
10924 u8 tmp_buf
[100] = { 0 };
10926 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10928 memcpy (digest
, tmp_buf
, 20);
10930 digest
[0] = byte_swap_32 (digest
[0]);
10931 digest
[1] = byte_swap_32 (digest
[1]);
10932 digest
[2] = byte_swap_32 (digest
[2]);
10933 digest
[3] = byte_swap_32 (digest
[3]);
10934 digest
[4] = byte_swap_32 (digest
[4]);
10936 digest
[0] -= SHA1M_A
;
10937 digest
[1] -= SHA1M_B
;
10938 digest
[2] -= SHA1M_C
;
10939 digest
[3] -= SHA1M_D
;
10940 digest
[4] -= SHA1M_E
;
10942 return (PARSER_OK
);
10945 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10947 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10949 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10951 if (c12
& 3) return (PARSER_HASH_VALUE
);
10953 u32
*digest
= (u32
*) hash_buf
->digest
;
10955 salt_t
*salt
= hash_buf
->salt
;
10957 // for ascii_digest
10958 salt
->salt_sign
[0] = input_buf
[0];
10959 salt
->salt_sign
[1] = input_buf
[1];
10961 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10962 | itoa64_to_int (input_buf
[1]) << 6;
10964 salt
->salt_len
= 2;
10966 u8 tmp_buf
[100] = { 0 };
10968 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10970 memcpy (digest
, tmp_buf
, 8);
10974 IP (digest
[0], digest
[1], tt
);
10979 return (PARSER_OK
);
10982 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10984 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10986 u32
*digest
= (u32
*) hash_buf
->digest
;
10988 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10989 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10990 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10991 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10993 digest
[0] = byte_swap_32 (digest
[0]);
10994 digest
[1] = byte_swap_32 (digest
[1]);
10995 digest
[2] = byte_swap_32 (digest
[2]);
10996 digest
[3] = byte_swap_32 (digest
[3]);
10998 digest
[0] -= MD4M_A
;
10999 digest
[1] -= MD4M_B
;
11000 digest
[2] -= MD4M_C
;
11001 digest
[3] -= MD4M_D
;
11003 return (PARSER_OK
);
11006 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11008 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11010 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
11014 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
11017 u32
*digest
= (u32
*) hash_buf
->digest
;
11019 salt_t
*salt
= hash_buf
->salt
;
11021 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11022 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11023 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11024 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11026 digest
[0] = byte_swap_32 (digest
[0]);
11027 digest
[1] = byte_swap_32 (digest
[1]);
11028 digest
[2] = byte_swap_32 (digest
[2]);
11029 digest
[3] = byte_swap_32 (digest
[3]);
11031 digest
[0] -= MD4M_A
;
11032 digest
[1] -= MD4M_B
;
11033 digest
[2] -= MD4M_C
;
11034 digest
[3] -= MD4M_D
;
11036 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11038 uint salt_len
= input_len
- 32 - 1;
11040 char *salt_buf
= input_buf
+ 32 + 1;
11042 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11044 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11046 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11048 salt
->salt_len
= salt_len
;
11050 return (PARSER_OK
);
11053 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11055 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
11057 u32
*digest
= (u32
*) hash_buf
->digest
;
11059 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11060 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11061 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11062 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11064 digest
[0] = byte_swap_32 (digest
[0]);
11065 digest
[1] = byte_swap_32 (digest
[1]);
11066 digest
[2] = byte_swap_32 (digest
[2]);
11067 digest
[3] = byte_swap_32 (digest
[3]);
11069 digest
[0] -= MD5M_A
;
11070 digest
[1] -= MD5M_B
;
11071 digest
[2] -= MD5M_C
;
11072 digest
[3] -= MD5M_D
;
11074 return (PARSER_OK
);
11077 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11079 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11081 u32
*digest
= (u32
*) hash_buf
->digest
;
11083 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11084 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11088 digest
[0] = byte_swap_32 (digest
[0]);
11089 digest
[1] = byte_swap_32 (digest
[1]);
11091 return (PARSER_OK
);
11094 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11096 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11098 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11102 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11105 u32
*digest
= (u32
*) hash_buf
->digest
;
11107 salt_t
*salt
= hash_buf
->salt
;
11109 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11110 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11111 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11112 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11114 digest
[0] = byte_swap_32 (digest
[0]);
11115 digest
[1] = byte_swap_32 (digest
[1]);
11116 digest
[2] = byte_swap_32 (digest
[2]);
11117 digest
[3] = byte_swap_32 (digest
[3]);
11119 digest
[0] -= MD5M_A
;
11120 digest
[1] -= MD5M_B
;
11121 digest
[2] -= MD5M_C
;
11122 digest
[3] -= MD5M_D
;
11124 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11126 uint salt_len
= input_len
- 32 - 1;
11128 char *salt_buf
= input_buf
+ 32 + 1;
11130 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11132 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11134 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11136 salt
->salt_len
= salt_len
;
11138 return (PARSER_OK
);
11141 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11143 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11145 u32
*digest
= (u32
*) hash_buf
->digest
;
11147 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11148 | itoa64_to_int (input_buf
[ 1]) << 6
11149 | itoa64_to_int (input_buf
[ 2]) << 12
11150 | itoa64_to_int (input_buf
[ 3]) << 18;
11151 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11152 | itoa64_to_int (input_buf
[ 5]) << 6
11153 | itoa64_to_int (input_buf
[ 6]) << 12
11154 | itoa64_to_int (input_buf
[ 7]) << 18;
11155 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11156 | itoa64_to_int (input_buf
[ 9]) << 6
11157 | itoa64_to_int (input_buf
[10]) << 12
11158 | itoa64_to_int (input_buf
[11]) << 18;
11159 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11160 | itoa64_to_int (input_buf
[13]) << 6
11161 | itoa64_to_int (input_buf
[14]) << 12
11162 | itoa64_to_int (input_buf
[15]) << 18;
11164 digest
[0] -= MD5M_A
;
11165 digest
[1] -= MD5M_B
;
11166 digest
[2] -= MD5M_C
;
11167 digest
[3] -= MD5M_D
;
11169 digest
[0] &= 0x00ffffff;
11170 digest
[1] &= 0x00ffffff;
11171 digest
[2] &= 0x00ffffff;
11172 digest
[3] &= 0x00ffffff;
11174 return (PARSER_OK
);
11177 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11179 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11181 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11185 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11188 u32
*digest
= (u32
*) hash_buf
->digest
;
11190 salt_t
*salt
= hash_buf
->salt
;
11192 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11193 | itoa64_to_int (input_buf
[ 1]) << 6
11194 | itoa64_to_int (input_buf
[ 2]) << 12
11195 | itoa64_to_int (input_buf
[ 3]) << 18;
11196 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11197 | itoa64_to_int (input_buf
[ 5]) << 6
11198 | itoa64_to_int (input_buf
[ 6]) << 12
11199 | itoa64_to_int (input_buf
[ 7]) << 18;
11200 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11201 | itoa64_to_int (input_buf
[ 9]) << 6
11202 | itoa64_to_int (input_buf
[10]) << 12
11203 | itoa64_to_int (input_buf
[11]) << 18;
11204 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11205 | itoa64_to_int (input_buf
[13]) << 6
11206 | itoa64_to_int (input_buf
[14]) << 12
11207 | itoa64_to_int (input_buf
[15]) << 18;
11209 digest
[0] -= MD5M_A
;
11210 digest
[1] -= MD5M_B
;
11211 digest
[2] -= MD5M_C
;
11212 digest
[3] -= MD5M_D
;
11214 digest
[0] &= 0x00ffffff;
11215 digest
[1] &= 0x00ffffff;
11216 digest
[2] &= 0x00ffffff;
11217 digest
[3] &= 0x00ffffff;
11219 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11221 uint salt_len
= input_len
- 16 - 1;
11223 char *salt_buf
= input_buf
+ 16 + 1;
11225 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11227 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11229 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11231 salt
->salt_len
= salt_len
;
11233 return (PARSER_OK
);
11236 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11238 key
[0] = (nthash
[0] >> 0);
11239 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11240 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11241 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11242 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11243 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11244 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11245 key
[7] = (nthash
[6] << 1);
11257 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11259 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11261 u32
*digest
= (u32
*) hash_buf
->digest
;
11263 salt_t
*salt
= hash_buf
->salt
;
11265 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11271 char *user_pos
= input_buf
;
11273 char *unused_pos
= strchr (user_pos
, ':');
11275 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11277 uint user_len
= unused_pos
- user_pos
;
11279 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11283 char *domain_pos
= strchr (unused_pos
, ':');
11285 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11287 uint unused_len
= domain_pos
- unused_pos
;
11289 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11293 char *srvchall_pos
= strchr (domain_pos
, ':');
11295 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11297 uint domain_len
= srvchall_pos
- domain_pos
;
11299 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11303 char *hash_pos
= strchr (srvchall_pos
, ':');
11305 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11307 uint srvchall_len
= hash_pos
- srvchall_pos
;
11309 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11313 char *clichall_pos
= strchr (hash_pos
, ':');
11315 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11317 uint hash_len
= clichall_pos
- hash_pos
;
11319 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11323 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11325 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11328 * store some data for later use
11331 netntlm
->user_len
= user_len
* 2;
11332 netntlm
->domain_len
= domain_len
* 2;
11333 netntlm
->srvchall_len
= srvchall_len
/ 2;
11334 netntlm
->clichall_len
= clichall_len
/ 2;
11336 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11337 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11340 * handle username and domainname
11343 for (uint i
= 0; i
< user_len
; i
++)
11345 *userdomain_ptr
++ = user_pos
[i
];
11346 *userdomain_ptr
++ = 0;
11349 for (uint i
= 0; i
< domain_len
; i
++)
11351 *userdomain_ptr
++ = domain_pos
[i
];
11352 *userdomain_ptr
++ = 0;
11356 * handle server challenge encoding
11359 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11361 const char p0
= srvchall_pos
[i
+ 0];
11362 const char p1
= srvchall_pos
[i
+ 1];
11364 *chall_ptr
++ = hex_convert (p1
) << 0
11365 | hex_convert (p0
) << 4;
11369 * handle client challenge encoding
11372 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11374 const char p0
= clichall_pos
[i
+ 0];
11375 const char p1
= clichall_pos
[i
+ 1];
11377 *chall_ptr
++ = hex_convert (p1
) << 0
11378 | hex_convert (p0
) << 4;
11385 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11387 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11389 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11391 salt
->salt_len
= salt_len
;
11393 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11394 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11395 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11396 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11398 digest
[0] = byte_swap_32 (digest
[0]);
11399 digest
[1] = byte_swap_32 (digest
[1]);
11400 digest
[2] = byte_swap_32 (digest
[2]);
11401 digest
[3] = byte_swap_32 (digest
[3]);
11403 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11405 uint digest_tmp
[2] = { 0 };
11407 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11408 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11410 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11411 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11413 /* special case 2: ESS */
11415 if (srvchall_len
== 48)
11417 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11419 uint w
[16] = { 0 };
11421 w
[ 0] = netntlm
->chall_buf
[6];
11422 w
[ 1] = netntlm
->chall_buf
[7];
11423 w
[ 2] = netntlm
->chall_buf
[0];
11424 w
[ 3] = netntlm
->chall_buf
[1];
11428 uint dgst
[4] = { 0 };
11437 salt
->salt_buf
[0] = dgst
[0];
11438 salt
->salt_buf
[1] = dgst
[1];
11442 /* precompute netntlmv1 exploit start */
11444 for (uint i
= 0; i
< 0x10000; i
++)
11446 uint key_md4
[2] = { i
, 0 };
11447 uint key_des
[2] = { 0, 0 };
11449 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11451 uint Kc
[16] = { 0 };
11452 uint Kd
[16] = { 0 };
11454 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11456 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11458 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11460 if (data3
[0] != digest_tmp
[0]) continue;
11461 if (data3
[1] != digest_tmp
[1]) continue;
11463 salt
->salt_buf
[2] = i
;
11465 salt
->salt_len
= 24;
11470 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11471 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11473 /* precompute netntlmv1 exploit stop */
11477 IP (digest
[0], digest
[1], tt
);
11478 IP (digest
[2], digest
[3], tt
);
11480 digest
[0] = rotr32 (digest
[0], 29);
11481 digest
[1] = rotr32 (digest
[1], 29);
11482 digest
[2] = rotr32 (digest
[2], 29);
11483 digest
[3] = rotr32 (digest
[3], 29);
11485 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11487 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11488 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11490 return (PARSER_OK
);
11493 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11495 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11497 u32
*digest
= (u32
*) hash_buf
->digest
;
11499 salt_t
*salt
= hash_buf
->salt
;
11501 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11507 char *user_pos
= input_buf
;
11509 char *unused_pos
= strchr (user_pos
, ':');
11511 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11513 uint user_len
= unused_pos
- user_pos
;
11515 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11519 char *domain_pos
= strchr (unused_pos
, ':');
11521 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11523 uint unused_len
= domain_pos
- unused_pos
;
11525 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11529 char *srvchall_pos
= strchr (domain_pos
, ':');
11531 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11533 uint domain_len
= srvchall_pos
- domain_pos
;
11535 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11539 char *hash_pos
= strchr (srvchall_pos
, ':');
11541 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11543 uint srvchall_len
= hash_pos
- srvchall_pos
;
11545 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11549 char *clichall_pos
= strchr (hash_pos
, ':');
11551 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11553 uint hash_len
= clichall_pos
- hash_pos
;
11555 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11559 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11561 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11563 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11566 * store some data for later use
11569 netntlm
->user_len
= user_len
* 2;
11570 netntlm
->domain_len
= domain_len
* 2;
11571 netntlm
->srvchall_len
= srvchall_len
/ 2;
11572 netntlm
->clichall_len
= clichall_len
/ 2;
11574 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11575 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11578 * handle username and domainname
11581 for (uint i
= 0; i
< user_len
; i
++)
11583 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11584 *userdomain_ptr
++ = 0;
11587 for (uint i
= 0; i
< domain_len
; i
++)
11589 *userdomain_ptr
++ = domain_pos
[i
];
11590 *userdomain_ptr
++ = 0;
11593 *userdomain_ptr
++ = 0x80;
11596 * handle server challenge encoding
11599 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11601 const char p0
= srvchall_pos
[i
+ 0];
11602 const char p1
= srvchall_pos
[i
+ 1];
11604 *chall_ptr
++ = hex_convert (p1
) << 0
11605 | hex_convert (p0
) << 4;
11609 * handle client challenge encoding
11612 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11614 const char p0
= clichall_pos
[i
+ 0];
11615 const char p1
= clichall_pos
[i
+ 1];
11617 *chall_ptr
++ = hex_convert (p1
) << 0
11618 | hex_convert (p0
) << 4;
11621 *chall_ptr
++ = 0x80;
11624 * handle hash itself
11627 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11628 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11629 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11630 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11632 digest
[0] = byte_swap_32 (digest
[0]);
11633 digest
[1] = byte_swap_32 (digest
[1]);
11634 digest
[2] = byte_swap_32 (digest
[2]);
11635 digest
[3] = byte_swap_32 (digest
[3]);
11638 * reuse challange data as salt_buf, its the buffer that is most likely unique
11641 salt
->salt_buf
[0] = 0;
11642 salt
->salt_buf
[1] = 0;
11643 salt
->salt_buf
[2] = 0;
11644 salt
->salt_buf
[3] = 0;
11645 salt
->salt_buf
[4] = 0;
11646 salt
->salt_buf
[5] = 0;
11647 salt
->salt_buf
[6] = 0;
11648 salt
->salt_buf
[7] = 0;
11652 uptr
= (uint
*) netntlm
->userdomain_buf
;
11654 for (uint i
= 0; i
< 16; i
+= 16)
11656 md5_64 (uptr
, salt
->salt_buf
);
11659 uptr
= (uint
*) netntlm
->chall_buf
;
11661 for (uint i
= 0; i
< 256; i
+= 16)
11663 md5_64 (uptr
, salt
->salt_buf
);
11666 salt
->salt_len
= 16;
11668 return (PARSER_OK
);
11671 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11673 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11675 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11679 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11682 u32
*digest
= (u32
*) hash_buf
->digest
;
11684 salt_t
*salt
= hash_buf
->salt
;
11686 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11687 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11688 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11689 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11691 digest
[0] = byte_swap_32 (digest
[0]);
11692 digest
[1] = byte_swap_32 (digest
[1]);
11693 digest
[2] = byte_swap_32 (digest
[2]);
11694 digest
[3] = byte_swap_32 (digest
[3]);
11696 digest
[0] -= MD5M_A
;
11697 digest
[1] -= MD5M_B
;
11698 digest
[2] -= MD5M_C
;
11699 digest
[3] -= MD5M_D
;
11701 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11703 uint salt_len
= input_len
- 32 - 1;
11705 char *salt_buf
= input_buf
+ 32 + 1;
11707 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11709 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11711 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11713 salt
->salt_len
= salt_len
;
11715 return (PARSER_OK
);
11718 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11720 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11722 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11726 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11729 u32
*digest
= (u32
*) hash_buf
->digest
;
11731 salt_t
*salt
= hash_buf
->salt
;
11733 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11734 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11735 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11736 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11738 digest
[0] = byte_swap_32 (digest
[0]);
11739 digest
[1] = byte_swap_32 (digest
[1]);
11740 digest
[2] = byte_swap_32 (digest
[2]);
11741 digest
[3] = byte_swap_32 (digest
[3]);
11743 digest
[0] -= MD5M_A
;
11744 digest
[1] -= MD5M_B
;
11745 digest
[2] -= MD5M_C
;
11746 digest
[3] -= MD5M_D
;
11748 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11750 uint salt_len
= input_len
- 32 - 1;
11752 char *salt_buf
= input_buf
+ 32 + 1;
11754 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11756 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11758 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11760 salt
->salt_len
= salt_len
;
11762 return (PARSER_OK
);
11765 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11767 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11769 u32
*digest
= (u32
*) hash_buf
->digest
;
11771 salt_t
*salt
= hash_buf
->salt
;
11773 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11774 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11775 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11776 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11778 digest
[0] = byte_swap_32 (digest
[0]);
11779 digest
[1] = byte_swap_32 (digest
[1]);
11780 digest
[2] = byte_swap_32 (digest
[2]);
11781 digest
[3] = byte_swap_32 (digest
[3]);
11783 digest
[0] -= MD5M_A
;
11784 digest
[1] -= MD5M_B
;
11785 digest
[2] -= MD5M_C
;
11786 digest
[3] -= MD5M_D
;
11789 * This is a virtual salt. While the algorithm is basically not salted
11790 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11791 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11794 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11796 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11798 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11800 salt
->salt_len
= salt_len
;
11802 return (PARSER_OK
);
11805 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11807 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11809 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11813 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11816 u32
*digest
= (u32
*) hash_buf
->digest
;
11818 salt_t
*salt
= hash_buf
->salt
;
11820 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11821 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11822 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11823 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11825 digest
[0] = byte_swap_32 (digest
[0]);
11826 digest
[1] = byte_swap_32 (digest
[1]);
11827 digest
[2] = byte_swap_32 (digest
[2]);
11828 digest
[3] = byte_swap_32 (digest
[3]);
11830 digest
[0] -= MD5M_A
;
11831 digest
[1] -= MD5M_B
;
11832 digest
[2] -= MD5M_C
;
11833 digest
[3] -= MD5M_D
;
11835 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11837 uint salt_len
= input_len
- 32 - 1;
11839 char *salt_buf
= input_buf
+ 32 + 1;
11841 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11843 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11845 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11847 salt
->salt_len
= salt_len
;
11849 return (PARSER_OK
);
11852 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11854 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11856 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11860 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11863 u32
*digest
= (u32
*) hash_buf
->digest
;
11865 salt_t
*salt
= hash_buf
->salt
;
11867 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11868 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11869 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11870 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11872 digest
[0] = byte_swap_32 (digest
[0]);
11873 digest
[1] = byte_swap_32 (digest
[1]);
11874 digest
[2] = byte_swap_32 (digest
[2]);
11875 digest
[3] = byte_swap_32 (digest
[3]);
11877 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11879 uint salt_len
= input_len
- 32 - 1;
11881 char *salt_buf
= input_buf
+ 32 + 1;
11883 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11885 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11887 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11889 salt
->salt_len
= salt_len
;
11891 return (PARSER_OK
);
11894 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11896 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11898 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11902 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11905 u32
*digest
= (u32
*) hash_buf
->digest
;
11907 salt_t
*salt
= hash_buf
->salt
;
11909 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11910 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11911 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11912 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11914 digest
[0] = byte_swap_32 (digest
[0]);
11915 digest
[1] = byte_swap_32 (digest
[1]);
11916 digest
[2] = byte_swap_32 (digest
[2]);
11917 digest
[3] = byte_swap_32 (digest
[3]);
11919 digest
[0] -= MD4M_A
;
11920 digest
[1] -= MD4M_B
;
11921 digest
[2] -= MD4M_C
;
11922 digest
[3] -= MD4M_D
;
11924 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11926 uint salt_len
= input_len
- 32 - 1;
11928 char *salt_buf
= input_buf
+ 32 + 1;
11930 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11932 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11934 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11936 salt
->salt_len
= salt_len
;
11938 return (PARSER_OK
);
11941 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11943 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11945 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11949 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11952 u32
*digest
= (u32
*) hash_buf
->digest
;
11954 salt_t
*salt
= hash_buf
->salt
;
11956 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11957 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11958 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11959 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11961 digest
[0] = byte_swap_32 (digest
[0]);
11962 digest
[1] = byte_swap_32 (digest
[1]);
11963 digest
[2] = byte_swap_32 (digest
[2]);
11964 digest
[3] = byte_swap_32 (digest
[3]);
11966 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11968 uint salt_len
= input_len
- 32 - 1;
11970 char *salt_buf
= input_buf
+ 32 + 1;
11972 uint salt_pc_block
[16] = { 0 };
11974 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11976 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11978 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11980 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11982 salt_pc_block
[14] = salt_len
* 8;
11984 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11986 md5_64 (salt_pc_block
, salt_pc_digest
);
11988 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11989 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11990 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11991 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11993 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11995 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11997 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11999 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
12000 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
12001 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
12002 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
12004 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
12006 return (PARSER_OK
);
12009 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12011 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
12013 u32
*digest
= (u32
*) hash_buf
->digest
;
12015 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12016 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12017 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12018 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12019 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12021 digest
[0] -= SHA1M_A
;
12022 digest
[1] -= SHA1M_B
;
12023 digest
[2] -= SHA1M_C
;
12024 digest
[3] -= SHA1M_D
;
12025 digest
[4] -= SHA1M_E
;
12027 return (PARSER_OK
);
12030 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12032 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
12034 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
12036 u32
*digest
= (u32
*) hash_buf
->digest
;
12040 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12041 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12042 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12043 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12046 return (PARSER_OK
);
12049 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12051 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12053 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12057 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12060 u32
*digest
= (u32
*) hash_buf
->digest
;
12062 salt_t
*salt
= hash_buf
->salt
;
12064 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12065 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12066 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12067 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12068 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12070 digest
[0] -= SHA1M_A
;
12071 digest
[1] -= SHA1M_B
;
12072 digest
[2] -= SHA1M_C
;
12073 digest
[3] -= SHA1M_D
;
12074 digest
[4] -= SHA1M_E
;
12076 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12078 uint salt_len
= input_len
- 40 - 1;
12080 char *salt_buf
= input_buf
+ 40 + 1;
12082 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12084 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12086 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12088 salt
->salt_len
= salt_len
;
12090 return (PARSER_OK
);
12093 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12095 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12097 u32
*digest
= (u32
*) hash_buf
->digest
;
12099 salt_t
*salt
= hash_buf
->salt
;
12101 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12103 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12104 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12105 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12106 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12107 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12109 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12111 uint salt_len
= input_len
- 40 - 1;
12113 char *salt_buf
= input_buf
+ 40 + 1;
12115 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12117 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12119 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12121 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12124 pstoken
->salt_len
= salt_len
/ 2;
12126 /* some fake salt for the sorting mechanisms */
12128 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12129 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12130 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12131 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12132 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12133 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12134 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12135 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12137 salt
->salt_len
= 32;
12139 /* we need to check if we can precompute some of the data --
12140 this is possible since the scheme is badly designed */
12142 pstoken
->pc_digest
[0] = SHA1M_A
;
12143 pstoken
->pc_digest
[1] = SHA1M_B
;
12144 pstoken
->pc_digest
[2] = SHA1M_C
;
12145 pstoken
->pc_digest
[3] = SHA1M_D
;
12146 pstoken
->pc_digest
[4] = SHA1M_E
;
12148 pstoken
->pc_offset
= 0;
12150 for (int i
= 0; i
< (int) pstoken
->salt_len
- 63; i
+= 64)
12154 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12155 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12156 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12157 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12158 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12159 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12160 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12161 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12162 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12163 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12164 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12165 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12166 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12167 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12168 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12169 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12171 sha1_64 (w
, pstoken
->pc_digest
);
12173 pstoken
->pc_offset
+= 16;
12176 return (PARSER_OK
);
12179 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12181 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12183 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12185 u32
*digest
= (u32
*) hash_buf
->digest
;
12187 u8 tmp_buf
[100] = { 0 };
12189 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12191 memcpy (digest
, tmp_buf
, 20);
12193 digest
[0] = byte_swap_32 (digest
[0]);
12194 digest
[1] = byte_swap_32 (digest
[1]);
12195 digest
[2] = byte_swap_32 (digest
[2]);
12196 digest
[3] = byte_swap_32 (digest
[3]);
12197 digest
[4] = byte_swap_32 (digest
[4]);
12199 digest
[0] -= SHA1M_A
;
12200 digest
[1] -= SHA1M_B
;
12201 digest
[2] -= SHA1M_C
;
12202 digest
[3] -= SHA1M_D
;
12203 digest
[4] -= SHA1M_E
;
12205 return (PARSER_OK
);
12208 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12210 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12212 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12214 u32
*digest
= (u32
*) hash_buf
->digest
;
12216 salt_t
*salt
= hash_buf
->salt
;
12218 u8 tmp_buf
[100] = { 0 };
12220 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12222 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12224 memcpy (digest
, tmp_buf
, 20);
12226 int salt_len
= tmp_len
- 20;
12228 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12230 salt
->salt_len
= salt_len
;
12232 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12234 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12236 char *ptr
= (char *) salt
->salt_buf
;
12238 ptr
[salt
->salt_len
] = 0x80;
12241 digest
[0] = byte_swap_32 (digest
[0]);
12242 digest
[1] = byte_swap_32 (digest
[1]);
12243 digest
[2] = byte_swap_32 (digest
[2]);
12244 digest
[3] = byte_swap_32 (digest
[3]);
12245 digest
[4] = byte_swap_32 (digest
[4]);
12247 digest
[0] -= SHA1M_A
;
12248 digest
[1] -= SHA1M_B
;
12249 digest
[2] -= SHA1M_C
;
12250 digest
[3] -= SHA1M_D
;
12251 digest
[4] -= SHA1M_E
;
12253 return (PARSER_OK
);
12256 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12258 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12260 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12262 u32
*digest
= (u32
*) hash_buf
->digest
;
12264 salt_t
*salt
= hash_buf
->salt
;
12266 char *salt_buf
= input_buf
+ 6;
12270 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12272 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12274 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12276 salt
->salt_len
= salt_len
;
12278 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12280 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12281 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12282 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12283 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12284 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12286 digest
[0] -= SHA1M_A
;
12287 digest
[1] -= SHA1M_B
;
12288 digest
[2] -= SHA1M_C
;
12289 digest
[3] -= SHA1M_D
;
12290 digest
[4] -= SHA1M_E
;
12292 return (PARSER_OK
);
12295 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12297 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12299 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12301 u32
*digest
= (u32
*) hash_buf
->digest
;
12303 salt_t
*salt
= hash_buf
->salt
;
12305 char *salt_buf
= input_buf
+ 6;
12309 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12311 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12313 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12315 salt
->salt_len
= salt_len
;
12317 char *hash_pos
= input_buf
+ 6 + 8;
12319 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12320 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12321 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12322 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12323 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12325 digest
[0] -= SHA1M_A
;
12326 digest
[1] -= SHA1M_B
;
12327 digest
[2] -= SHA1M_C
;
12328 digest
[3] -= SHA1M_D
;
12329 digest
[4] -= SHA1M_E
;
12331 return (PARSER_OK
);
12334 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12336 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12338 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12340 u64
*digest
= (u64
*) hash_buf
->digest
;
12342 salt_t
*salt
= hash_buf
->salt
;
12344 char *salt_buf
= input_buf
+ 6;
12348 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12350 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12352 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12354 salt
->salt_len
= salt_len
;
12356 char *hash_pos
= input_buf
+ 6 + 8;
12358 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12359 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12360 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12361 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12362 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12363 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12364 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12365 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12367 digest
[0] -= SHA512M_A
;
12368 digest
[1] -= SHA512M_B
;
12369 digest
[2] -= SHA512M_C
;
12370 digest
[3] -= SHA512M_D
;
12371 digest
[4] -= SHA512M_E
;
12372 digest
[5] -= SHA512M_F
;
12373 digest
[6] -= SHA512M_G
;
12374 digest
[7] -= SHA512M_H
;
12376 return (PARSER_OK
);
12379 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12381 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12383 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12387 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12390 u32
*digest
= (u32
*) hash_buf
->digest
;
12392 salt_t
*salt
= hash_buf
->salt
;
12394 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12395 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12399 digest
[0] = byte_swap_32 (digest
[0]);
12400 digest
[1] = byte_swap_32 (digest
[1]);
12402 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12404 uint salt_len
= input_len
- 16 - 1;
12406 char *salt_buf
= input_buf
+ 16 + 1;
12408 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12410 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12412 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12414 salt
->salt_len
= salt_len
;
12416 return (PARSER_OK
);
12419 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12421 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12423 u32
*digest
= (u32
*) hash_buf
->digest
;
12425 salt_t
*salt
= hash_buf
->salt
;
12427 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12428 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12429 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12430 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12431 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12433 digest
[0] -= SHA1M_A
;
12434 digest
[1] -= SHA1M_B
;
12435 digest
[2] -= SHA1M_C
;
12436 digest
[3] -= SHA1M_D
;
12437 digest
[4] -= SHA1M_E
;
12439 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12441 uint salt_len
= input_len
- 40 - 1;
12443 char *salt_buf
= input_buf
+ 40 + 1;
12445 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12447 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12449 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12451 salt
->salt_len
= salt_len
;
12453 return (PARSER_OK
);
12456 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12458 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12460 u32
*digest
= (u32
*) hash_buf
->digest
;
12462 salt_t
*salt
= hash_buf
->salt
;
12464 char *hash_pos
= input_buf
;
12466 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12467 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12468 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12469 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12470 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12471 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12472 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12473 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12474 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12475 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12476 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12477 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12478 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12479 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12480 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12481 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12483 char *salt_pos
= input_buf
+ 128;
12485 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12486 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12487 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12488 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12490 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12491 salt
->salt_len
= 16;
12493 return (PARSER_OK
);
12496 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12498 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12500 u32
*digest
= (u32
*) hash_buf
->digest
;
12502 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12503 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12504 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12505 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12506 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12507 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12508 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12509 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12511 digest
[0] -= SHA256M_A
;
12512 digest
[1] -= SHA256M_B
;
12513 digest
[2] -= SHA256M_C
;
12514 digest
[3] -= SHA256M_D
;
12515 digest
[4] -= SHA256M_E
;
12516 digest
[5] -= SHA256M_F
;
12517 digest
[6] -= SHA256M_G
;
12518 digest
[7] -= SHA256M_H
;
12520 return (PARSER_OK
);
12523 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12525 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12527 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12531 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12534 u32
*digest
= (u32
*) hash_buf
->digest
;
12536 salt_t
*salt
= hash_buf
->salt
;
12538 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12539 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12540 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12541 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12542 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12543 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12544 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12545 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12547 digest
[0] -= SHA256M_A
;
12548 digest
[1] -= SHA256M_B
;
12549 digest
[2] -= SHA256M_C
;
12550 digest
[3] -= SHA256M_D
;
12551 digest
[4] -= SHA256M_E
;
12552 digest
[5] -= SHA256M_F
;
12553 digest
[6] -= SHA256M_G
;
12554 digest
[7] -= SHA256M_H
;
12556 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12558 uint salt_len
= input_len
- 64 - 1;
12560 char *salt_buf
= input_buf
+ 64 + 1;
12562 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12564 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12566 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12568 salt
->salt_len
= salt_len
;
12570 return (PARSER_OK
);
12573 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12575 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12577 u64
*digest
= (u64
*) hash_buf
->digest
;
12579 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12580 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12581 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12582 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12583 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12584 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12588 digest
[0] -= SHA384M_A
;
12589 digest
[1] -= SHA384M_B
;
12590 digest
[2] -= SHA384M_C
;
12591 digest
[3] -= SHA384M_D
;
12592 digest
[4] -= SHA384M_E
;
12593 digest
[5] -= SHA384M_F
;
12597 return (PARSER_OK
);
12600 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12602 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12604 u64
*digest
= (u64
*) hash_buf
->digest
;
12606 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12607 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12608 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12609 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12610 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12611 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12612 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12613 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12615 digest
[0] -= SHA512M_A
;
12616 digest
[1] -= SHA512M_B
;
12617 digest
[2] -= SHA512M_C
;
12618 digest
[3] -= SHA512M_D
;
12619 digest
[4] -= SHA512M_E
;
12620 digest
[5] -= SHA512M_F
;
12621 digest
[6] -= SHA512M_G
;
12622 digest
[7] -= SHA512M_H
;
12624 return (PARSER_OK
);
12627 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12629 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12631 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12635 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12638 u64
*digest
= (u64
*) hash_buf
->digest
;
12640 salt_t
*salt
= hash_buf
->salt
;
12642 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12643 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12644 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12645 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12646 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12647 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12648 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12649 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12651 digest
[0] -= SHA512M_A
;
12652 digest
[1] -= SHA512M_B
;
12653 digest
[2] -= SHA512M_C
;
12654 digest
[3] -= SHA512M_D
;
12655 digest
[4] -= SHA512M_E
;
12656 digest
[5] -= SHA512M_F
;
12657 digest
[6] -= SHA512M_G
;
12658 digest
[7] -= SHA512M_H
;
12660 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12662 uint salt_len
= input_len
- 128 - 1;
12664 char *salt_buf
= input_buf
+ 128 + 1;
12666 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12668 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12670 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12672 salt
->salt_len
= salt_len
;
12674 return (PARSER_OK
);
12677 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12679 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12681 u64
*digest
= (u64
*) hash_buf
->digest
;
12683 salt_t
*salt
= hash_buf
->salt
;
12685 char *salt_pos
= input_buf
+ 3;
12687 uint iterations_len
= 0;
12689 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12693 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12695 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12696 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12700 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12704 iterations_len
+= 8;
12708 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12711 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12713 char *hash_pos
= strchr (salt_pos
, '$');
12715 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12717 uint salt_len
= hash_pos
- salt_pos
;
12719 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12721 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12723 salt
->salt_len
= salt_len
;
12727 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12729 return (PARSER_OK
);
12732 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12734 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12736 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12738 u64
*digest
= (u64
*) hash_buf
->digest
;
12740 salt_t
*salt
= hash_buf
->salt
;
12742 uint keccak_mdlen
= input_len
/ 2;
12744 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12746 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12748 digest
[i
] = byte_swap_64 (digest
[i
]);
12751 salt
->keccak_mdlen
= keccak_mdlen
;
12753 return (PARSER_OK
);
12756 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12758 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12760 u32
*digest
= (u32
*) hash_buf
->digest
;
12762 salt_t
*salt
= hash_buf
->salt
;
12764 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12767 * Parse that strange long line
12772 size_t in_len
[9] = { 0 };
12774 in_off
[0] = strtok (input_buf
, ":");
12776 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12778 in_len
[0] = strlen (in_off
[0]);
12782 for (i
= 1; i
< 9; i
++)
12784 in_off
[i
] = strtok (NULL
, ":");
12786 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12788 in_len
[i
] = strlen (in_off
[i
]);
12791 char *ptr
= (char *) ikepsk
->msg_buf
;
12793 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12794 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12795 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12796 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12797 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12798 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12802 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12804 ptr
= (char *) ikepsk
->nr_buf
;
12806 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12807 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12811 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12814 * Store to database
12819 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12820 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12821 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12822 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12824 digest
[0] = byte_swap_32 (digest
[0]);
12825 digest
[1] = byte_swap_32 (digest
[1]);
12826 digest
[2] = byte_swap_32 (digest
[2]);
12827 digest
[3] = byte_swap_32 (digest
[3]);
12829 salt
->salt_len
= 32;
12831 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12832 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12833 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12834 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12835 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12836 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12837 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12838 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12840 return (PARSER_OK
);
12843 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12845 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12847 u32
*digest
= (u32
*) hash_buf
->digest
;
12849 salt_t
*salt
= hash_buf
->salt
;
12851 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12854 * Parse that strange long line
12859 size_t in_len
[9] = { 0 };
12861 in_off
[0] = strtok (input_buf
, ":");
12863 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12865 in_len
[0] = strlen (in_off
[0]);
12869 for (i
= 1; i
< 9; i
++)
12871 in_off
[i
] = strtok (NULL
, ":");
12873 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12875 in_len
[i
] = strlen (in_off
[i
]);
12878 char *ptr
= (char *) ikepsk
->msg_buf
;
12880 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12881 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12882 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12883 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12884 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12885 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12889 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12891 ptr
= (char *) ikepsk
->nr_buf
;
12893 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12894 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12898 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12901 * Store to database
12906 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12907 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12908 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12909 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12910 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12912 salt
->salt_len
= 32;
12914 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12915 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12916 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12917 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12918 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12919 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12920 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12921 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12923 return (PARSER_OK
);
12926 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12928 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12930 u32
*digest
= (u32
*) hash_buf
->digest
;
12932 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12933 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12934 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12935 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12936 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12938 digest
[0] = byte_swap_32 (digest
[0]);
12939 digest
[1] = byte_swap_32 (digest
[1]);
12940 digest
[2] = byte_swap_32 (digest
[2]);
12941 digest
[3] = byte_swap_32 (digest
[3]);
12942 digest
[4] = byte_swap_32 (digest
[4]);
12944 return (PARSER_OK
);
12947 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12949 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12951 u32
*digest
= (u32
*) hash_buf
->digest
;
12953 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12954 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12955 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12956 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12957 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12958 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12959 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12960 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12961 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12962 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12963 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12964 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12965 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12966 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12967 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12968 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12970 return (PARSER_OK
);
12973 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12975 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12977 u32
*digest
= (u32
*) hash_buf
->digest
;
12979 salt_t
*salt
= hash_buf
->salt
;
12981 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12982 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12983 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12984 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12985 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12987 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12989 uint salt_len
= input_len
- 40 - 1;
12991 char *salt_buf
= input_buf
+ 40 + 1;
12993 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12995 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12997 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12999 salt
->salt_len
= salt_len
;
13001 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
13003 return (PARSER_OK
);
13006 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13008 u32
*digest
= (u32
*) hash_buf
->digest
;
13010 salt_t
*salt
= hash_buf
->salt
;
13012 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13014 if (input_len
== 0)
13016 log_error ("TrueCrypt container not specified");
13021 FILE *fp
= fopen (input_buf
, "rb");
13025 log_error ("%s: %s", input_buf
, strerror (errno
));
13030 char buf
[512] = { 0 };
13032 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13036 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13038 memcpy (tc
->salt_buf
, buf
, 64);
13040 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13042 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13044 salt
->salt_len
= 4;
13046 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
13048 tc
->signature
= 0x45555254; // "TRUE"
13050 digest
[0] = tc
->data_buf
[0];
13052 return (PARSER_OK
);
13055 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13057 u32
*digest
= (u32
*) hash_buf
->digest
;
13059 salt_t
*salt
= hash_buf
->salt
;
13061 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13063 if (input_len
== 0)
13065 log_error ("TrueCrypt container not specified");
13070 FILE *fp
= fopen (input_buf
, "rb");
13074 log_error ("%s: %s", input_buf
, strerror (errno
));
13079 char buf
[512] = { 0 };
13081 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13085 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13087 memcpy (tc
->salt_buf
, buf
, 64);
13089 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13091 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13093 salt
->salt_len
= 4;
13095 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13097 tc
->signature
= 0x45555254; // "TRUE"
13099 digest
[0] = tc
->data_buf
[0];
13101 return (PARSER_OK
);
13104 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13106 u32
*digest
= (u32
*) hash_buf
->digest
;
13108 salt_t
*salt
= hash_buf
->salt
;
13110 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13112 if (input_len
== 0)
13114 log_error ("VeraCrypt container not specified");
13119 FILE *fp
= fopen (input_buf
, "rb");
13123 log_error ("%s: %s", input_buf
, strerror (errno
));
13128 char buf
[512] = { 0 };
13130 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13134 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13136 memcpy (tc
->salt_buf
, buf
, 64);
13138 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13140 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13142 salt
->salt_len
= 4;
13144 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13146 tc
->signature
= 0x41524556; // "VERA"
13148 digest
[0] = tc
->data_buf
[0];
13150 return (PARSER_OK
);
13153 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13155 u32
*digest
= (u32
*) hash_buf
->digest
;
13157 salt_t
*salt
= hash_buf
->salt
;
13159 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13161 if (input_len
== 0)
13163 log_error ("VeraCrypt container not specified");
13168 FILE *fp
= fopen (input_buf
, "rb");
13172 log_error ("%s: %s", input_buf
, strerror (errno
));
13177 char buf
[512] = { 0 };
13179 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13183 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13185 memcpy (tc
->salt_buf
, buf
, 64);
13187 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13189 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13191 salt
->salt_len
= 4;
13193 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13195 tc
->signature
= 0x41524556; // "VERA"
13197 digest
[0] = tc
->data_buf
[0];
13199 return (PARSER_OK
);
13202 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13204 u32
*digest
= (u32
*) hash_buf
->digest
;
13206 salt_t
*salt
= hash_buf
->salt
;
13208 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13210 if (input_len
== 0)
13212 log_error ("VeraCrypt container not specified");
13217 FILE *fp
= fopen (input_buf
, "rb");
13221 log_error ("%s: %s", input_buf
, strerror (errno
));
13226 char buf
[512] = { 0 };
13228 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13232 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13234 memcpy (tc
->salt_buf
, buf
, 64);
13236 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13238 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13240 salt
->salt_len
= 4;
13242 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13244 tc
->signature
= 0x41524556; // "VERA"
13246 digest
[0] = tc
->data_buf
[0];
13248 return (PARSER_OK
);
13251 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13253 u32
*digest
= (u32
*) hash_buf
->digest
;
13255 salt_t
*salt
= hash_buf
->salt
;
13257 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13259 if (input_len
== 0)
13261 log_error ("VeraCrypt container not specified");
13266 FILE *fp
= fopen (input_buf
, "rb");
13270 log_error ("%s: %s", input_buf
, strerror (errno
));
13275 char buf
[512] = { 0 };
13277 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13281 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13283 memcpy (tc
->salt_buf
, buf
, 64);
13285 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13287 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13289 salt
->salt_len
= 4;
13291 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13293 tc
->signature
= 0x41524556; // "VERA"
13295 digest
[0] = tc
->data_buf
[0];
13297 return (PARSER_OK
);
13300 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13302 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13304 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13306 u32
*digest
= (u32
*) hash_buf
->digest
;
13308 salt_t
*salt
= hash_buf
->salt
;
13310 char *salt_pos
= input_buf
+ 6;
13312 char *hash_pos
= strchr (salt_pos
, '$');
13314 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13316 uint salt_len
= hash_pos
- salt_pos
;
13318 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13320 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13322 salt
->salt_len
= salt_len
;
13324 salt
->salt_iter
= 1000;
13328 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13330 return (PARSER_OK
);
13333 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13335 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13337 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13339 u32
*digest
= (u32
*) hash_buf
->digest
;
13341 salt_t
*salt
= hash_buf
->salt
;
13343 char *iter_pos
= input_buf
+ 7;
13345 char *salt_pos
= strchr (iter_pos
, '$');
13347 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13351 char *hash_pos
= strchr (salt_pos
, '$');
13353 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13355 uint salt_len
= hash_pos
- salt_pos
;
13357 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13359 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13361 salt
->salt_len
= salt_len
;
13363 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13365 salt
->salt_sign
[0] = atoi (salt_iter
);
13367 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13371 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13373 digest
[0] = byte_swap_32 (digest
[0]);
13374 digest
[1] = byte_swap_32 (digest
[1]);
13375 digest
[2] = byte_swap_32 (digest
[2]);
13376 digest
[3] = byte_swap_32 (digest
[3]);
13377 digest
[4] = byte_swap_32 (digest
[4]);
13379 return (PARSER_OK
);
13382 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13384 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13386 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13388 u32
*digest
= (u32
*) hash_buf
->digest
;
13390 salt_t
*salt
= hash_buf
->salt
;
13392 char *iter_pos
= input_buf
+ 9;
13394 char *salt_pos
= strchr (iter_pos
, '$');
13396 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13400 char *hash_pos
= strchr (salt_pos
, '$');
13402 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13404 uint salt_len
= hash_pos
- salt_pos
;
13406 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13408 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13410 salt
->salt_len
= salt_len
;
13412 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13414 salt
->salt_sign
[0] = atoi (salt_iter
);
13416 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13420 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13422 digest
[0] = byte_swap_32 (digest
[0]);
13423 digest
[1] = byte_swap_32 (digest
[1]);
13424 digest
[2] = byte_swap_32 (digest
[2]);
13425 digest
[3] = byte_swap_32 (digest
[3]);
13426 digest
[4] = byte_swap_32 (digest
[4]);
13427 digest
[5] = byte_swap_32 (digest
[5]);
13428 digest
[6] = byte_swap_32 (digest
[6]);
13429 digest
[7] = byte_swap_32 (digest
[7]);
13431 return (PARSER_OK
);
13434 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13436 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13438 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13440 u64
*digest
= (u64
*) hash_buf
->digest
;
13442 salt_t
*salt
= hash_buf
->salt
;
13444 char *iter_pos
= input_buf
+ 9;
13446 char *salt_pos
= strchr (iter_pos
, '$');
13448 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13452 char *hash_pos
= strchr (salt_pos
, '$');
13454 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13456 uint salt_len
= hash_pos
- salt_pos
;
13458 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13460 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13462 salt
->salt_len
= salt_len
;
13464 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13466 salt
->salt_sign
[0] = atoi (salt_iter
);
13468 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13472 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13474 digest
[0] = byte_swap_64 (digest
[0]);
13475 digest
[1] = byte_swap_64 (digest
[1]);
13476 digest
[2] = byte_swap_64 (digest
[2]);
13477 digest
[3] = byte_swap_64 (digest
[3]);
13478 digest
[4] = byte_swap_64 (digest
[4]);
13479 digest
[5] = byte_swap_64 (digest
[5]);
13480 digest
[6] = byte_swap_64 (digest
[6]);
13481 digest
[7] = byte_swap_64 (digest
[7]);
13483 return (PARSER_OK
);
13486 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13488 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13490 u32
*digest
= (u32
*) hash_buf
->digest
;
13492 salt_t
*salt
= hash_buf
->salt
;
13494 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13500 char *iterations_pos
= input_buf
;
13502 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13504 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13506 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13508 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13512 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13514 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13516 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13518 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13520 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13522 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13527 * pbkdf2 iterations
13530 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13533 * handle salt encoding
13536 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13538 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13540 const char p0
= saltbuf_pos
[i
+ 0];
13541 const char p1
= saltbuf_pos
[i
+ 1];
13543 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13544 | hex_convert (p0
) << 4;
13547 salt
->salt_len
= saltbuf_len
/ 2;
13550 * handle cipher encoding
13553 uint
*tmp
= (uint
*) mymalloc (32);
13555 char *cipherbuf_ptr
= (char *) tmp
;
13557 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13559 const char p0
= cipherbuf_pos
[i
+ 0];
13560 const char p1
= cipherbuf_pos
[i
+ 1];
13562 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13563 | hex_convert (p0
) << 4;
13566 // iv is stored at salt_buf 4 (length 16)
13567 // data is stored at salt_buf 8 (length 16)
13569 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13570 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13571 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13572 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13574 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13575 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13576 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13577 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13581 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13583 const char p0
= cipherbuf_pos
[j
+ 0];
13584 const char p1
= cipherbuf_pos
[j
+ 1];
13586 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13587 | hex_convert (p0
) << 4;
13594 digest
[0] = 0x10101010;
13595 digest
[1] = 0x10101010;
13596 digest
[2] = 0x10101010;
13597 digest
[3] = 0x10101010;
13599 return (PARSER_OK
);
13602 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13604 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13606 u32
*digest
= (u32
*) hash_buf
->digest
;
13608 salt_t
*salt
= hash_buf
->salt
;
13610 char *hashbuf_pos
= input_buf
;
13612 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13614 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13616 uint hash_len
= iterations_pos
- hashbuf_pos
;
13618 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13622 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13624 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13626 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13630 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13632 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13634 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13636 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13638 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13640 salt
->salt_len
= salt_len
;
13642 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13644 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13645 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13646 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13647 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13649 return (PARSER_OK
);
13652 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13654 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13656 u32
*digest
= (u32
*) hash_buf
->digest
;
13658 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13659 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13660 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13661 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13662 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13663 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13664 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13665 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13667 digest
[0] = byte_swap_32 (digest
[0]);
13668 digest
[1] = byte_swap_32 (digest
[1]);
13669 digest
[2] = byte_swap_32 (digest
[2]);
13670 digest
[3] = byte_swap_32 (digest
[3]);
13671 digest
[4] = byte_swap_32 (digest
[4]);
13672 digest
[5] = byte_swap_32 (digest
[5]);
13673 digest
[6] = byte_swap_32 (digest
[6]);
13674 digest
[7] = byte_swap_32 (digest
[7]);
13676 return (PARSER_OK
);
13679 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13681 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13683 u32
*digest
= (u32
*) hash_buf
->digest
;
13685 salt_t
*salt
= hash_buf
->salt
;
13687 char *salt_pos
= input_buf
+ 3;
13689 uint iterations_len
= 0;
13691 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13695 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13697 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13698 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13702 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13706 iterations_len
+= 8;
13710 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13713 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13715 char *hash_pos
= strchr (salt_pos
, '$');
13717 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13719 uint salt_len
= hash_pos
- salt_pos
;
13721 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13723 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13725 salt
->salt_len
= salt_len
;
13729 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13731 return (PARSER_OK
);
13734 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13736 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13738 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13740 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13742 u64
*digest
= (u64
*) hash_buf
->digest
;
13744 salt_t
*salt
= hash_buf
->salt
;
13746 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13748 char *iter_pos
= input_buf
+ 4;
13750 char *salt_pos
= strchr (iter_pos
, '$');
13752 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13756 char *hash_pos
= strchr (salt_pos
, '$');
13758 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13760 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13764 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13765 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13766 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13767 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13768 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13769 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13770 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13771 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13773 uint salt_len
= hash_pos
- salt_pos
- 1;
13775 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13777 salt
->salt_len
= salt_len
/ 2;
13779 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13780 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13781 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13782 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13783 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13784 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13785 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13786 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13788 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13789 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13790 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13791 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13792 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13793 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13794 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13795 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13796 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13797 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13799 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13801 salt
->salt_iter
= atoi (iter_pos
) - 1;
13803 return (PARSER_OK
);
13806 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13808 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13810 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13812 u32
*digest
= (u32
*) hash_buf
->digest
;
13814 salt_t
*salt
= hash_buf
->salt
;
13816 char *salt_pos
= input_buf
+ 14;
13818 char *hash_pos
= strchr (salt_pos
, '*');
13820 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13824 uint salt_len
= hash_pos
- salt_pos
- 1;
13826 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13828 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13830 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13832 salt
->salt_len
= salt_len
;
13834 u8 tmp_buf
[100] = { 0 };
13836 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13838 memcpy (digest
, tmp_buf
, 32);
13840 digest
[0] = byte_swap_32 (digest
[0]);
13841 digest
[1] = byte_swap_32 (digest
[1]);
13842 digest
[2] = byte_swap_32 (digest
[2]);
13843 digest
[3] = byte_swap_32 (digest
[3]);
13844 digest
[4] = byte_swap_32 (digest
[4]);
13845 digest
[5] = byte_swap_32 (digest
[5]);
13846 digest
[6] = byte_swap_32 (digest
[6]);
13847 digest
[7] = byte_swap_32 (digest
[7]);
13849 digest
[0] -= SHA256M_A
;
13850 digest
[1] -= SHA256M_B
;
13851 digest
[2] -= SHA256M_C
;
13852 digest
[3] -= SHA256M_D
;
13853 digest
[4] -= SHA256M_E
;
13854 digest
[5] -= SHA256M_F
;
13855 digest
[6] -= SHA256M_G
;
13856 digest
[7] -= SHA256M_H
;
13858 return (PARSER_OK
);
13861 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13863 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13865 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13867 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13869 u64
*digest
= (u64
*) hash_buf
->digest
;
13871 salt_t
*salt
= hash_buf
->salt
;
13873 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13875 char *iter_pos
= input_buf
+ 19;
13877 char *salt_pos
= strchr (iter_pos
, '.');
13879 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13883 char *hash_pos
= strchr (salt_pos
, '.');
13885 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13887 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13891 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13892 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13893 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13894 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13895 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13896 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13897 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13898 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13900 uint salt_len
= hash_pos
- salt_pos
- 1;
13904 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13908 for (i
= 0; i
< salt_len
; i
++)
13910 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13913 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13914 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13916 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13918 salt
->salt_len
= salt_len
;
13920 salt
->salt_iter
= atoi (iter_pos
) - 1;
13922 return (PARSER_OK
);
13925 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13927 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13929 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13931 u64
*digest
= (u64
*) hash_buf
->digest
;
13933 salt_t
*salt
= hash_buf
->salt
;
13935 u8 tmp_buf
[120] = { 0 };
13937 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13939 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13941 memcpy (digest
, tmp_buf
, 64);
13943 digest
[0] = byte_swap_64 (digest
[0]);
13944 digest
[1] = byte_swap_64 (digest
[1]);
13945 digest
[2] = byte_swap_64 (digest
[2]);
13946 digest
[3] = byte_swap_64 (digest
[3]);
13947 digest
[4] = byte_swap_64 (digest
[4]);
13948 digest
[5] = byte_swap_64 (digest
[5]);
13949 digest
[6] = byte_swap_64 (digest
[6]);
13950 digest
[7] = byte_swap_64 (digest
[7]);
13952 digest
[0] -= SHA512M_A
;
13953 digest
[1] -= SHA512M_B
;
13954 digest
[2] -= SHA512M_C
;
13955 digest
[3] -= SHA512M_D
;
13956 digest
[4] -= SHA512M_E
;
13957 digest
[5] -= SHA512M_F
;
13958 digest
[6] -= SHA512M_G
;
13959 digest
[7] -= SHA512M_H
;
13961 int salt_len
= tmp_len
- 64;
13963 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13965 salt
->salt_len
= salt_len
;
13967 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13969 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13971 char *ptr
= (char *) salt
->salt_buf
;
13973 ptr
[salt
->salt_len
] = 0x80;
13976 return (PARSER_OK
);
13979 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13981 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13983 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13987 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13990 u32
*digest
= (u32
*) hash_buf
->digest
;
13992 salt_t
*salt
= hash_buf
->salt
;
13994 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13995 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13996 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13997 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13999 digest
[0] = byte_swap_32 (digest
[0]);
14000 digest
[1] = byte_swap_32 (digest
[1]);
14001 digest
[2] = byte_swap_32 (digest
[2]);
14002 digest
[3] = byte_swap_32 (digest
[3]);
14004 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14006 uint salt_len
= input_len
- 32 - 1;
14008 char *salt_buf
= input_buf
+ 32 + 1;
14010 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14012 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14014 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14016 salt
->salt_len
= salt_len
;
14018 return (PARSER_OK
);
14021 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14023 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14025 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
14029 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
14032 u32
*digest
= (u32
*) hash_buf
->digest
;
14034 salt_t
*salt
= hash_buf
->salt
;
14036 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14037 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14038 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14039 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14040 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14042 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14044 uint salt_len
= input_len
- 40 - 1;
14046 char *salt_buf
= input_buf
+ 40 + 1;
14048 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14050 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14052 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14054 salt
->salt_len
= salt_len
;
14056 return (PARSER_OK
);
14059 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14061 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14063 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14067 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14070 u32
*digest
= (u32
*) hash_buf
->digest
;
14072 salt_t
*salt
= hash_buf
->salt
;
14074 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14075 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14076 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14077 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14078 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14079 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14080 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14081 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14083 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14085 uint salt_len
= input_len
- 64 - 1;
14087 char *salt_buf
= input_buf
+ 64 + 1;
14089 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14091 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14093 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14095 salt
->salt_len
= salt_len
;
14097 return (PARSER_OK
);
14100 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14102 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14104 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14108 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14111 u64
*digest
= (u64
*) hash_buf
->digest
;
14113 salt_t
*salt
= hash_buf
->salt
;
14115 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14116 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14117 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14118 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14119 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14120 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14121 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14122 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14124 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14126 uint salt_len
= input_len
- 128 - 1;
14128 char *salt_buf
= input_buf
+ 128 + 1;
14130 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14132 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14134 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14136 salt
->salt_len
= salt_len
;
14138 return (PARSER_OK
);
14141 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14143 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14145 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14147 u32
*digest
= (u32
*) hash_buf
->digest
;
14149 salt_t
*salt
= hash_buf
->salt
;
14151 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14157 char *user_pos
= input_buf
+ 10 + 1;
14159 char *realm_pos
= strchr (user_pos
, '$');
14161 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14163 uint user_len
= realm_pos
- user_pos
;
14165 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14169 char *salt_pos
= strchr (realm_pos
, '$');
14171 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14173 uint realm_len
= salt_pos
- realm_pos
;
14175 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14179 char *data_pos
= strchr (salt_pos
, '$');
14181 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14183 uint salt_len
= data_pos
- salt_pos
;
14185 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14189 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14191 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14197 memcpy (krb5pa
->user
, user_pos
, user_len
);
14198 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14199 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14201 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14203 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14205 const char p0
= data_pos
[i
+ 0];
14206 const char p1
= data_pos
[i
+ 1];
14208 *timestamp_ptr
++ = hex_convert (p1
) << 0
14209 | hex_convert (p0
) << 4;
14212 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14214 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14216 const char p0
= data_pos
[i
+ 0];
14217 const char p1
= data_pos
[i
+ 1];
14219 *checksum_ptr
++ = hex_convert (p1
) << 0
14220 | hex_convert (p0
) << 4;
14224 * copy some data to generic buffers to make sorting happy
14227 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14228 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14229 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14230 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14231 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14232 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14233 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14234 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14235 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14237 salt
->salt_len
= 36;
14239 digest
[0] = krb5pa
->checksum
[0];
14240 digest
[1] = krb5pa
->checksum
[1];
14241 digest
[2] = krb5pa
->checksum
[2];
14242 digest
[3] = krb5pa
->checksum
[3];
14244 return (PARSER_OK
);
14247 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14249 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14251 u32
*digest
= (u32
*) hash_buf
->digest
;
14253 salt_t
*salt
= hash_buf
->salt
;
14259 char *salt_pos
= input_buf
;
14261 char *hash_pos
= strchr (salt_pos
, '$');
14263 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14265 uint salt_len
= hash_pos
- salt_pos
;
14267 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14271 uint hash_len
= input_len
- 1 - salt_len
;
14273 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14281 for (uint i
= 0; i
< salt_len
; i
++)
14283 if (salt_pos
[i
] == ' ') continue;
14288 // SAP user names cannot be longer than 12 characters
14289 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14291 // SAP user name cannot start with ! or ?
14292 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14298 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14300 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14302 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14304 salt
->salt_len
= salt_len
;
14306 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14307 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14311 digest
[0] = byte_swap_32 (digest
[0]);
14312 digest
[1] = byte_swap_32 (digest
[1]);
14314 return (PARSER_OK
);
14317 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14319 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14321 u32
*digest
= (u32
*) hash_buf
->digest
;
14323 salt_t
*salt
= hash_buf
->salt
;
14329 char *salt_pos
= input_buf
;
14331 char *hash_pos
= strchr (salt_pos
, '$');
14333 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14335 uint salt_len
= hash_pos
- salt_pos
;
14337 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14341 uint hash_len
= input_len
- 1 - salt_len
;
14343 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14351 for (uint i
= 0; i
< salt_len
; i
++)
14353 if (salt_pos
[i
] == ' ') continue;
14358 // SAP user names cannot be longer than 12 characters
14359 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14360 // so far nobody complained so we stay with this because it helps in optimization
14361 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14363 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14365 // SAP user name cannot start with ! or ?
14366 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14372 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14374 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14376 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14378 salt
->salt_len
= salt_len
;
14380 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14381 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14382 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14383 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14384 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14386 return (PARSER_OK
);
14389 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14391 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14393 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14395 u64
*digest
= (u64
*) hash_buf
->digest
;
14397 salt_t
*salt
= hash_buf
->salt
;
14399 char *iter_pos
= input_buf
+ 3;
14401 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14403 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14405 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14407 salt
->salt_iter
= salt_iter
;
14409 char *salt_pos
= iter_pos
+ 1;
14413 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14415 salt
->salt_len
= salt_len
;
14417 char *hash_pos
= salt_pos
+ salt_len
;
14419 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14423 char *tmp
= (char *) salt
->salt_buf_pc
;
14425 tmp
[0] = hash_pos
[42];
14429 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14430 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14431 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14432 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14438 return (PARSER_OK
);
14441 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14443 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14445 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14447 u32
*digest
= (u32
*) hash_buf
->digest
;
14449 salt_t
*salt
= hash_buf
->salt
;
14451 char *salt_buf
= input_buf
+ 6;
14453 uint salt_len
= 16;
14455 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14457 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14459 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14461 salt
->salt_len
= salt_len
;
14463 char *hash_pos
= input_buf
+ 6 + 16;
14465 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14466 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14467 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14468 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14469 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14470 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14471 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14472 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14474 return (PARSER_OK
);
14477 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14479 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14481 u32
*digest
= (u32
*) hash_buf
->digest
;
14483 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14484 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14488 return (PARSER_OK
);
14491 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14493 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14495 u32
*digest
= (u32
*) hash_buf
->digest
;
14497 salt_t
*salt
= hash_buf
->salt
;
14499 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14501 char *saltbuf_pos
= input_buf
;
14503 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14505 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14507 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14509 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14510 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14512 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14516 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14518 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14520 char *salt_ptr
= (char *) saltbuf_pos
;
14521 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14526 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14528 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14531 rakp_ptr
[j
] = 0x80;
14533 rakp
->salt_len
= j
;
14535 for (i
= 0; i
< 64; i
++)
14537 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14540 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14541 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14542 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14543 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14544 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14545 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14546 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14547 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14549 salt
->salt_len
= 32; // muss min. 32 haben
14551 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14552 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14553 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14554 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14555 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14557 return (PARSER_OK
);
14560 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14562 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14564 u32
*digest
= (u32
*) hash_buf
->digest
;
14566 salt_t
*salt
= hash_buf
->salt
;
14568 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14570 char *salt_pos
= input_buf
+ 1;
14572 memcpy (salt
->salt_buf
, salt_pos
, 8);
14574 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14575 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14577 salt
->salt_len
= 8;
14579 char *hash_pos
= salt_pos
+ 8;
14581 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14582 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14583 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14584 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14585 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14587 digest
[0] -= SHA1M_A
;
14588 digest
[1] -= SHA1M_B
;
14589 digest
[2] -= SHA1M_C
;
14590 digest
[3] -= SHA1M_D
;
14591 digest
[4] -= SHA1M_E
;
14593 return (PARSER_OK
);
14596 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14598 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14600 u32
*digest
= (u32
*) hash_buf
->digest
;
14602 salt_t
*salt
= hash_buf
->salt
;
14604 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14605 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14606 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14607 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14609 digest
[0] = byte_swap_32 (digest
[0]);
14610 digest
[1] = byte_swap_32 (digest
[1]);
14611 digest
[2] = byte_swap_32 (digest
[2]);
14612 digest
[3] = byte_swap_32 (digest
[3]);
14614 digest
[0] -= MD5M_A
;
14615 digest
[1] -= MD5M_B
;
14616 digest
[2] -= MD5M_C
;
14617 digest
[3] -= MD5M_D
;
14619 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14621 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14623 u32
*salt_buf
= salt
->salt_buf
;
14625 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14626 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14627 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14628 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14630 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14631 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14632 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14633 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14635 salt
->salt_len
= 16 + 1;
14637 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14639 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14641 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14643 return (PARSER_OK
);
14646 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14648 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14650 u32
*digest
= (u32
*) hash_buf
->digest
;
14652 salt_t
*salt
= hash_buf
->salt
;
14654 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14660 char *hashbuf_pos
= input_buf
;
14662 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14664 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14666 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14668 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14672 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14674 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14676 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14678 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14682 char *databuf_pos
= strchr (iteration_pos
, ':');
14684 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14686 const uint iteration_len
= databuf_pos
- iteration_pos
;
14688 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14689 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14691 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14693 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14694 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14700 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14701 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14702 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14703 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14704 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14705 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14706 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14707 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14711 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14713 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14715 const char p0
= saltbuf_pos
[i
+ 0];
14716 const char p1
= saltbuf_pos
[i
+ 1];
14718 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14719 | hex_convert (p0
) << 4;
14722 salt
->salt_buf
[4] = 0x01000000;
14723 salt
->salt_buf
[5] = 0x80;
14725 salt
->salt_len
= saltbuf_len
/ 2;
14729 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14733 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14735 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14737 const char p0
= databuf_pos
[i
+ 0];
14738 const char p1
= databuf_pos
[i
+ 1];
14740 *databuf_ptr
++ = hex_convert (p1
) << 0
14741 | hex_convert (p0
) << 4;
14744 *databuf_ptr
++ = 0x80;
14746 for (uint i
= 0; i
< 512; i
++)
14748 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14751 cloudkey
->data_len
= databuf_len
/ 2;
14753 return (PARSER_OK
);
14756 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14758 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14760 u32
*digest
= (u32
*) hash_buf
->digest
;
14762 salt_t
*salt
= hash_buf
->salt
;
14768 char *hashbuf_pos
= input_buf
;
14770 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14772 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14774 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14776 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14780 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14782 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14784 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14786 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14788 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14792 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14794 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14796 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14798 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14800 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14804 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14806 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14807 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14809 // ok, the plan for this algorithm is the following:
14810 // we have 2 salts here, the domain-name and a random salt
14811 // while both are used in the initial transformation,
14812 // only the random salt is used in the following iterations
14813 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14814 // and one that includes only the real salt (stored into salt_buf[]).
14815 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14817 u8 tmp_buf
[100] = { 0 };
14819 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14821 memcpy (digest
, tmp_buf
, 20);
14823 digest
[0] = byte_swap_32 (digest
[0]);
14824 digest
[1] = byte_swap_32 (digest
[1]);
14825 digest
[2] = byte_swap_32 (digest
[2]);
14826 digest
[3] = byte_swap_32 (digest
[3]);
14827 digest
[4] = byte_swap_32 (digest
[4]);
14831 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14833 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14835 char *len_ptr
= NULL
;
14837 for (uint i
= 0; i
< domainbuf_len
; i
++)
14839 if (salt_buf_pc_ptr
[i
] == '.')
14841 len_ptr
= &salt_buf_pc_ptr
[i
];
14851 salt
->salt_buf_pc
[7] = domainbuf_len
;
14855 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14857 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14859 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14861 salt
->salt_len
= salt_len
;
14865 salt
->salt_iter
= atoi (iteration_pos
);
14867 return (PARSER_OK
);
14870 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14872 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14874 u32
*digest
= (u32
*) hash_buf
->digest
;
14876 salt_t
*salt
= hash_buf
->salt
;
14878 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14879 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14880 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14881 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14882 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14884 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14886 uint salt_len
= input_len
- 40 - 1;
14888 char *salt_buf
= input_buf
+ 40 + 1;
14890 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14892 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14894 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14896 salt
->salt_len
= salt_len
;
14898 return (PARSER_OK
);
14901 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14903 const u8 ascii_to_ebcdic
[] =
14905 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14906 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14907 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14908 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14909 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14910 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14911 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14912 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14913 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14914 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14915 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14916 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14917 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14918 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14919 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14920 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14923 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14925 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14927 u32
*digest
= (u32
*) hash_buf
->digest
;
14929 salt_t
*salt
= hash_buf
->salt
;
14931 char *salt_pos
= input_buf
+ 6 + 1;
14933 char *digest_pos
= strchr (salt_pos
, '*');
14935 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14937 uint salt_len
= digest_pos
- salt_pos
;
14939 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14941 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14943 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14947 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14948 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14950 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14952 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14954 salt
->salt_len
= salt_len
;
14956 for (uint i
= 0; i
< salt_len
; i
++)
14958 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14960 for (uint i
= salt_len
; i
< 8; i
++)
14962 salt_buf_pc_ptr
[i
] = 0x40;
14967 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14969 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14970 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14972 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14973 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14975 digest
[0] = byte_swap_32 (digest
[0]);
14976 digest
[1] = byte_swap_32 (digest
[1]);
14978 IP (digest
[0], digest
[1], tt
);
14980 digest
[0] = rotr32 (digest
[0], 29);
14981 digest
[1] = rotr32 (digest
[1], 29);
14985 return (PARSER_OK
);
14988 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14990 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14992 u32
*digest
= (u32
*) hash_buf
->digest
;
14994 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14995 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14996 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14997 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14999 digest
[0] = byte_swap_32 (digest
[0]);
15000 digest
[1] = byte_swap_32 (digest
[1]);
15001 digest
[2] = byte_swap_32 (digest
[2]);
15002 digest
[3] = byte_swap_32 (digest
[3]);
15004 return (PARSER_OK
);
15007 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15009 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
15011 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15013 u32
*digest
= (u32
*) hash_buf
->digest
;
15015 salt_t
*salt
= hash_buf
->salt
;
15017 u8 tmp_buf
[120] = { 0 };
15019 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15021 tmp_buf
[3] += -4; // dont ask!
15023 memcpy (salt
->salt_buf
, tmp_buf
, 5);
15025 salt
->salt_len
= 5;
15027 memcpy (digest
, tmp_buf
+ 5, 9);
15029 // yes, only 9 byte are needed to crack, but 10 to display
15031 salt
->salt_buf_pc
[7] = input_buf
[20];
15033 return (PARSER_OK
);
15036 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15038 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
15040 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15042 u32
*digest
= (u32
*) hash_buf
->digest
;
15044 salt_t
*salt
= hash_buf
->salt
;
15046 u8 tmp_buf
[120] = { 0 };
15048 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15050 tmp_buf
[3] += -4; // dont ask!
15054 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15056 salt
->salt_len
= 16; // Attention: in theory we have 2 salt_len, one for the -m 8700 part (len: 8), 2nd for the 9100 part (len: 16)
15060 char tmp_iter_buf
[11] = { 0 };
15062 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15064 tmp_iter_buf
[10] = 0;
15066 salt
->salt_iter
= atoi (tmp_iter_buf
);
15068 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15070 return (PARSER_SALT_ITERATION
);
15073 salt
->salt_iter
--; // first round in init
15075 // 2 additional bytes for display only
15077 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15078 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15082 memcpy (digest
, tmp_buf
+ 28, 8);
15084 digest
[0] = byte_swap_32 (digest
[0]);
15085 digest
[1] = byte_swap_32 (digest
[1]);
15089 return (PARSER_OK
);
15092 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15094 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15096 u32
*digest
= (u32
*) hash_buf
->digest
;
15098 salt_t
*salt
= hash_buf
->salt
;
15100 char *salt_buf_pos
= input_buf
;
15102 char *hash_buf_pos
= salt_buf_pos
+ 6;
15104 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15105 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15106 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15107 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15108 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15109 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15110 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15111 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15113 digest
[0] -= SHA256M_A
;
15114 digest
[1] -= SHA256M_B
;
15115 digest
[2] -= SHA256M_C
;
15116 digest
[3] -= SHA256M_D
;
15117 digest
[4] -= SHA256M_E
;
15118 digest
[5] -= SHA256M_F
;
15119 digest
[6] -= SHA256M_G
;
15120 digest
[7] -= SHA256M_H
;
15122 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15124 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15126 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15128 salt
->salt_len
= salt_len
;
15130 return (PARSER_OK
);
15133 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15135 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15137 u32
*digest
= (u32
*) hash_buf
->digest
;
15139 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15141 salt_t
*salt
= hash_buf
->salt
;
15143 char *salt_buf
= input_buf
+ 6;
15145 char *digest_buf
= strchr (salt_buf
, '$');
15147 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15149 uint salt_len
= digest_buf
- salt_buf
;
15151 digest_buf
++; // skip the '$' symbol
15153 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15155 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15157 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15159 salt
->salt_len
= salt_len
;
15161 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15162 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15163 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15164 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15166 digest
[0] = byte_swap_32 (digest
[0]);
15167 digest
[1] = byte_swap_32 (digest
[1]);
15168 digest
[2] = byte_swap_32 (digest
[2]);
15169 digest
[3] = byte_swap_32 (digest
[3]);
15171 digest
[0] -= MD5M_A
;
15172 digest
[1] -= MD5M_B
;
15173 digest
[2] -= MD5M_C
;
15174 digest
[3] -= MD5M_D
;
15176 return (PARSER_OK
);
15179 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15181 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15183 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15185 u32
*digest
= (u32
*) hash_buf
->digest
;
15187 salt_t
*salt
= hash_buf
->salt
;
15189 char *salt_buf
= input_buf
+ 3;
15191 char *digest_buf
= strchr (salt_buf
, '$');
15193 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15195 uint salt_len
= digest_buf
- salt_buf
;
15197 digest_buf
++; // skip the '$' symbol
15199 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15201 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15203 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15205 salt_buf_ptr
[salt_len
] = 0x2d;
15207 salt
->salt_len
= salt_len
+ 1;
15209 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15210 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15211 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15212 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15214 digest
[0] = byte_swap_32 (digest
[0]);
15215 digest
[1] = byte_swap_32 (digest
[1]);
15216 digest
[2] = byte_swap_32 (digest
[2]);
15217 digest
[3] = byte_swap_32 (digest
[3]);
15219 digest
[0] -= MD5M_A
;
15220 digest
[1] -= MD5M_B
;
15221 digest
[2] -= MD5M_C
;
15222 digest
[3] -= MD5M_D
;
15224 return (PARSER_OK
);
15227 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15229 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15231 u32
*digest
= (u32
*) hash_buf
->digest
;
15233 salt_t
*salt
= hash_buf
->salt
;
15235 u8 tmp_buf
[100] = { 0 };
15237 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15239 memcpy (digest
, tmp_buf
, 20);
15241 digest
[0] = byte_swap_32 (digest
[0]);
15242 digest
[1] = byte_swap_32 (digest
[1]);
15243 digest
[2] = byte_swap_32 (digest
[2]);
15244 digest
[3] = byte_swap_32 (digest
[3]);
15245 digest
[4] = byte_swap_32 (digest
[4]);
15247 digest
[0] -= SHA1M_A
;
15248 digest
[1] -= SHA1M_B
;
15249 digest
[2] -= SHA1M_C
;
15250 digest
[3] -= SHA1M_D
;
15251 digest
[4] -= SHA1M_E
;
15253 salt
->salt_buf
[0] = 0x80;
15255 salt
->salt_len
= 0;
15257 return (PARSER_OK
);
15260 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15262 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15264 u32
*digest
= (u32
*) hash_buf
->digest
;
15266 salt_t
*salt
= hash_buf
->salt
;
15268 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15269 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15270 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15271 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15273 digest
[0] = byte_swap_32 (digest
[0]);
15274 digest
[1] = byte_swap_32 (digest
[1]);
15275 digest
[2] = byte_swap_32 (digest
[2]);
15276 digest
[3] = byte_swap_32 (digest
[3]);
15278 digest
[0] -= MD5M_A
;
15279 digest
[1] -= MD5M_B
;
15280 digest
[2] -= MD5M_C
;
15281 digest
[3] -= MD5M_D
;
15283 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15285 uint salt_len
= input_len
- 32 - 1;
15287 char *salt_buf
= input_buf
+ 32 + 1;
15289 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15291 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15293 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15296 * add static "salt" part
15299 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15303 salt
->salt_len
= salt_len
;
15305 return (PARSER_OK
);
15308 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15310 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15312 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15314 u32
*digest
= (u32
*) hash_buf
->digest
;
15316 salt_t
*salt
= hash_buf
->salt
;
15318 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15324 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15326 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15328 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15330 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15332 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15336 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15338 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15340 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15342 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15346 char *keybuf_pos
= strchr (keylen_pos
, '$');
15348 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15350 uint keylen_len
= keybuf_pos
- keylen_pos
;
15352 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15356 char *databuf_pos
= strchr (keybuf_pos
, '$');
15358 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15360 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15362 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15366 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15368 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15374 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15375 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15376 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15377 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15379 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15380 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15381 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15382 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15384 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15385 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15386 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15387 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15389 salt
->salt_len
= 16;
15390 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15392 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15394 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15397 return (PARSER_OK
);
15400 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15402 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15404 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15406 u32
*digest
= (u32
*) hash_buf
->digest
;
15408 salt_t
*salt
= hash_buf
->salt
;
15414 // first is the N salt parameter
15416 char *N_pos
= input_buf
+ 6;
15418 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15422 salt
->scrypt_N
= atoi (N_pos
);
15426 char *r_pos
= strchr (N_pos
, ':');
15428 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15432 salt
->scrypt_r
= atoi (r_pos
);
15436 char *p_pos
= strchr (r_pos
, ':');
15438 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15442 salt
->scrypt_p
= atoi (p_pos
);
15446 char *saltbuf_pos
= strchr (p_pos
, ':');
15448 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15452 char *hash_pos
= strchr (saltbuf_pos
, ':');
15454 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15460 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15462 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15464 u8 tmp_buf
[33] = { 0 };
15466 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15468 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15470 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15472 salt
->salt_len
= tmp_len
;
15473 salt
->salt_iter
= 1;
15475 // digest - base64 decode
15477 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15479 tmp_len
= input_len
- (hash_pos
- input_buf
);
15481 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15483 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15485 memcpy (digest
, tmp_buf
, 32);
15487 return (PARSER_OK
);
15490 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15492 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15494 u32
*digest
= (u32
*) hash_buf
->digest
;
15496 salt_t
*salt
= hash_buf
->salt
;
15502 char decrypted
[76] = { 0 }; // iv + hash
15504 juniper_decrypt_hash (input_buf
, decrypted
);
15506 char *md5crypt_hash
= decrypted
+ 12;
15508 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15510 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15512 char *salt_pos
= md5crypt_hash
+ 3;
15514 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15516 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15518 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15522 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15524 return (PARSER_OK
);
15527 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15529 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15531 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15533 u32
*digest
= (u32
*) hash_buf
->digest
;
15535 salt_t
*salt
= hash_buf
->salt
;
15537 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15543 // first is *raw* salt
15545 char *salt_pos
= input_buf
+ 3;
15547 char *hash_pos
= strchr (salt_pos
, '$');
15549 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15551 uint salt_len
= hash_pos
- salt_pos
;
15553 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15557 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15559 memcpy (salt_buf_ptr
, salt_pos
, 14);
15561 salt_buf_ptr
[17] = 0x01;
15562 salt_buf_ptr
[18] = 0x80;
15564 // add some stuff to normal salt to make sorted happy
15566 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15567 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15568 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15569 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15571 salt
->salt_len
= salt_len
;
15572 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15574 // base64 decode hash
15576 u8 tmp_buf
[100] = { 0 };
15578 uint hash_len
= input_len
- 3 - salt_len
- 1;
15580 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15582 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15584 memcpy (digest
, tmp_buf
, 32);
15586 digest
[0] = byte_swap_32 (digest
[0]);
15587 digest
[1] = byte_swap_32 (digest
[1]);
15588 digest
[2] = byte_swap_32 (digest
[2]);
15589 digest
[3] = byte_swap_32 (digest
[3]);
15590 digest
[4] = byte_swap_32 (digest
[4]);
15591 digest
[5] = byte_swap_32 (digest
[5]);
15592 digest
[6] = byte_swap_32 (digest
[6]);
15593 digest
[7] = byte_swap_32 (digest
[7]);
15595 return (PARSER_OK
);
15598 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15600 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15602 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15604 u32
*digest
= (u32
*) hash_buf
->digest
;
15606 salt_t
*salt
= hash_buf
->salt
;
15612 // first is *raw* salt
15614 char *salt_pos
= input_buf
+ 3;
15616 char *hash_pos
= strchr (salt_pos
, '$');
15618 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15620 uint salt_len
= hash_pos
- salt_pos
;
15622 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15624 salt
->salt_len
= salt_len
;
15627 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15629 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15630 salt_buf_ptr
[salt_len
] = 0;
15632 // base64 decode hash
15634 u8 tmp_buf
[100] = { 0 };
15636 uint hash_len
= input_len
- 3 - salt_len
- 1;
15638 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15640 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15642 memcpy (digest
, tmp_buf
, 32);
15645 salt
->scrypt_N
= 16384;
15646 salt
->scrypt_r
= 1;
15647 salt
->scrypt_p
= 1;
15648 salt
->salt_iter
= 1;
15650 return (PARSER_OK
);
15653 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15655 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15657 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15659 u32
*digest
= (u32
*) hash_buf
->digest
;
15661 salt_t
*salt
= hash_buf
->salt
;
15663 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15669 char *version_pos
= input_buf
+ 8 + 1;
15671 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15673 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15675 u32 version_len
= verifierHashSize_pos
- version_pos
;
15677 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15679 verifierHashSize_pos
++;
15681 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15683 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15685 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15687 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15691 char *saltSize_pos
= strchr (keySize_pos
, '*');
15693 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15695 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15697 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15701 char *osalt_pos
= strchr (saltSize_pos
, '*');
15703 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15705 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15707 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15711 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15713 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15715 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15717 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15719 encryptedVerifier_pos
++;
15721 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15723 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15725 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15727 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15729 encryptedVerifierHash_pos
++;
15731 u32 encryptedVerifierHash_len
= input_len
- 8 - 1 - version_len
- 1 - verifierHashSize_len
- 1 - keySize_len
- 1 - saltSize_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15733 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15735 const uint version
= atoi (version_pos
);
15737 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15739 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15741 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15743 const uint keySize
= atoi (keySize_pos
);
15745 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15747 office2007
->keySize
= keySize
;
15749 const uint saltSize
= atoi (saltSize_pos
);
15751 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15757 salt
->salt_len
= 16;
15758 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15760 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15761 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15762 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15763 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15769 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15770 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15771 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15772 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15774 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15775 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15776 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15777 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15778 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15784 digest
[0] = office2007
->encryptedVerifierHash
[0];
15785 digest
[1] = office2007
->encryptedVerifierHash
[1];
15786 digest
[2] = office2007
->encryptedVerifierHash
[2];
15787 digest
[3] = office2007
->encryptedVerifierHash
[3];
15789 return (PARSER_OK
);
15792 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15794 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15796 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15798 u32
*digest
= (u32
*) hash_buf
->digest
;
15800 salt_t
*salt
= hash_buf
->salt
;
15802 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15808 char *version_pos
= input_buf
+ 8 + 1;
15810 char *spinCount_pos
= strchr (version_pos
, '*');
15812 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15814 u32 version_len
= spinCount_pos
- version_pos
;
15816 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15820 char *keySize_pos
= strchr (spinCount_pos
, '*');
15822 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15824 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15826 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15830 char *saltSize_pos
= strchr (keySize_pos
, '*');
15832 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15834 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15836 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15840 char *osalt_pos
= strchr (saltSize_pos
, '*');
15842 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15844 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15846 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15850 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15852 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15854 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15856 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15858 encryptedVerifier_pos
++;
15860 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15862 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15864 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15866 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15868 encryptedVerifierHash_pos
++;
15870 u32 encryptedVerifierHash_len
= input_len
- 8 - 1 - version_len
- 1 - spinCount_len
- 1 - keySize_len
- 1 - saltSize_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15872 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15874 const uint version
= atoi (version_pos
);
15876 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15878 const uint spinCount
= atoi (spinCount_pos
);
15880 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15882 const uint keySize
= atoi (keySize_pos
);
15884 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15886 const uint saltSize
= atoi (saltSize_pos
);
15888 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15894 salt
->salt_len
= 16;
15895 salt
->salt_iter
= spinCount
;
15897 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15898 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15899 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15900 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15906 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15907 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15908 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15909 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15911 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15912 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15913 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15914 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15915 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15916 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15917 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15918 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15924 digest
[0] = office2010
->encryptedVerifierHash
[0];
15925 digest
[1] = office2010
->encryptedVerifierHash
[1];
15926 digest
[2] = office2010
->encryptedVerifierHash
[2];
15927 digest
[3] = office2010
->encryptedVerifierHash
[3];
15929 return (PARSER_OK
);
15932 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15934 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15936 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15938 u32
*digest
= (u32
*) hash_buf
->digest
;
15940 salt_t
*salt
= hash_buf
->salt
;
15942 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15948 char *version_pos
= input_buf
+ 8 + 1;
15950 char *spinCount_pos
= strchr (version_pos
, '*');
15952 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15954 u32 version_len
= spinCount_pos
- version_pos
;
15956 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15960 char *keySize_pos
= strchr (spinCount_pos
, '*');
15962 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15964 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15966 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15970 char *saltSize_pos
= strchr (keySize_pos
, '*');
15972 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15974 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15976 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15980 char *osalt_pos
= strchr (saltSize_pos
, '*');
15982 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15984 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15986 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15990 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15992 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15994 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15996 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15998 encryptedVerifier_pos
++;
16000 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16002 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16004 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16006 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16008 encryptedVerifierHash_pos
++;
16010 u32 encryptedVerifierHash_len
= input_len
- 8 - 1 - version_len
- 1 - spinCount_len
- 1 - keySize_len
- 1 - saltSize_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16012 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
16014 const uint version
= atoi (version_pos
);
16016 if (version
!= 2013) return (PARSER_SALT_VALUE
);
16018 const uint spinCount
= atoi (spinCount_pos
);
16020 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
16022 const uint keySize
= atoi (keySize_pos
);
16024 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
16026 const uint saltSize
= atoi (saltSize_pos
);
16028 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
16034 salt
->salt_len
= 16;
16035 salt
->salt_iter
= spinCount
;
16037 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16038 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16039 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16040 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16046 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16047 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16048 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16049 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16051 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16052 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16053 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16054 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16055 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16056 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16057 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16058 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16064 digest
[0] = office2013
->encryptedVerifierHash
[0];
16065 digest
[1] = office2013
->encryptedVerifierHash
[1];
16066 digest
[2] = office2013
->encryptedVerifierHash
[2];
16067 digest
[3] = office2013
->encryptedVerifierHash
[3];
16069 return (PARSER_OK
);
16072 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16074 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16076 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16078 u32
*digest
= (u32
*) hash_buf
->digest
;
16080 salt_t
*salt
= hash_buf
->salt
;
16082 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16088 char *version_pos
= input_buf
+ 11;
16090 char *osalt_pos
= strchr (version_pos
, '*');
16092 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16094 u32 version_len
= osalt_pos
- version_pos
;
16096 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16100 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16102 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16104 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16106 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16108 encryptedVerifier_pos
++;
16110 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16112 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16114 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16116 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16118 encryptedVerifierHash_pos
++;
16120 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16122 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16124 const uint version
= *version_pos
- 0x30;
16126 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16132 oldoffice01
->version
= version
;
16134 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16135 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16136 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16137 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16139 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16140 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16141 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16142 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16144 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16145 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16146 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16147 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16149 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16150 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16151 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16152 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16158 salt
->salt_len
= 16;
16160 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16161 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16162 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16163 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16165 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16166 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16167 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16168 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16170 // this is a workaround as office produces multiple documents with the same salt
16172 salt
->salt_len
+= 32;
16174 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16175 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16176 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16177 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16178 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16179 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16180 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16181 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16187 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16188 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16189 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16190 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16192 return (PARSER_OK
);
16195 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16197 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16200 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16202 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16204 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16206 u32
*digest
= (u32
*) hash_buf
->digest
;
16208 salt_t
*salt
= hash_buf
->salt
;
16210 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16216 char *version_pos
= input_buf
+ 11;
16218 char *osalt_pos
= strchr (version_pos
, '*');
16220 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16222 u32 version_len
= osalt_pos
- version_pos
;
16224 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16228 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16230 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16232 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16234 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16236 encryptedVerifier_pos
++;
16238 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16240 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16242 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16244 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16246 encryptedVerifierHash_pos
++;
16248 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16250 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16252 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16254 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16258 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16260 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16262 const uint version
= *version_pos
- 0x30;
16264 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16270 oldoffice01
->version
= version
;
16272 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16273 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16274 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16275 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16277 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16278 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16279 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16280 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16282 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16283 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16284 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16285 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16287 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16288 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16289 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16290 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16292 oldoffice01
->rc4key
[1] = 0;
16293 oldoffice01
->rc4key
[0] = 0;
16295 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16296 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16297 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16298 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16299 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16300 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16301 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16302 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16303 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16304 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16306 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16307 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16313 salt
->salt_len
= 16;
16315 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16316 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16317 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16318 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16320 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16321 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16322 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16323 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16325 // this is a workaround as office produces multiple documents with the same salt
16327 salt
->salt_len
+= 32;
16329 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16330 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16331 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16332 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16333 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16334 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16335 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16336 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16342 digest
[0] = oldoffice01
->rc4key
[0];
16343 digest
[1] = oldoffice01
->rc4key
[1];
16347 return (PARSER_OK
);
16350 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16352 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16354 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16356 u32
*digest
= (u32
*) hash_buf
->digest
;
16358 salt_t
*salt
= hash_buf
->salt
;
16360 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16366 char *version_pos
= input_buf
+ 11;
16368 char *osalt_pos
= strchr (version_pos
, '*');
16370 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16372 u32 version_len
= osalt_pos
- version_pos
;
16374 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16378 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16380 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16382 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16384 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16386 encryptedVerifier_pos
++;
16388 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16390 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16392 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16394 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16396 encryptedVerifierHash_pos
++;
16398 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16400 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16402 const uint version
= *version_pos
- 0x30;
16404 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16410 oldoffice34
->version
= version
;
16412 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16413 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16414 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16415 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16417 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16418 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16419 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16420 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16422 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16423 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16424 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16425 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16426 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16428 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16429 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16430 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16431 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16432 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16438 salt
->salt_len
= 16;
16440 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16441 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16442 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16443 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16445 // this is a workaround as office produces multiple documents with the same salt
16447 salt
->salt_len
+= 32;
16449 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16450 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16451 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16452 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16453 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16454 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16455 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16456 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16462 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16463 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16464 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16465 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16467 return (PARSER_OK
);
16470 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16472 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16474 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16477 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16479 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16481 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16483 u32
*digest
= (u32
*) hash_buf
->digest
;
16485 salt_t
*salt
= hash_buf
->salt
;
16487 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16493 char *version_pos
= input_buf
+ 11;
16495 char *osalt_pos
= strchr (version_pos
, '*');
16497 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16499 u32 version_len
= osalt_pos
- version_pos
;
16501 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16505 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16507 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16509 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16511 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16513 encryptedVerifier_pos
++;
16515 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16517 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16519 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16521 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16523 encryptedVerifierHash_pos
++;
16525 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16527 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16529 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16531 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16535 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16537 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16539 const uint version
= *version_pos
- 0x30;
16541 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16547 oldoffice34
->version
= version
;
16549 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16550 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16551 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16552 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16554 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16555 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16556 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16557 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16559 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16560 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16561 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16562 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16563 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16565 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16566 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16567 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16568 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16569 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16571 oldoffice34
->rc4key
[1] = 0;
16572 oldoffice34
->rc4key
[0] = 0;
16574 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16575 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16576 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16577 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16578 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16579 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16580 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16581 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16582 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16583 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16585 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16586 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16592 salt
->salt_len
= 16;
16594 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16595 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16596 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16597 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16599 // this is a workaround as office produces multiple documents with the same salt
16601 salt
->salt_len
+= 32;
16603 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16604 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16605 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16606 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16607 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16608 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16609 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16610 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16616 digest
[0] = oldoffice34
->rc4key
[0];
16617 digest
[1] = oldoffice34
->rc4key
[1];
16621 return (PARSER_OK
);
16624 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16626 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16628 u32
*digest
= (u32
*) hash_buf
->digest
;
16630 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16631 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16632 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16633 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16635 digest
[0] = byte_swap_32 (digest
[0]);
16636 digest
[1] = byte_swap_32 (digest
[1]);
16637 digest
[2] = byte_swap_32 (digest
[2]);
16638 digest
[3] = byte_swap_32 (digest
[3]);
16640 return (PARSER_OK
);
16643 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16645 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16647 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16649 u32
*digest
= (u32
*) hash_buf
->digest
;
16651 salt_t
*salt
= hash_buf
->salt
;
16653 char *signature_pos
= input_buf
;
16655 char *salt_pos
= strchr (signature_pos
, '$');
16657 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16659 u32 signature_len
= salt_pos
- signature_pos
;
16661 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16665 char *hash_pos
= strchr (salt_pos
, '$');
16667 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16669 u32 salt_len
= hash_pos
- salt_pos
;
16671 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16675 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16677 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16679 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16680 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16681 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16682 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16683 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16685 digest
[0] -= SHA1M_A
;
16686 digest
[1] -= SHA1M_B
;
16687 digest
[2] -= SHA1M_C
;
16688 digest
[3] -= SHA1M_D
;
16689 digest
[4] -= SHA1M_E
;
16691 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16693 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16695 salt
->salt_len
= salt_len
;
16697 return (PARSER_OK
);
16700 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16702 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16704 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16706 u32
*digest
= (u32
*) hash_buf
->digest
;
16708 salt_t
*salt
= hash_buf
->salt
;
16710 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16716 char *iter_pos
= input_buf
+ 14;
16718 const int iter
= atoi (iter_pos
);
16720 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16722 salt
->salt_iter
= iter
- 1;
16724 char *salt_pos
= strchr (iter_pos
, '$');
16726 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16730 char *hash_pos
= strchr (salt_pos
, '$');
16732 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16734 const uint salt_len
= hash_pos
- salt_pos
;
16738 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16740 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16742 salt
->salt_len
= salt_len
;
16744 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16745 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16747 // add some stuff to normal salt to make sorted happy
16749 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16750 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16751 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16752 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16753 salt
->salt_buf
[4] = salt
->salt_iter
;
16755 // base64 decode hash
16757 u8 tmp_buf
[100] = { 0 };
16759 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16761 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16763 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16765 memcpy (digest
, tmp_buf
, 32);
16767 digest
[0] = byte_swap_32 (digest
[0]);
16768 digest
[1] = byte_swap_32 (digest
[1]);
16769 digest
[2] = byte_swap_32 (digest
[2]);
16770 digest
[3] = byte_swap_32 (digest
[3]);
16771 digest
[4] = byte_swap_32 (digest
[4]);
16772 digest
[5] = byte_swap_32 (digest
[5]);
16773 digest
[6] = byte_swap_32 (digest
[6]);
16774 digest
[7] = byte_swap_32 (digest
[7]);
16776 return (PARSER_OK
);
16779 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16781 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16783 u32
*digest
= (u32
*) hash_buf
->digest
;
16785 salt_t
*salt
= hash_buf
->salt
;
16787 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16788 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16792 digest
[0] = byte_swap_32 (digest
[0]);
16793 digest
[1] = byte_swap_32 (digest
[1]);
16795 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16796 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16797 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16799 char iter_c
= input_buf
[17];
16800 char iter_d
= input_buf
[19];
16802 // atm only defaults, let's see if there's more request
16803 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16804 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16806 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16808 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16809 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16810 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16811 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16813 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16814 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16815 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16816 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16818 salt
->salt_len
= 16;
16820 return (PARSER_OK
);
16823 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16825 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16827 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16829 u32
*digest
= (u32
*) hash_buf
->digest
;
16831 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16833 salt_t
*salt
= hash_buf
->salt
;
16835 char *salt_pos
= input_buf
+ 10;
16837 char *hash_pos
= strchr (salt_pos
, '$');
16839 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16841 uint salt_len
= hash_pos
- salt_pos
;
16845 uint hash_len
= input_len
- 10 - salt_len
- 1;
16847 // base64 decode salt
16849 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16851 u8 tmp_buf
[100] = { 0 };
16853 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16855 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16857 tmp_buf
[salt_len
] = 0x80;
16859 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16861 salt
->salt_len
= salt_len
;
16863 // base64 decode hash
16865 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16867 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16869 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16871 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16873 uint user_len
= hash_len
- 32;
16875 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16877 user_len
--; // skip the trailing space
16879 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16880 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16881 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16882 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16884 digest
[0] = byte_swap_32 (digest
[0]);
16885 digest
[1] = byte_swap_32 (digest
[1]);
16886 digest
[2] = byte_swap_32 (digest
[2]);
16887 digest
[3] = byte_swap_32 (digest
[3]);
16889 // store username for host only (output hash if cracked)
16891 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16892 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16894 return (PARSER_OK
);
16897 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16899 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16901 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16903 u32
*digest
= (u32
*) hash_buf
->digest
;
16905 salt_t
*salt
= hash_buf
->salt
;
16907 char *iter_pos
= input_buf
+ 10;
16909 u32 iter
= atoi (iter_pos
);
16913 return (PARSER_SALT_ITERATION
);
16916 iter
--; // first iteration is special
16918 salt
->salt_iter
= iter
;
16920 char *base64_pos
= strchr (iter_pos
, '}');
16922 if (base64_pos
== NULL
)
16924 return (PARSER_SIGNATURE_UNMATCHED
);
16929 // base64 decode salt
16931 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16933 u8 tmp_buf
[100] = { 0 };
16935 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16937 if (decoded_len
< 24)
16939 return (PARSER_SALT_LENGTH
);
16944 uint salt_len
= decoded_len
- 20;
16946 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16947 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16949 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16951 salt
->salt_len
= salt_len
;
16955 u32
*digest_ptr
= (u32
*) tmp_buf
;
16957 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16958 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16959 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16960 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16961 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16963 return (PARSER_OK
);
16966 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16968 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16970 u32
*digest
= (u32
*) hash_buf
->digest
;
16972 salt_t
*salt
= hash_buf
->salt
;
16974 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16975 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16976 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16977 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16978 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16980 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16982 uint salt_len
= input_len
- 40 - 1;
16984 char *salt_buf
= input_buf
+ 40 + 1;
16986 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16988 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16990 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16992 salt
->salt_len
= salt_len
;
16994 return (PARSER_OK
);
16997 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16999 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
17001 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17003 u32
*digest
= (u32
*) hash_buf
->digest
;
17005 salt_t
*salt
= hash_buf
->salt
;
17007 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17013 char *V_pos
= input_buf
+ 5;
17015 char *R_pos
= strchr (V_pos
, '*');
17017 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17019 u32 V_len
= R_pos
- V_pos
;
17023 char *bits_pos
= strchr (R_pos
, '*');
17025 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17027 u32 R_len
= bits_pos
- R_pos
;
17031 char *P_pos
= strchr (bits_pos
, '*');
17033 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17035 u32 bits_len
= P_pos
- bits_pos
;
17039 char *enc_md_pos
= strchr (P_pos
, '*');
17041 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17043 u32 P_len
= enc_md_pos
- P_pos
;
17047 char *id_len_pos
= strchr (enc_md_pos
, '*');
17049 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17051 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17055 char *id_buf_pos
= strchr (id_len_pos
, '*');
17057 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17059 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17063 char *u_len_pos
= strchr (id_buf_pos
, '*');
17065 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17067 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17069 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17073 char *u_buf_pos
= strchr (u_len_pos
, '*');
17075 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17077 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17081 char *o_len_pos
= strchr (u_buf_pos
, '*');
17083 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17085 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17087 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17091 char *o_buf_pos
= strchr (o_len_pos
, '*');
17093 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17095 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17099 u32 o_buf_len
= input_len
- 5 - V_len
- 1 - R_len
- 1 - bits_len
- 1 - P_len
- 1 - enc_md_len
- 1 - id_len_len
- 1 - id_buf_len
- 1 - u_len_len
- 1 - u_buf_len
- 1 - o_len_len
- 1;
17101 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17105 const int V
= atoi (V_pos
);
17106 const int R
= atoi (R_pos
);
17107 const int P
= atoi (P_pos
);
17109 if (V
!= 1) return (PARSER_SALT_VALUE
);
17110 if (R
!= 2) return (PARSER_SALT_VALUE
);
17112 const int enc_md
= atoi (enc_md_pos
);
17114 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17116 const int id_len
= atoi (id_len_pos
);
17117 const int u_len
= atoi (u_len_pos
);
17118 const int o_len
= atoi (o_len_pos
);
17120 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17121 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17122 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17124 const int bits
= atoi (bits_pos
);
17126 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17128 // copy data to esalt
17134 pdf
->enc_md
= enc_md
;
17136 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17137 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17138 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17139 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17140 pdf
->id_len
= id_len
;
17142 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17143 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17144 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17145 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17146 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17147 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17148 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17149 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17150 pdf
->u_len
= u_len
;
17152 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17153 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17154 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17155 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17156 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17157 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17158 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17159 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17160 pdf
->o_len
= o_len
;
17162 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17163 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17164 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17165 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17167 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17168 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17169 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17170 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17171 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17172 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17173 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17174 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17176 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17177 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17178 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17179 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17180 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17181 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17182 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17183 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17185 // we use ID for salt, maybe needs to change, we will see...
17187 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17188 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17189 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17190 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17191 salt
->salt_len
= pdf
->id_len
;
17193 digest
[0] = pdf
->u_buf
[0];
17194 digest
[1] = pdf
->u_buf
[1];
17195 digest
[2] = pdf
->u_buf
[2];
17196 digest
[3] = pdf
->u_buf
[3];
17198 return (PARSER_OK
);
17201 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17203 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17206 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17208 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17210 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17212 u32
*digest
= (u32
*) hash_buf
->digest
;
17214 salt_t
*salt
= hash_buf
->salt
;
17216 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17222 char *V_pos
= input_buf
+ 5;
17224 char *R_pos
= strchr (V_pos
, '*');
17226 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17228 u32 V_len
= R_pos
- V_pos
;
17232 char *bits_pos
= strchr (R_pos
, '*');
17234 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17236 u32 R_len
= bits_pos
- R_pos
;
17240 char *P_pos
= strchr (bits_pos
, '*');
17242 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17244 u32 bits_len
= P_pos
- bits_pos
;
17248 char *enc_md_pos
= strchr (P_pos
, '*');
17250 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17252 u32 P_len
= enc_md_pos
- P_pos
;
17256 char *id_len_pos
= strchr (enc_md_pos
, '*');
17258 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17260 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17264 char *id_buf_pos
= strchr (id_len_pos
, '*');
17266 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17268 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17272 char *u_len_pos
= strchr (id_buf_pos
, '*');
17274 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17276 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17278 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17282 char *u_buf_pos
= strchr (u_len_pos
, '*');
17284 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17286 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17290 char *o_len_pos
= strchr (u_buf_pos
, '*');
17292 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17294 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17296 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17300 char *o_buf_pos
= strchr (o_len_pos
, '*');
17302 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17304 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17308 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17310 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17312 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17314 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17318 u32 rc4key_len
= input_len
- 5 - V_len
- 1 - R_len
- 1 - bits_len
- 1 - P_len
- 1 - enc_md_len
- 1 - id_len_len
- 1 - id_buf_len
- 1 - u_len_len
- 1 - u_buf_len
- 1 - o_len_len
- 1 - o_buf_len
- 1;
17320 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17324 const int V
= atoi (V_pos
);
17325 const int R
= atoi (R_pos
);
17326 const int P
= atoi (P_pos
);
17328 if (V
!= 1) return (PARSER_SALT_VALUE
);
17329 if (R
!= 2) return (PARSER_SALT_VALUE
);
17331 const int enc_md
= atoi (enc_md_pos
);
17333 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17335 const int id_len
= atoi (id_len_pos
);
17336 const int u_len
= atoi (u_len_pos
);
17337 const int o_len
= atoi (o_len_pos
);
17339 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17340 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17341 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17343 const int bits
= atoi (bits_pos
);
17345 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17347 // copy data to esalt
17353 pdf
->enc_md
= enc_md
;
17355 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17356 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17357 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17358 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17359 pdf
->id_len
= id_len
;
17361 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17362 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17363 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17364 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17365 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17366 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17367 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17368 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17369 pdf
->u_len
= u_len
;
17371 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17372 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17373 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17374 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17375 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17376 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17377 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17378 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17379 pdf
->o_len
= o_len
;
17381 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17382 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17383 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17384 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17386 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17387 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17388 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17389 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17390 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17391 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17392 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17393 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17395 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17396 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17397 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17398 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17399 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17400 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17401 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17402 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17404 pdf
->rc4key
[1] = 0;
17405 pdf
->rc4key
[0] = 0;
17407 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17408 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17409 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17410 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17411 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17412 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17413 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17414 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17415 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17416 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17418 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17419 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17421 // we use ID for salt, maybe needs to change, we will see...
17423 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17424 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17425 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17426 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17427 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17428 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17429 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17430 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17431 salt
->salt_len
= pdf
->id_len
+ 16;
17433 digest
[0] = pdf
->rc4key
[0];
17434 digest
[1] = pdf
->rc4key
[1];
17438 return (PARSER_OK
);
17441 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17443 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17445 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17447 u32
*digest
= (u32
*) hash_buf
->digest
;
17449 salt_t
*salt
= hash_buf
->salt
;
17451 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17457 char *V_pos
= input_buf
+ 5;
17459 char *R_pos
= strchr (V_pos
, '*');
17461 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17463 u32 V_len
= R_pos
- V_pos
;
17467 char *bits_pos
= strchr (R_pos
, '*');
17469 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17471 u32 R_len
= bits_pos
- R_pos
;
17475 char *P_pos
= strchr (bits_pos
, '*');
17477 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17479 u32 bits_len
= P_pos
- bits_pos
;
17483 char *enc_md_pos
= strchr (P_pos
, '*');
17485 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17487 u32 P_len
= enc_md_pos
- P_pos
;
17491 char *id_len_pos
= strchr (enc_md_pos
, '*');
17493 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17495 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17499 char *id_buf_pos
= strchr (id_len_pos
, '*');
17501 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17503 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17507 char *u_len_pos
= strchr (id_buf_pos
, '*');
17509 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17511 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17513 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17517 char *u_buf_pos
= strchr (u_len_pos
, '*');
17519 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17521 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17525 char *o_len_pos
= strchr (u_buf_pos
, '*');
17527 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17529 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17531 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17535 char *o_buf_pos
= strchr (o_len_pos
, '*');
17537 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17539 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17543 u32 o_buf_len
= input_len
- 5 - V_len
- 1 - R_len
- 1 - bits_len
- 1 - P_len
- 1 - enc_md_len
- 1 - id_len_len
- 1 - id_buf_len
- 1 - u_len_len
- 1 - u_buf_len
- 1 - o_len_len
- 1;
17545 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17549 const int V
= atoi (V_pos
);
17550 const int R
= atoi (R_pos
);
17551 const int P
= atoi (P_pos
);
17555 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17556 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17558 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17560 const int id_len
= atoi (id_len_pos
);
17561 const int u_len
= atoi (u_len_pos
);
17562 const int o_len
= atoi (o_len_pos
);
17564 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17566 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17567 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17569 const int bits
= atoi (bits_pos
);
17571 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17577 enc_md
= atoi (enc_md_pos
);
17580 // copy data to esalt
17586 pdf
->enc_md
= enc_md
;
17588 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17589 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17590 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17591 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17595 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17596 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17597 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17598 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17601 pdf
->id_len
= id_len
;
17603 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17604 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17605 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17606 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17607 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17608 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17609 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17610 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17611 pdf
->u_len
= u_len
;
17613 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17614 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17615 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17616 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17617 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17618 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17619 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17620 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17621 pdf
->o_len
= o_len
;
17623 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17624 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17625 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17626 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17630 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17631 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17632 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17633 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17636 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17637 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17638 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17639 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17640 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17641 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17642 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17643 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17645 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17646 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17647 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17648 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17649 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17650 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17651 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17652 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17654 // precompute rc4 data for later use
17670 uint salt_pc_block
[32] = { 0 };
17672 char *salt_pc_ptr
= (char *) salt_pc_block
;
17674 memcpy (salt_pc_ptr
, padding
, 32);
17675 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17677 uint salt_pc_digest
[4] = { 0 };
17679 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17681 pdf
->rc4data
[0] = salt_pc_digest
[0];
17682 pdf
->rc4data
[1] = salt_pc_digest
[1];
17684 // we use ID for salt, maybe needs to change, we will see...
17686 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17687 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17688 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17689 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17690 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17691 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17692 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17693 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17694 salt
->salt_len
= pdf
->id_len
+ 16;
17696 salt
->salt_iter
= ROUNDS_PDF14
;
17698 digest
[0] = pdf
->u_buf
[0];
17699 digest
[1] = pdf
->u_buf
[1];
17703 return (PARSER_OK
);
17706 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17708 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17710 if (ret
!= PARSER_OK
)
17715 u32
*digest
= (u32
*) hash_buf
->digest
;
17717 salt_t
*salt
= hash_buf
->salt
;
17719 digest
[0] -= SHA256M_A
;
17720 digest
[1] -= SHA256M_B
;
17721 digest
[2] -= SHA256M_C
;
17722 digest
[3] -= SHA256M_D
;
17723 digest
[4] -= SHA256M_E
;
17724 digest
[5] -= SHA256M_F
;
17725 digest
[6] -= SHA256M_G
;
17726 digest
[7] -= SHA256M_H
;
17728 salt
->salt_buf
[2] = 0x80;
17730 return (PARSER_OK
);
17733 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17735 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17737 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17739 u32
*digest
= (u32
*) hash_buf
->digest
;
17741 salt_t
*salt
= hash_buf
->salt
;
17743 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17749 char *V_pos
= input_buf
+ 5;
17751 char *R_pos
= strchr (V_pos
, '*');
17753 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17755 u32 V_len
= R_pos
- V_pos
;
17759 char *bits_pos
= strchr (R_pos
, '*');
17761 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17763 u32 R_len
= bits_pos
- R_pos
;
17767 char *P_pos
= strchr (bits_pos
, '*');
17769 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17771 u32 bits_len
= P_pos
- bits_pos
;
17775 char *enc_md_pos
= strchr (P_pos
, '*');
17777 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17779 u32 P_len
= enc_md_pos
- P_pos
;
17783 char *id_len_pos
= strchr (enc_md_pos
, '*');
17785 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17787 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17791 char *id_buf_pos
= strchr (id_len_pos
, '*');
17793 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17795 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17799 char *u_len_pos
= strchr (id_buf_pos
, '*');
17801 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17803 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17807 char *u_buf_pos
= strchr (u_len_pos
, '*');
17809 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17811 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17815 char *o_len_pos
= strchr (u_buf_pos
, '*');
17817 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17819 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17823 char *o_buf_pos
= strchr (o_len_pos
, '*');
17825 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17827 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17831 char *last
= strchr (o_buf_pos
, '*');
17833 if (last
== NULL
) last
= input_buf
+ input_len
;
17835 u32 o_buf_len
= last
- o_buf_pos
;
17839 const int V
= atoi (V_pos
);
17840 const int R
= atoi (R_pos
);
17844 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17845 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17847 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17849 const int bits
= atoi (bits_pos
);
17851 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17853 int enc_md
= atoi (enc_md_pos
);
17855 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17857 const uint id_len
= atoi (id_len_pos
);
17858 const uint u_len
= atoi (u_len_pos
);
17859 const uint o_len
= atoi (o_len_pos
);
17861 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17862 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17863 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17864 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17865 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17866 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17867 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17868 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17870 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17871 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17872 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17874 // copy data to esalt
17876 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17878 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17880 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17883 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17884 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17886 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17887 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17889 salt
->salt_len
= 8;
17890 salt
->salt_iter
= ROUNDS_PDF17L8
;
17892 digest
[0] = pdf
->u_buf
[0];
17893 digest
[1] = pdf
->u_buf
[1];
17894 digest
[2] = pdf
->u_buf
[2];
17895 digest
[3] = pdf
->u_buf
[3];
17896 digest
[4] = pdf
->u_buf
[4];
17897 digest
[5] = pdf
->u_buf
[5];
17898 digest
[6] = pdf
->u_buf
[6];
17899 digest
[7] = pdf
->u_buf
[7];
17901 return (PARSER_OK
);
17904 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17906 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17908 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17910 u32
*digest
= (u32
*) hash_buf
->digest
;
17912 salt_t
*salt
= hash_buf
->salt
;
17914 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17922 char *iter_pos
= input_buf
+ 7;
17924 u32 iter
= atoi (iter_pos
);
17926 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17927 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17929 // first is *raw* salt
17931 char *salt_pos
= strchr (iter_pos
, ':');
17933 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17937 char *hash_pos
= strchr (salt_pos
, ':');
17939 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17941 u32 salt_len
= hash_pos
- salt_pos
;
17943 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17947 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17949 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17953 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17955 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17957 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17959 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17960 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17962 salt
->salt_len
= salt_len
;
17963 salt
->salt_iter
= iter
- 1;
17967 u8 tmp_buf
[100] = { 0 };
17969 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17971 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17973 memcpy (digest
, tmp_buf
, 16);
17975 digest
[0] = byte_swap_32 (digest
[0]);
17976 digest
[1] = byte_swap_32 (digest
[1]);
17977 digest
[2] = byte_swap_32 (digest
[2]);
17978 digest
[3] = byte_swap_32 (digest
[3]);
17980 // add some stuff to normal salt to make sorted happy
17982 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17983 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17984 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17985 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17986 salt
->salt_buf
[4] = salt
->salt_iter
;
17988 return (PARSER_OK
);
17991 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17993 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17995 u32
*digest
= (u32
*) hash_buf
->digest
;
17997 salt_t
*salt
= hash_buf
->salt
;
17999 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18000 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18001 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18002 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18004 digest
[0] = byte_swap_32 (digest
[0]);
18005 digest
[1] = byte_swap_32 (digest
[1]);
18006 digest
[2] = byte_swap_32 (digest
[2]);
18007 digest
[3] = byte_swap_32 (digest
[3]);
18009 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18011 uint salt_len
= input_len
- 32 - 1;
18013 char *salt_buf
= input_buf
+ 32 + 1;
18015 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18017 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18019 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18021 salt
->salt_len
= salt_len
;
18023 return (PARSER_OK
);
18026 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18028 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
18030 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18032 u32
*digest
= (u32
*) hash_buf
->digest
;
18034 salt_t
*salt
= hash_buf
->salt
;
18036 char *user_pos
= input_buf
+ 10;
18038 char *salt_pos
= strchr (user_pos
, '*');
18040 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18044 char *hash_pos
= strchr (salt_pos
, '*');
18048 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18050 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18052 uint user_len
= salt_pos
- user_pos
- 1;
18054 uint salt_len
= hash_pos
- salt_pos
- 1;
18056 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18062 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18063 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18064 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18065 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18067 digest
[0] = byte_swap_32 (digest
[0]);
18068 digest
[1] = byte_swap_32 (digest
[1]);
18069 digest
[2] = byte_swap_32 (digest
[2]);
18070 digest
[3] = byte_swap_32 (digest
[3]);
18072 digest
[0] -= MD5M_A
;
18073 digest
[1] -= MD5M_B
;
18074 digest
[2] -= MD5M_C
;
18075 digest
[3] -= MD5M_D
;
18081 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18083 // first 4 bytes are the "challenge"
18085 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18086 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18087 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18088 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18090 // append the user name
18092 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18094 salt
->salt_len
= 4 + user_len
;
18096 return (PARSER_OK
);
18099 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18101 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18103 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18105 u32
*digest
= (u32
*) hash_buf
->digest
;
18107 salt_t
*salt
= hash_buf
->salt
;
18109 char *salt_pos
= input_buf
+ 9;
18111 char *hash_pos
= strchr (salt_pos
, '*');
18113 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18117 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18119 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18121 uint salt_len
= hash_pos
- salt_pos
- 1;
18123 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18129 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18130 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18131 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18132 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18133 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18139 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18141 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18143 salt
->salt_len
= salt_len
;
18145 return (PARSER_OK
);
18148 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18150 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18152 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18154 u32
*digest
= (u32
*) hash_buf
->digest
;
18156 salt_t
*salt
= hash_buf
->salt
;
18158 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18164 char *cry_master_len_pos
= input_buf
+ 9;
18166 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18168 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18170 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18172 cry_master_buf_pos
++;
18174 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18176 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18178 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18180 cry_salt_len_pos
++;
18182 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18184 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18186 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18188 cry_salt_buf_pos
++;
18190 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18192 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18194 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18198 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18200 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18202 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18206 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18208 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18210 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18214 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18216 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18218 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18220 public_key_len_pos
++;
18222 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18224 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18226 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18228 public_key_buf_pos
++;
18230 u32 public_key_buf_len
= input_len
- 1 - 7 - 1 - cry_master_len_len
- 1 - cry_master_buf_len
- 1 - cry_salt_len_len
- 1 - cry_salt_buf_len
- 1 - cry_rounds_len
- 1 - ckey_len_len
- 1 - ckey_buf_len
- 1 - public_key_len_len
- 1;
18232 const uint cry_master_len
= atoi (cry_master_len_pos
);
18233 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18234 const uint ckey_len
= atoi (ckey_len_pos
);
18235 const uint public_key_len
= atoi (public_key_len_pos
);
18237 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18238 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18239 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18240 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18242 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18244 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18246 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18249 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18251 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18253 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18256 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18258 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18260 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18263 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18264 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18265 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18268 * store digest (should be unique enought, hopefully)
18271 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18272 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18273 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18274 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18280 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18282 const uint cry_rounds
= atoi (cry_rounds_pos
);
18284 salt
->salt_iter
= cry_rounds
- 1;
18286 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18288 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18290 salt
->salt_len
= salt_len
;
18292 return (PARSER_OK
);
18295 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18297 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18299 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18301 u32
*digest
= (u32
*) hash_buf
->digest
;
18303 salt_t
*salt
= hash_buf
->salt
;
18305 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18307 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18309 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18311 memcpy (temp_input_buf
, input_buf
, input_len
);
18315 char *URI_server_pos
= temp_input_buf
+ 6;
18317 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18319 if (URI_client_pos
== NULL
)
18321 myfree (temp_input_buf
);
18323 return (PARSER_SEPARATOR_UNMATCHED
);
18326 URI_client_pos
[0] = 0;
18329 uint URI_server_len
= strlen (URI_server_pos
);
18331 if (URI_server_len
> 512)
18333 myfree (temp_input_buf
);
18335 return (PARSER_SALT_LENGTH
);
18340 char *user_pos
= strchr (URI_client_pos
, '*');
18342 if (user_pos
== NULL
)
18344 myfree (temp_input_buf
);
18346 return (PARSER_SEPARATOR_UNMATCHED
);
18352 uint URI_client_len
= strlen (URI_client_pos
);
18354 if (URI_client_len
> 512)
18356 myfree (temp_input_buf
);
18358 return (PARSER_SALT_LENGTH
);
18363 char *realm_pos
= strchr (user_pos
, '*');
18365 if (realm_pos
== NULL
)
18367 myfree (temp_input_buf
);
18369 return (PARSER_SEPARATOR_UNMATCHED
);
18375 uint user_len
= strlen (user_pos
);
18377 if (user_len
> 116)
18379 myfree (temp_input_buf
);
18381 return (PARSER_SALT_LENGTH
);
18386 char *method_pos
= strchr (realm_pos
, '*');
18388 if (method_pos
== NULL
)
18390 myfree (temp_input_buf
);
18392 return (PARSER_SEPARATOR_UNMATCHED
);
18398 uint realm_len
= strlen (realm_pos
);
18400 if (realm_len
> 116)
18402 myfree (temp_input_buf
);
18404 return (PARSER_SALT_LENGTH
);
18409 char *URI_prefix_pos
= strchr (method_pos
, '*');
18411 if (URI_prefix_pos
== NULL
)
18413 myfree (temp_input_buf
);
18415 return (PARSER_SEPARATOR_UNMATCHED
);
18418 URI_prefix_pos
[0] = 0;
18421 uint method_len
= strlen (method_pos
);
18423 if (method_len
> 246)
18425 myfree (temp_input_buf
);
18427 return (PARSER_SALT_LENGTH
);
18432 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18434 if (URI_resource_pos
== NULL
)
18436 myfree (temp_input_buf
);
18438 return (PARSER_SEPARATOR_UNMATCHED
);
18441 URI_resource_pos
[0] = 0;
18442 URI_resource_pos
++;
18444 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18446 if (URI_prefix_len
> 245)
18448 myfree (temp_input_buf
);
18450 return (PARSER_SALT_LENGTH
);
18455 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18457 if (URI_suffix_pos
== NULL
)
18459 myfree (temp_input_buf
);
18461 return (PARSER_SEPARATOR_UNMATCHED
);
18464 URI_suffix_pos
[0] = 0;
18467 uint URI_resource_len
= strlen (URI_resource_pos
);
18469 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18471 myfree (temp_input_buf
);
18473 return (PARSER_SALT_LENGTH
);
18478 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18480 if (nonce_pos
== NULL
)
18482 myfree (temp_input_buf
);
18484 return (PARSER_SEPARATOR_UNMATCHED
);
18490 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18492 if (URI_suffix_len
> 245)
18494 myfree (temp_input_buf
);
18496 return (PARSER_SALT_LENGTH
);
18501 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18503 if (nonce_client_pos
== NULL
)
18505 myfree (temp_input_buf
);
18507 return (PARSER_SEPARATOR_UNMATCHED
);
18510 nonce_client_pos
[0] = 0;
18511 nonce_client_pos
++;
18513 uint nonce_len
= strlen (nonce_pos
);
18515 if (nonce_len
< 1 || nonce_len
> 50)
18517 myfree (temp_input_buf
);
18519 return (PARSER_SALT_LENGTH
);
18524 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18526 if (nonce_count_pos
== NULL
)
18528 myfree (temp_input_buf
);
18530 return (PARSER_SEPARATOR_UNMATCHED
);
18533 nonce_count_pos
[0] = 0;
18536 uint nonce_client_len
= strlen (nonce_client_pos
);
18538 if (nonce_client_len
> 50)
18540 myfree (temp_input_buf
);
18542 return (PARSER_SALT_LENGTH
);
18547 char *qop_pos
= strchr (nonce_count_pos
, '*');
18549 if (qop_pos
== NULL
)
18551 myfree (temp_input_buf
);
18553 return (PARSER_SEPARATOR_UNMATCHED
);
18559 uint nonce_count_len
= strlen (nonce_count_pos
);
18561 if (nonce_count_len
> 50)
18563 myfree (temp_input_buf
);
18565 return (PARSER_SALT_LENGTH
);
18570 char *directive_pos
= strchr (qop_pos
, '*');
18572 if (directive_pos
== NULL
)
18574 myfree (temp_input_buf
);
18576 return (PARSER_SEPARATOR_UNMATCHED
);
18579 directive_pos
[0] = 0;
18582 uint qop_len
= strlen (qop_pos
);
18586 myfree (temp_input_buf
);
18588 return (PARSER_SALT_LENGTH
);
18593 char *digest_pos
= strchr (directive_pos
, '*');
18595 if (digest_pos
== NULL
)
18597 myfree (temp_input_buf
);
18599 return (PARSER_SEPARATOR_UNMATCHED
);
18605 uint directive_len
= strlen (directive_pos
);
18607 if (directive_len
!= 3)
18609 myfree (temp_input_buf
);
18611 return (PARSER_SALT_LENGTH
);
18614 if (memcmp (directive_pos
, "MD5", 3))
18616 log_info ("ERROR: Only the MD5 directive is currently supported\n");
18618 myfree (temp_input_buf
);
18620 return (PARSER_SIP_AUTH_DIRECTIVE
);
18624 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18629 uint md5_max_len
= 4 * 64;
18631 uint md5_remaining_len
= md5_max_len
;
18633 uint tmp_md5_buf
[64] = { 0 };
18635 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18637 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18639 md5_len
+= method_len
+ 1;
18640 tmp_md5_ptr
+= method_len
+ 1;
18642 if (URI_prefix_len
> 0)
18644 md5_remaining_len
= md5_max_len
- md5_len
;
18646 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18648 md5_len
+= URI_prefix_len
+ 1;
18649 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18652 md5_remaining_len
= md5_max_len
- md5_len
;
18654 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18656 md5_len
+= URI_resource_len
;
18657 tmp_md5_ptr
+= URI_resource_len
;
18659 if (URI_suffix_len
> 0)
18661 md5_remaining_len
= md5_max_len
- md5_len
;
18663 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18665 md5_len
+= 1 + URI_suffix_len
;
18668 uint tmp_digest
[4] = { 0 };
18670 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18672 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18673 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18674 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18675 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18681 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18683 uint esalt_len
= 0;
18685 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18687 // there are 2 possibilities for the esalt:
18689 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18691 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18693 if (esalt_len
> max_esalt_len
)
18695 myfree (temp_input_buf
);
18697 return (PARSER_SALT_LENGTH
);
18700 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18712 esalt_len
= 1 + nonce_len
+ 1 + 32;
18714 if (esalt_len
> max_esalt_len
)
18716 myfree (temp_input_buf
);
18718 return (PARSER_SALT_LENGTH
);
18721 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18729 // add 0x80 to esalt
18731 esalt_buf_ptr
[esalt_len
] = 0x80;
18733 sip
->esalt_len
= esalt_len
;
18739 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18741 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18743 uint max_salt_len
= 119;
18745 if (salt_len
> max_salt_len
)
18747 myfree (temp_input_buf
);
18749 return (PARSER_SALT_LENGTH
);
18752 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18754 sip
->salt_len
= salt_len
;
18757 * fake salt (for sorting)
18760 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18764 uint fake_salt_len
= salt_len
;
18766 if (fake_salt_len
> max_salt_len
)
18768 fake_salt_len
= max_salt_len
;
18771 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18773 salt
->salt_len
= fake_salt_len
;
18779 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18780 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18781 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18782 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18784 digest
[0] = byte_swap_32 (digest
[0]);
18785 digest
[1] = byte_swap_32 (digest
[1]);
18786 digest
[2] = byte_swap_32 (digest
[2]);
18787 digest
[3] = byte_swap_32 (digest
[3]);
18789 myfree (temp_input_buf
);
18791 return (PARSER_OK
);
18794 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18796 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18798 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18800 u32
*digest
= (u32
*) hash_buf
->digest
;
18802 salt_t
*salt
= hash_buf
->salt
;
18806 char *digest_pos
= input_buf
;
18808 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18815 char *salt_buf
= input_buf
+ 8 + 1;
18819 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18821 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18823 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18825 salt
->salt_len
= salt_len
;
18827 return (PARSER_OK
);
18830 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18832 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18834 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18836 u32
*digest
= (u32
*) hash_buf
->digest
;
18838 salt_t
*salt
= hash_buf
->salt
;
18840 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18846 char *p_buf_pos
= input_buf
+ 4;
18848 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18850 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18852 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18854 NumCyclesPower_pos
++;
18856 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18858 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18860 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18864 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18866 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18868 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18872 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18874 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18876 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18880 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18882 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18884 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18888 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18890 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18892 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18896 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18898 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18900 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18904 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18906 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18908 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18912 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18914 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18916 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18920 u32 data_buf_len
= input_len
- 1 - 2 - 1 - p_buf_len
- 1 - NumCyclesPower_len
- 1 - salt_len_len
- 1 - salt_buf_len
- 1 - iv_len_len
- 1 - iv_buf_len
- 1 - crc_buf_len
- 1 - data_len_len
- 1 - unpack_size_len
- 1;
18922 const uint iter
= atoi (NumCyclesPower_pos
);
18923 const uint crc
= atoi (crc_buf_pos
);
18924 const uint p_buf
= atoi (p_buf_pos
);
18925 const uint salt_len
= atoi (salt_len_pos
);
18926 const uint iv_len
= atoi (iv_len_pos
);
18927 const uint unpack_size
= atoi (unpack_size_pos
);
18928 const uint data_len
= atoi (data_len_pos
);
18934 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18935 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18937 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18939 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18941 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18947 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18948 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18949 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18950 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18952 seven_zip
->iv_len
= iv_len
;
18954 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18956 seven_zip
->salt_len
= 0;
18958 seven_zip
->crc
= crc
;
18960 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18962 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18964 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18967 seven_zip
->data_len
= data_len
;
18969 seven_zip
->unpack_size
= unpack_size
;
18973 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18974 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18975 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18976 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18978 salt
->salt_len
= 16;
18980 salt
->salt_sign
[0] = iter
;
18982 salt
->salt_iter
= 1 << iter
;
18993 return (PARSER_OK
);
18996 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18998 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
19000 u32
*digest
= (u32
*) hash_buf
->digest
;
19002 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19003 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19004 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19005 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19006 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19007 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19008 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19009 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19011 digest
[0] = byte_swap_32 (digest
[0]);
19012 digest
[1] = byte_swap_32 (digest
[1]);
19013 digest
[2] = byte_swap_32 (digest
[2]);
19014 digest
[3] = byte_swap_32 (digest
[3]);
19015 digest
[4] = byte_swap_32 (digest
[4]);
19016 digest
[5] = byte_swap_32 (digest
[5]);
19017 digest
[6] = byte_swap_32 (digest
[6]);
19018 digest
[7] = byte_swap_32 (digest
[7]);
19020 return (PARSER_OK
);
19023 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19025 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
19027 u32
*digest
= (u32
*) hash_buf
->digest
;
19029 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19030 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19031 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
19032 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
19033 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
19034 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
19035 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
19036 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
19037 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
19038 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
19039 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
19040 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
19041 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
19042 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
19043 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
19044 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
19046 digest
[ 0] = byte_swap_32 (digest
[ 0]);
19047 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19048 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19049 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19050 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19051 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19052 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19053 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19054 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19055 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19056 digest
[10] = byte_swap_32 (digest
[10]);
19057 digest
[11] = byte_swap_32 (digest
[11]);
19058 digest
[12] = byte_swap_32 (digest
[12]);
19059 digest
[13] = byte_swap_32 (digest
[13]);
19060 digest
[14] = byte_swap_32 (digest
[14]);
19061 digest
[15] = byte_swap_32 (digest
[15]);
19063 return (PARSER_OK
);
19066 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19068 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19070 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19072 u32
*digest
= (u32
*) hash_buf
->digest
;
19074 salt_t
*salt
= hash_buf
->salt
;
19076 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19084 char *iter_pos
= input_buf
+ 4;
19086 u32 iter
= atoi (iter_pos
);
19088 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19089 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19091 // first is *raw* salt
19093 char *salt_pos
= strchr (iter_pos
, ':');
19095 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19099 char *hash_pos
= strchr (salt_pos
, ':');
19101 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19103 u32 salt_len
= hash_pos
- salt_pos
;
19105 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19109 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19111 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19115 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19117 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19119 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19121 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19122 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19124 salt
->salt_len
= salt_len
;
19125 salt
->salt_iter
= iter
- 1;
19129 u8 tmp_buf
[100] = { 0 };
19131 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19133 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19135 memcpy (digest
, tmp_buf
, 16);
19137 // add some stuff to normal salt to make sorted happy
19139 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19140 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19141 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19142 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19143 salt
->salt_buf
[4] = salt
->salt_iter
;
19145 return (PARSER_OK
);
19148 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19150 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19152 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19154 u32
*digest
= (u32
*) hash_buf
->digest
;
19156 salt_t
*salt
= hash_buf
->salt
;
19158 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19166 char *iter_pos
= input_buf
+ 5;
19168 u32 iter
= atoi (iter_pos
);
19170 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19171 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19173 // first is *raw* salt
19175 char *salt_pos
= strchr (iter_pos
, ':');
19177 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19181 char *hash_pos
= strchr (salt_pos
, ':');
19183 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19185 u32 salt_len
= hash_pos
- salt_pos
;
19187 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19191 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19193 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19197 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19199 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19201 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19203 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19204 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19206 salt
->salt_len
= salt_len
;
19207 salt
->salt_iter
= iter
- 1;
19211 u8 tmp_buf
[100] = { 0 };
19213 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19215 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19217 memcpy (digest
, tmp_buf
, 16);
19219 digest
[0] = byte_swap_32 (digest
[0]);
19220 digest
[1] = byte_swap_32 (digest
[1]);
19221 digest
[2] = byte_swap_32 (digest
[2]);
19222 digest
[3] = byte_swap_32 (digest
[3]);
19224 // add some stuff to normal salt to make sorted happy
19226 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19227 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19228 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19229 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19230 salt
->salt_buf
[4] = salt
->salt_iter
;
19232 return (PARSER_OK
);
19235 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19237 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19239 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19241 u64
*digest
= (u64
*) hash_buf
->digest
;
19243 salt_t
*salt
= hash_buf
->salt
;
19245 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19253 char *iter_pos
= input_buf
+ 7;
19255 u32 iter
= atoi (iter_pos
);
19257 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19258 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19260 // first is *raw* salt
19262 char *salt_pos
= strchr (iter_pos
, ':');
19264 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19268 char *hash_pos
= strchr (salt_pos
, ':');
19270 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19272 u32 salt_len
= hash_pos
- salt_pos
;
19274 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19278 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19280 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19284 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19286 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19288 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19290 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19291 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19293 salt
->salt_len
= salt_len
;
19294 salt
->salt_iter
= iter
- 1;
19298 u8 tmp_buf
[100] = { 0 };
19300 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19302 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19304 memcpy (digest
, tmp_buf
, 64);
19306 digest
[0] = byte_swap_64 (digest
[0]);
19307 digest
[1] = byte_swap_64 (digest
[1]);
19308 digest
[2] = byte_swap_64 (digest
[2]);
19309 digest
[3] = byte_swap_64 (digest
[3]);
19310 digest
[4] = byte_swap_64 (digest
[4]);
19311 digest
[5] = byte_swap_64 (digest
[5]);
19312 digest
[6] = byte_swap_64 (digest
[6]);
19313 digest
[7] = byte_swap_64 (digest
[7]);
19315 // add some stuff to normal salt to make sorted happy
19317 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19318 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19319 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19320 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19321 salt
->salt_buf
[4] = salt
->salt_iter
;
19323 return (PARSER_OK
);
19326 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19328 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19330 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19332 uint
*digest
= (uint
*) hash_buf
->digest
;
19334 salt_t
*salt
= hash_buf
->salt
;
19340 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19342 char *hash_pos
= strchr (salt_pos
, '$');
19344 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19346 u32 salt_len
= hash_pos
- salt_pos
;
19348 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19352 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19354 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19358 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19359 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19377 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19378 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19380 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19381 salt
->salt_len
= 8;
19383 return (PARSER_OK
);
19386 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19388 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19390 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19392 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19394 if (c19
& 3) return (PARSER_HASH_VALUE
);
19396 salt_t
*salt
= hash_buf
->salt
;
19398 u32
*digest
= (u32
*) hash_buf
->digest
;
19402 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19403 | itoa64_to_int (input_buf
[2]) << 6
19404 | itoa64_to_int (input_buf
[3]) << 12
19405 | itoa64_to_int (input_buf
[4]) << 18;
19409 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19410 | itoa64_to_int (input_buf
[6]) << 6
19411 | itoa64_to_int (input_buf
[7]) << 12
19412 | itoa64_to_int (input_buf
[8]) << 18;
19414 salt
->salt_len
= 4;
19416 u8 tmp_buf
[100] = { 0 };
19418 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19420 memcpy (digest
, tmp_buf
, 8);
19424 IP (digest
[0], digest
[1], tt
);
19426 digest
[0] = rotr32 (digest
[0], 31);
19427 digest
[1] = rotr32 (digest
[1], 31);
19431 return (PARSER_OK
);
19434 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19436 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19438 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19440 u32
*digest
= (u32
*) hash_buf
->digest
;
19442 salt_t
*salt
= hash_buf
->salt
;
19448 char *type_pos
= input_buf
+ 6 + 1;
19450 char *salt_pos
= strchr (type_pos
, '*');
19452 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19454 u32 type_len
= salt_pos
- type_pos
;
19456 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19460 char *crypted_pos
= strchr (salt_pos
, '*');
19462 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19464 u32 salt_len
= crypted_pos
- salt_pos
;
19466 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19470 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19472 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19478 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19479 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19481 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19482 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19484 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19485 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19486 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19487 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19489 salt
->salt_len
= 24;
19490 salt
->salt_iter
= ROUNDS_RAR3
;
19492 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19493 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19495 digest
[0] = 0xc43d7b00;
19496 digest
[1] = 0x40070000;
19500 return (PARSER_OK
);
19503 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19505 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19507 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19509 u32
*digest
= (u32
*) hash_buf
->digest
;
19511 salt_t
*salt
= hash_buf
->salt
;
19513 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19519 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19521 char *param1_pos
= strchr (param0_pos
, '$');
19523 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19525 u32 param0_len
= param1_pos
- param0_pos
;
19529 char *param2_pos
= strchr (param1_pos
, '$');
19531 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19533 u32 param1_len
= param2_pos
- param1_pos
;
19537 char *param3_pos
= strchr (param2_pos
, '$');
19539 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19541 u32 param2_len
= param3_pos
- param2_pos
;
19545 char *param4_pos
= strchr (param3_pos
, '$');
19547 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19549 u32 param3_len
= param4_pos
- param3_pos
;
19553 char *param5_pos
= strchr (param4_pos
, '$');
19555 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19557 u32 param4_len
= param5_pos
- param4_pos
;
19561 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19563 char *salt_buf
= param1_pos
;
19564 char *iv
= param3_pos
;
19565 char *pswcheck
= param5_pos
;
19567 const uint salt_len
= atoi (param0_pos
);
19568 const uint iterations
= atoi (param2_pos
);
19569 const uint pswcheck_len
= atoi (param4_pos
);
19575 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19576 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19577 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19579 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19580 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19581 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19587 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19588 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19589 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19590 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19592 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19593 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19594 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19595 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19597 salt
->salt_len
= 16;
19599 salt
->salt_sign
[0] = iterations
;
19601 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19607 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19608 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19612 return (PARSER_OK
);
19615 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19617 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19619 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19621 u32
*digest
= (u32
*) hash_buf
->digest
;
19623 salt_t
*salt
= hash_buf
->salt
;
19625 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19632 char *account_pos
= input_buf
+ 11 + 1;
19638 if (account_pos
[0] == '*')
19642 data_pos
= strchr (account_pos
, '*');
19647 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19649 uint account_len
= data_pos
- account_pos
+ 1;
19651 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19656 data_len
= input_len
- 11 - 1 - account_len
- 2;
19658 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19662 /* assume $krb5tgs$23$checksum$edata2 */
19663 data_pos
= account_pos
;
19665 memcpy (krb5tgs
->account_info
, "**", 3);
19667 data_len
= input_len
- 11 - 1 - 1;
19670 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19672 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19674 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19676 const char p0
= data_pos
[i
+ 0];
19677 const char p1
= data_pos
[i
+ 1];
19679 *checksum_ptr
++ = hex_convert (p1
) << 0
19680 | hex_convert (p0
) << 4;
19683 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19685 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19688 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19690 const char p0
= data_pos
[i
+ 0];
19691 const char p1
= data_pos
[i
+ 1];
19692 *edata_ptr
++ = hex_convert (p1
) << 0
19693 | hex_convert (p0
) << 4;
19696 /* this is needed for hmac_md5 */
19697 *edata_ptr
++ = 0x80;
19699 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19700 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19701 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19702 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19704 salt
->salt_len
= 32;
19706 digest
[0] = krb5tgs
->checksum
[0];
19707 digest
[1] = krb5tgs
->checksum
[1];
19708 digest
[2] = krb5tgs
->checksum
[2];
19709 digest
[3] = krb5tgs
->checksum
[3];
19711 return (PARSER_OK
);
19714 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19716 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19718 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19720 u32
*digest
= (u32
*) hash_buf
->digest
;
19722 salt_t
*salt
= hash_buf
->salt
;
19729 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19733 char *wrapped_key_pos
;
19737 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19739 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19741 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19743 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19748 data_pos
= salt_pos
;
19750 wrapped_key_pos
= strchr (salt_pos
, '*');
19752 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19754 uint salt_len
= wrapped_key_pos
- salt_pos
;
19756 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19761 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19763 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19765 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19766 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19767 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19768 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19772 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19773 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19774 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19775 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19776 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19777 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19779 salt
->salt_len
= 40;
19781 digest
[0] = salt
->salt_buf
[0];
19782 digest
[1] = salt
->salt_buf
[1];
19783 digest
[2] = salt
->salt_buf
[2];
19784 digest
[3] = salt
->salt_buf
[3];
19786 return (PARSER_OK
);
19789 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19791 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19793 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19795 u32
*digest
= (u32
*) hash_buf
->digest
;
19797 salt_t
*salt
= hash_buf
->salt
;
19799 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19809 char *algorithm_pos
;
19811 char *final_random_seed_pos
;
19812 u32 final_random_seed_len
;
19814 char *transf_random_seed_pos
;
19815 u32 transf_random_seed_len
;
19820 /* default is no keyfile provided */
19821 char *keyfile_len_pos
;
19822 u32 keyfile_len
= 0;
19823 u32 is_keyfile_present
= 0;
19824 char *keyfile_inline_pos
;
19827 /* specific to version 1 */
19828 char *contents_len_pos
;
19830 char *contents_pos
;
19832 /* specific to version 2 */
19833 char *expected_bytes_pos
;
19834 u32 expected_bytes_len
;
19836 char *contents_hash_pos
;
19837 u32 contents_hash_len
;
19839 version_pos
= input_buf
+ 8 + 1 + 1;
19841 keepass
->version
= atoi (version_pos
);
19843 rounds_pos
= strchr (version_pos
, '*');
19845 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19849 salt
->salt_iter
= (atoi (rounds_pos
));
19851 algorithm_pos
= strchr (rounds_pos
, '*');
19853 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19857 keepass
->algorithm
= atoi (algorithm_pos
);
19859 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19861 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19863 final_random_seed_pos
++;
19865 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19866 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19867 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19868 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19870 if (keepass
->version
== 2)
19872 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19873 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19874 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19875 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19878 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19880 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19882 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19884 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19885 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19887 transf_random_seed_pos
++;
19889 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19890 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19891 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19892 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19893 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19894 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19895 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19896 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19898 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19900 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19902 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19904 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19908 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19909 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19910 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19911 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19913 if (keepass
->version
== 1)
19915 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19917 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19919 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19921 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19923 contents_hash_pos
++;
19925 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19926 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19927 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19928 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19929 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19930 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19931 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19932 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19934 /* get length of contents following */
19935 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19937 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19939 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19941 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19945 u32 inline_flag
= atoi (inline_flag_pos
);
19947 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19949 contents_len_pos
= strchr (inline_flag_pos
, '*');
19951 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19953 contents_len_pos
++;
19955 contents_len
= atoi (contents_len_pos
);
19957 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19959 contents_pos
= strchr (contents_len_pos
, '*');
19961 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19967 keepass
->contents_len
= contents_len
;
19969 contents_len
= contents_len
/ 4;
19971 keyfile_inline_pos
= strchr (contents_pos
, '*');
19973 u32 real_contents_len
;
19975 if (keyfile_inline_pos
== NULL
)
19976 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19979 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19980 keyfile_inline_pos
++;
19981 is_keyfile_present
= 1;
19984 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19986 for (i
= 0; i
< contents_len
; i
++)
19987 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19989 else if (keepass
->version
== 2)
19991 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19993 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19995 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19997 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19999 expected_bytes_pos
++;
20001 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
20002 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
20003 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
20004 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
20005 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
20006 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
20007 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
20008 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
20010 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
20012 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20014 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
20016 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
20018 contents_hash_pos
++;
20020 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
20021 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
20022 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
20023 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20024 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20025 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20026 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20027 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20029 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
20031 if (keyfile_inline_pos
== NULL
)
20032 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
20035 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
20036 keyfile_inline_pos
++;
20037 is_keyfile_present
= 1;
20039 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20042 if (is_keyfile_present
!= 0)
20044 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20048 keyfile_len
= atoi (keyfile_len_pos
);
20050 keepass
->keyfile_len
= keyfile_len
;
20052 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20054 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20056 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20060 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20062 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20064 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20065 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20066 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20067 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20068 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20069 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20070 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20071 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20074 digest
[0] = keepass
->enc_iv
[0];
20075 digest
[1] = keepass
->enc_iv
[1];
20076 digest
[2] = keepass
->enc_iv
[2];
20077 digest
[3] = keepass
->enc_iv
[3];
20079 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20080 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20081 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20082 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20083 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20084 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20085 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20086 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20088 return (PARSER_OK
);
20091 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20093 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20095 u32
*digest
= (u32
*) hash_buf
->digest
;
20097 salt_t
*salt
= hash_buf
->salt
;
20099 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20100 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20101 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20102 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20103 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20104 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20105 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20106 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20108 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20110 uint salt_len
= input_len
- 64 - 1;
20112 char *salt_buf
= input_buf
+ 64 + 1;
20114 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20116 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20118 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20120 salt
->salt_len
= salt_len
;
20123 * we can precompute the first sha256 transform
20126 uint w
[16] = { 0 };
20128 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20129 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20130 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20131 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20132 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20133 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20134 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20135 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20136 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20137 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20138 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20139 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20140 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20141 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20142 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20143 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20145 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20147 sha256_64 (w
, pc256
);
20149 salt
->salt_buf_pc
[0] = pc256
[0];
20150 salt
->salt_buf_pc
[1] = pc256
[1];
20151 salt
->salt_buf_pc
[2] = pc256
[2];
20152 salt
->salt_buf_pc
[3] = pc256
[3];
20153 salt
->salt_buf_pc
[4] = pc256
[4];
20154 salt
->salt_buf_pc
[5] = pc256
[5];
20155 salt
->salt_buf_pc
[6] = pc256
[6];
20156 salt
->salt_buf_pc
[7] = pc256
[7];
20158 digest
[0] -= pc256
[0];
20159 digest
[1] -= pc256
[1];
20160 digest
[2] -= pc256
[2];
20161 digest
[3] -= pc256
[3];
20162 digest
[4] -= pc256
[4];
20163 digest
[5] -= pc256
[5];
20164 digest
[6] -= pc256
[6];
20165 digest
[7] -= pc256
[7];
20167 return (PARSER_OK
);
20170 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20172 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20174 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20176 u32
*digest
= (u32
*) hash_buf
->digest
;
20178 salt_t
*salt
= hash_buf
->salt
;
20184 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20186 char *data_buf_pos
= strchr (data_len_pos
, '$');
20188 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20190 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20192 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20193 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20197 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20199 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20201 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20203 u32 data_len
= atoi (data_len_pos
);
20205 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20211 char *salt_pos
= data_buf_pos
;
20213 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20214 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20215 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20216 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20218 // this is actually the CT, which is also the hash later (if matched)
20220 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20221 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20222 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20223 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20225 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20227 salt
->salt_iter
= 10 - 1;
20233 digest
[0] = salt
->salt_buf
[4];
20234 digest
[1] = salt
->salt_buf
[5];
20235 digest
[2] = salt
->salt_buf
[6];
20236 digest
[3] = salt
->salt_buf
[7];
20238 return (PARSER_OK
);
20241 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20243 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20245 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20247 u32
*digest
= (u32
*) hash_buf
->digest
;
20249 salt_t
*salt
= hash_buf
->salt
;
20255 char *salt_pos
= input_buf
+ 11 + 1;
20257 char *iter_pos
= strchr (salt_pos
, ',');
20259 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20261 u32 salt_len
= iter_pos
- salt_pos
;
20263 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20267 char *hash_pos
= strchr (iter_pos
, ',');
20269 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20271 u32 iter_len
= hash_pos
- iter_pos
;
20273 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20277 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20279 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20285 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20286 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20287 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20288 salt
->salt_buf
[3] = 0x00018000;
20290 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20291 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20292 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20293 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20295 salt
->salt_len
= salt_len
/ 2;
20297 salt
->salt_iter
= atoi (iter_pos
) - 1;
20303 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20304 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20305 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20306 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20307 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20308 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20309 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20310 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20312 return (PARSER_OK
);
20315 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20317 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20319 u32
*digest
= (u32
*) hash_buf
->digest
;
20321 salt_t
*salt
= hash_buf
->salt
;
20327 char *hash_pos
= input_buf
+ 64;
20328 char *salt1_pos
= input_buf
+ 128;
20329 char *salt2_pos
= input_buf
;
20335 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20336 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20337 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20338 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20340 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20341 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20342 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20343 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20345 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20346 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20347 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20348 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20350 salt
->salt_len
= 48;
20352 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20358 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20359 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20360 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20361 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20362 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20363 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20364 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20365 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20367 return (PARSER_OK
);
20370 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20372 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20374 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20375 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20377 u32
*digest
= (u32
*) hash_buf
->digest
;
20379 salt_t
*salt
= hash_buf
->salt
;
20381 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20387 char *param0_pos
= input_buf
+ 6 + 1;
20389 char *param1_pos
= strchr (param0_pos
, '*');
20391 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20393 u32 param0_len
= param1_pos
- param0_pos
;
20397 char *param2_pos
= strchr (param1_pos
, '*');
20399 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20401 u32 param1_len
= param2_pos
- param1_pos
;
20405 char *param3_pos
= strchr (param2_pos
, '*');
20407 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20409 u32 param2_len
= param3_pos
- param2_pos
;
20413 char *param4_pos
= strchr (param3_pos
, '*');
20415 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20417 u32 param3_len
= param4_pos
- param3_pos
;
20421 char *param5_pos
= strchr (param4_pos
, '*');
20423 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20425 u32 param4_len
= param5_pos
- param4_pos
;
20429 char *param6_pos
= strchr (param5_pos
, '*');
20431 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20433 u32 param5_len
= param6_pos
- param5_pos
;
20437 char *param7_pos
= strchr (param6_pos
, '*');
20439 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20441 u32 param6_len
= param7_pos
- param6_pos
;
20445 char *param8_pos
= strchr (param7_pos
, '*');
20447 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20449 u32 param7_len
= param8_pos
- param7_pos
;
20453 const uint type
= atoi (param0_pos
);
20454 const uint mode
= atoi (param1_pos
);
20455 const uint magic
= atoi (param2_pos
);
20457 char *salt_buf
= param3_pos
;
20459 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20461 const uint compress_length
= atoi (param5_pos
);
20463 char *data_buf
= param6_pos
;
20464 char *auth
= param7_pos
;
20470 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20472 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20474 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20476 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20478 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20480 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20482 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20484 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20486 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20488 if (type
!= 0) return (PARSER_SALT_VALUE
);
20490 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20492 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20494 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20502 zip2
->magic
= magic
;
20506 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20507 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20508 zip2
->salt_buf
[2] = 0;
20509 zip2
->salt_buf
[3] = 0;
20511 zip2
->salt_len
= 8;
20513 else if (mode
== 2)
20515 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20516 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20517 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20518 zip2
->salt_buf
[3] = 0;
20520 zip2
->salt_len
= 12;
20522 else if (mode
== 3)
20524 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20525 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20526 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20527 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20529 zip2
->salt_len
= 16;
20532 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20533 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20534 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20535 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20537 zip2
->verify_bytes
= verify_bytes
;
20539 zip2
->compress_length
= compress_length
;
20541 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20543 for (uint i
= 0; i
< param6_len
; i
+= 2)
20545 const char p0
= data_buf
[i
+ 0];
20546 const char p1
= data_buf
[i
+ 1];
20548 *data_buf_ptr
++ = hex_convert (p1
) << 0
20549 | hex_convert (p0
) << 4;
20554 *data_buf_ptr
= 0x80;
20556 char *auth_ptr
= (char *) zip2
->auth_buf
;
20558 for (uint i
= 0; i
< param7_len
; i
+= 2)
20560 const char p0
= auth
[i
+ 0];
20561 const char p1
= auth
[i
+ 1];
20563 *auth_ptr
++ = hex_convert (p1
) << 0
20564 | hex_convert (p0
) << 4;
20573 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20574 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20575 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20576 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20577 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20578 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20579 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20580 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20582 salt
->salt_len
= 32;
20584 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20587 * digest buf (fake)
20590 digest
[0] = zip2
->auth_buf
[0];
20591 digest
[1] = zip2
->auth_buf
[1];
20592 digest
[2] = zip2
->auth_buf
[2];
20593 digest
[3] = zip2
->auth_buf
[3];
20595 return (PARSER_OK
);
20598 int win8phone_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20600 if ((input_len
< DISPLAY_LEN_MIN_13800
) || (input_len
> DISPLAY_LEN_MAX_13800
)) return (PARSER_GLOBAL_LENGTH
);
20602 u32
*digest
= (u32
*) hash_buf
->digest
;
20604 salt_t
*salt
= hash_buf
->salt
;
20606 win8phone_t
*esalt
= hash_buf
->esalt
;
20608 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20609 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20610 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20611 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20612 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20613 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20614 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20615 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20617 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20619 char *salt_buf_ptr
= input_buf
+ 64 + 1;
20621 u32
*salt_buf
= esalt
->salt_buf
;
20623 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
20625 salt_buf
[i
] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[j
]);
20628 salt
->salt_buf
[0] = salt_buf
[0];
20629 salt
->salt_buf
[1] = salt_buf
[1];
20630 salt
->salt_buf
[2] = salt_buf
[2];
20631 salt
->salt_buf
[3] = salt_buf
[3];
20632 salt
->salt_buf
[4] = salt_buf
[4];
20633 salt
->salt_buf
[5] = salt_buf
[5];
20634 salt
->salt_buf
[6] = salt_buf
[6];
20635 salt
->salt_buf
[7] = salt_buf
[7];
20637 salt
->salt_len
= 64;
20639 return (PARSER_OK
);
20643 * parallel running threads
20648 BOOL WINAPI
sigHandler_default (DWORD sig
)
20652 case CTRL_CLOSE_EVENT
:
20655 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20656 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20657 * function otherwise it is too late (e.g. after returning from this function)
20662 SetConsoleCtrlHandler (NULL
, TRUE
);
20669 case CTRL_LOGOFF_EVENT
:
20670 case CTRL_SHUTDOWN_EVENT
:
20674 SetConsoleCtrlHandler (NULL
, TRUE
);
20682 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20686 case CTRL_CLOSE_EVENT
:
20690 SetConsoleCtrlHandler (NULL
, TRUE
);
20697 case CTRL_LOGOFF_EVENT
:
20698 case CTRL_SHUTDOWN_EVENT
:
20702 SetConsoleCtrlHandler (NULL
, TRUE
);
20710 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20712 if (callback
== NULL
)
20714 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20718 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20724 void sigHandler_default (int sig
)
20728 signal (sig
, NULL
);
20731 void sigHandler_benchmark (int sig
)
20735 signal (sig
, NULL
);
20738 void hc_signal (void (callback
) (int))
20740 if (callback
== NULL
) callback
= SIG_DFL
;
20742 signal (SIGINT
, callback
);
20743 signal (SIGTERM
, callback
);
20744 signal (SIGABRT
, callback
);
20749 void status_display ();
20751 void *thread_keypress (void *p
)
20753 int benchmark
= *((int *) p
);
20755 uint quiet
= data
.quiet
;
20759 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20761 int ch
= tty_getchar();
20763 if (ch
== -1) break;
20765 if (ch
== 0) continue;
20767 //https://github.com/hashcat/hashcat/issues/302
20772 hc_thread_mutex_lock (mux_display
);
20788 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20789 if (quiet
== 0) fflush (stdout
);
20801 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20802 if (quiet
== 0) fflush (stdout
);
20814 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20815 if (quiet
== 0) fflush (stdout
);
20827 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20828 if (quiet
== 0) fflush (stdout
);
20836 if (benchmark
== 1) break;
20838 stop_at_checkpoint ();
20842 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20843 if (quiet
== 0) fflush (stdout
);
20851 if (benchmark
== 1)
20863 //https://github.com/hashcat/hashcat/issues/302
20868 hc_thread_mutex_unlock (mux_display
);
20880 bool class_num (const u8 c
)
20882 return ((c
>= '0') && (c
<= '9'));
20885 bool class_lower (const u8 c
)
20887 return ((c
>= 'a') && (c
<= 'z'));
20890 bool class_upper (const u8 c
)
20892 return ((c
>= 'A') && (c
<= 'Z'));
20895 bool class_alpha (const u8 c
)
20897 return (class_lower (c
) || class_upper (c
));
20900 int conv_ctoi (const u8 c
)
20906 else if (class_upper (c
))
20908 return c
- 'A' + 10;
20914 int conv_itoc (const u8 c
)
20922 return c
+ 'A' - 10;
20932 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20933 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20934 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20935 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20936 #define MAX_KERNEL_RULES 255
20937 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20938 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20939 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20941 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20942 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20943 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20944 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20946 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20951 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20953 switch (rule_buf
[rule_pos
])
20959 case RULE_OP_MANGLE_NOOP
:
20960 SET_NAME (rule
, rule_buf
[rule_pos
]);
20963 case RULE_OP_MANGLE_LREST
:
20964 SET_NAME (rule
, rule_buf
[rule_pos
]);
20967 case RULE_OP_MANGLE_UREST
:
20968 SET_NAME (rule
, rule_buf
[rule_pos
]);
20971 case RULE_OP_MANGLE_LREST_UFIRST
:
20972 SET_NAME (rule
, rule_buf
[rule_pos
]);
20975 case RULE_OP_MANGLE_UREST_LFIRST
:
20976 SET_NAME (rule
, rule_buf
[rule_pos
]);
20979 case RULE_OP_MANGLE_TREST
:
20980 SET_NAME (rule
, rule_buf
[rule_pos
]);
20983 case RULE_OP_MANGLE_TOGGLE_AT
:
20984 SET_NAME (rule
, rule_buf
[rule_pos
]);
20985 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20988 case RULE_OP_MANGLE_REVERSE
:
20989 SET_NAME (rule
, rule_buf
[rule_pos
]);
20992 case RULE_OP_MANGLE_DUPEWORD
:
20993 SET_NAME (rule
, rule_buf
[rule_pos
]);
20996 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20997 SET_NAME (rule
, rule_buf
[rule_pos
]);
20998 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21001 case RULE_OP_MANGLE_REFLECT
:
21002 SET_NAME (rule
, rule_buf
[rule_pos
]);
21005 case RULE_OP_MANGLE_ROTATE_LEFT
:
21006 SET_NAME (rule
, rule_buf
[rule_pos
]);
21009 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21010 SET_NAME (rule
, rule_buf
[rule_pos
]);
21013 case RULE_OP_MANGLE_APPEND
:
21014 SET_NAME (rule
, rule_buf
[rule_pos
]);
21015 SET_P0 (rule
, rule_buf
[rule_pos
]);
21018 case RULE_OP_MANGLE_PREPEND
:
21019 SET_NAME (rule
, rule_buf
[rule_pos
]);
21020 SET_P0 (rule
, rule_buf
[rule_pos
]);
21023 case RULE_OP_MANGLE_DELETE_FIRST
:
21024 SET_NAME (rule
, rule_buf
[rule_pos
]);
21027 case RULE_OP_MANGLE_DELETE_LAST
:
21028 SET_NAME (rule
, rule_buf
[rule_pos
]);
21031 case RULE_OP_MANGLE_DELETE_AT
:
21032 SET_NAME (rule
, rule_buf
[rule_pos
]);
21033 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21036 case RULE_OP_MANGLE_EXTRACT
:
21037 SET_NAME (rule
, rule_buf
[rule_pos
]);
21038 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21039 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21042 case RULE_OP_MANGLE_OMIT
:
21043 SET_NAME (rule
, rule_buf
[rule_pos
]);
21044 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21045 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21048 case RULE_OP_MANGLE_INSERT
:
21049 SET_NAME (rule
, rule_buf
[rule_pos
]);
21050 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21051 SET_P1 (rule
, rule_buf
[rule_pos
]);
21054 case RULE_OP_MANGLE_OVERSTRIKE
:
21055 SET_NAME (rule
, rule_buf
[rule_pos
]);
21056 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21057 SET_P1 (rule
, rule_buf
[rule_pos
]);
21060 case RULE_OP_MANGLE_TRUNCATE_AT
:
21061 SET_NAME (rule
, rule_buf
[rule_pos
]);
21062 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21065 case RULE_OP_MANGLE_REPLACE
:
21066 SET_NAME (rule
, rule_buf
[rule_pos
]);
21067 SET_P0 (rule
, rule_buf
[rule_pos
]);
21068 SET_P1 (rule
, rule_buf
[rule_pos
]);
21071 case RULE_OP_MANGLE_PURGECHAR
:
21075 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21079 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21080 SET_NAME (rule
, rule_buf
[rule_pos
]);
21081 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21084 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21085 SET_NAME (rule
, rule_buf
[rule_pos
]);
21086 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21089 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21090 SET_NAME (rule
, rule_buf
[rule_pos
]);
21093 case RULE_OP_MANGLE_SWITCH_FIRST
:
21094 SET_NAME (rule
, rule_buf
[rule_pos
]);
21097 case RULE_OP_MANGLE_SWITCH_LAST
:
21098 SET_NAME (rule
, rule_buf
[rule_pos
]);
21101 case RULE_OP_MANGLE_SWITCH_AT
:
21102 SET_NAME (rule
, rule_buf
[rule_pos
]);
21103 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21104 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21107 case RULE_OP_MANGLE_CHR_SHIFTL
:
21108 SET_NAME (rule
, rule_buf
[rule_pos
]);
21109 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21112 case RULE_OP_MANGLE_CHR_SHIFTR
:
21113 SET_NAME (rule
, rule_buf
[rule_pos
]);
21114 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21117 case RULE_OP_MANGLE_CHR_INCR
:
21118 SET_NAME (rule
, rule_buf
[rule_pos
]);
21119 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21122 case RULE_OP_MANGLE_CHR_DECR
:
21123 SET_NAME (rule
, rule_buf
[rule_pos
]);
21124 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21127 case RULE_OP_MANGLE_REPLACE_NP1
:
21128 SET_NAME (rule
, rule_buf
[rule_pos
]);
21129 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21132 case RULE_OP_MANGLE_REPLACE_NM1
:
21133 SET_NAME (rule
, rule_buf
[rule_pos
]);
21134 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21137 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21138 SET_NAME (rule
, rule_buf
[rule_pos
]);
21139 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21142 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21143 SET_NAME (rule
, rule_buf
[rule_pos
]);
21144 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21147 case RULE_OP_MANGLE_TITLE
:
21148 SET_NAME (rule
, rule_buf
[rule_pos
]);
21157 if (rule_pos
< rule_len
) return (-1);
21162 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21166 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21170 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21174 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21178 case RULE_OP_MANGLE_NOOP
:
21179 rule_buf
[rule_pos
] = rule_cmd
;
21182 case RULE_OP_MANGLE_LREST
:
21183 rule_buf
[rule_pos
] = rule_cmd
;
21186 case RULE_OP_MANGLE_UREST
:
21187 rule_buf
[rule_pos
] = rule_cmd
;
21190 case RULE_OP_MANGLE_LREST_UFIRST
:
21191 rule_buf
[rule_pos
] = rule_cmd
;
21194 case RULE_OP_MANGLE_UREST_LFIRST
:
21195 rule_buf
[rule_pos
] = rule_cmd
;
21198 case RULE_OP_MANGLE_TREST
:
21199 rule_buf
[rule_pos
] = rule_cmd
;
21202 case RULE_OP_MANGLE_TOGGLE_AT
:
21203 rule_buf
[rule_pos
] = rule_cmd
;
21204 GET_P0_CONV (rule
);
21207 case RULE_OP_MANGLE_REVERSE
:
21208 rule_buf
[rule_pos
] = rule_cmd
;
21211 case RULE_OP_MANGLE_DUPEWORD
:
21212 rule_buf
[rule_pos
] = rule_cmd
;
21215 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21216 rule_buf
[rule_pos
] = rule_cmd
;
21217 GET_P0_CONV (rule
);
21220 case RULE_OP_MANGLE_REFLECT
:
21221 rule_buf
[rule_pos
] = rule_cmd
;
21224 case RULE_OP_MANGLE_ROTATE_LEFT
:
21225 rule_buf
[rule_pos
] = rule_cmd
;
21228 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21229 rule_buf
[rule_pos
] = rule_cmd
;
21232 case RULE_OP_MANGLE_APPEND
:
21233 rule_buf
[rule_pos
] = rule_cmd
;
21237 case RULE_OP_MANGLE_PREPEND
:
21238 rule_buf
[rule_pos
] = rule_cmd
;
21242 case RULE_OP_MANGLE_DELETE_FIRST
:
21243 rule_buf
[rule_pos
] = rule_cmd
;
21246 case RULE_OP_MANGLE_DELETE_LAST
:
21247 rule_buf
[rule_pos
] = rule_cmd
;
21250 case RULE_OP_MANGLE_DELETE_AT
:
21251 rule_buf
[rule_pos
] = rule_cmd
;
21252 GET_P0_CONV (rule
);
21255 case RULE_OP_MANGLE_EXTRACT
:
21256 rule_buf
[rule_pos
] = rule_cmd
;
21257 GET_P0_CONV (rule
);
21258 GET_P1_CONV (rule
);
21261 case RULE_OP_MANGLE_OMIT
:
21262 rule_buf
[rule_pos
] = rule_cmd
;
21263 GET_P0_CONV (rule
);
21264 GET_P1_CONV (rule
);
21267 case RULE_OP_MANGLE_INSERT
:
21268 rule_buf
[rule_pos
] = rule_cmd
;
21269 GET_P0_CONV (rule
);
21273 case RULE_OP_MANGLE_OVERSTRIKE
:
21274 rule_buf
[rule_pos
] = rule_cmd
;
21275 GET_P0_CONV (rule
);
21279 case RULE_OP_MANGLE_TRUNCATE_AT
:
21280 rule_buf
[rule_pos
] = rule_cmd
;
21281 GET_P0_CONV (rule
);
21284 case RULE_OP_MANGLE_REPLACE
:
21285 rule_buf
[rule_pos
] = rule_cmd
;
21290 case RULE_OP_MANGLE_PURGECHAR
:
21294 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21298 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21299 rule_buf
[rule_pos
] = rule_cmd
;
21300 GET_P0_CONV (rule
);
21303 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21304 rule_buf
[rule_pos
] = rule_cmd
;
21305 GET_P0_CONV (rule
);
21308 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21309 rule_buf
[rule_pos
] = rule_cmd
;
21312 case RULE_OP_MANGLE_SWITCH_FIRST
:
21313 rule_buf
[rule_pos
] = rule_cmd
;
21316 case RULE_OP_MANGLE_SWITCH_LAST
:
21317 rule_buf
[rule_pos
] = rule_cmd
;
21320 case RULE_OP_MANGLE_SWITCH_AT
:
21321 rule_buf
[rule_pos
] = rule_cmd
;
21322 GET_P0_CONV (rule
);
21323 GET_P1_CONV (rule
);
21326 case RULE_OP_MANGLE_CHR_SHIFTL
:
21327 rule_buf
[rule_pos
] = rule_cmd
;
21328 GET_P0_CONV (rule
);
21331 case RULE_OP_MANGLE_CHR_SHIFTR
:
21332 rule_buf
[rule_pos
] = rule_cmd
;
21333 GET_P0_CONV (rule
);
21336 case RULE_OP_MANGLE_CHR_INCR
:
21337 rule_buf
[rule_pos
] = rule_cmd
;
21338 GET_P0_CONV (rule
);
21341 case RULE_OP_MANGLE_CHR_DECR
:
21342 rule_buf
[rule_pos
] = rule_cmd
;
21343 GET_P0_CONV (rule
);
21346 case RULE_OP_MANGLE_REPLACE_NP1
:
21347 rule_buf
[rule_pos
] = rule_cmd
;
21348 GET_P0_CONV (rule
);
21351 case RULE_OP_MANGLE_REPLACE_NM1
:
21352 rule_buf
[rule_pos
] = rule_cmd
;
21353 GET_P0_CONV (rule
);
21356 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21357 rule_buf
[rule_pos
] = rule_cmd
;
21358 GET_P0_CONV (rule
);
21361 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21362 rule_buf
[rule_pos
] = rule_cmd
;
21363 GET_P0_CONV (rule
);
21366 case RULE_OP_MANGLE_TITLE
:
21367 rule_buf
[rule_pos
] = rule_cmd
;
21371 return rule_pos
- 1;
21389 * CPU rules : this is from hashcat sources, cpu based rules
21392 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21393 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21395 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21396 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21397 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21399 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21400 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21401 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21403 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21407 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21412 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21416 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21421 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21425 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21430 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21435 for (l
= 0; l
< arr_len
; l
++)
21437 r
= arr_len
- 1 - l
;
21441 MANGLE_SWITCH (arr
, l
, r
);
21447 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21449 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21451 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21453 return (arr_len
* 2);
21456 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21458 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21460 int orig_len
= arr_len
;
21464 for (i
= 0; i
< times
; i
++)
21466 memcpy (&arr
[arr_len
], arr
, orig_len
);
21468 arr_len
+= orig_len
;
21474 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21476 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21478 mangle_double (arr
, arr_len
);
21480 mangle_reverse (arr
+ arr_len
, arr_len
);
21482 return (arr_len
* 2);
21485 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21490 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21492 MANGLE_SWITCH (arr
, l
, r
);
21498 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21503 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21505 MANGLE_SWITCH (arr
, l
, r
);
21511 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21513 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21517 return (arr_len
+ 1);
21520 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21522 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21526 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21528 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21533 return (arr_len
+ 1);
21536 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21538 if (upos
>= arr_len
) return (arr_len
);
21542 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21544 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21547 return (arr_len
- 1);
21550 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21552 if (upos
>= arr_len
) return (arr_len
);
21554 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21558 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21560 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21566 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21568 if (upos
>= arr_len
) return (arr_len
);
21570 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21574 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21576 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21579 return (arr_len
- ulen
);
21582 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21584 if (upos
>= arr_len
) return (arr_len
);
21586 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21590 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21592 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21597 return (arr_len
+ 1);
21600 int mangle_insert_multi (char arr
[BLOCK_SIZE
], int arr_len
, int arr_pos
, char arr2
[BLOCK_SIZE
], int arr2_len
, int arr2_pos
, int arr2_cpy
)
21602 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21604 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21606 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21608 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21610 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21612 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21614 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21616 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21618 return (arr_len
+ arr2_cpy
);
21621 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21623 if (upos
>= arr_len
) return (arr_len
);
21630 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21632 if (upos
>= arr_len
) return (arr_len
);
21634 memset (arr
+ upos
, 0, arr_len
- upos
);
21639 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21643 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21645 if (arr
[arr_pos
] != oldc
) continue;
21647 arr
[arr_pos
] = newc
;
21653 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21659 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21661 if (arr
[arr_pos
] == c
) continue;
21663 arr
[ret_len
] = arr
[arr_pos
];
21671 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21673 if (ulen
> arr_len
) return (arr_len
);
21675 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21677 char cs
[100] = { 0 };
21679 memcpy (cs
, arr
, ulen
);
21683 for (i
= 0; i
< ulen
; i
++)
21687 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21693 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21695 if (ulen
> arr_len
) return (arr_len
);
21697 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21699 int upos
= arr_len
- ulen
;
21703 for (i
= 0; i
< ulen
; i
++)
21705 char c
= arr
[upos
+ i
];
21707 arr_len
= mangle_append (arr
, arr_len
, c
);
21713 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21715 if ( arr_len
== 0) return (arr_len
);
21716 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21718 char c
= arr
[upos
];
21722 for (i
= 0; i
< ulen
; i
++)
21724 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21730 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21732 if ( arr_len
== 0) return (arr_len
);
21733 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21737 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21739 int new_pos
= arr_pos
* 2;
21741 arr
[new_pos
] = arr
[arr_pos
];
21743 arr
[new_pos
+ 1] = arr
[arr_pos
];
21746 return (arr_len
* 2);
21749 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21751 if (upos
>= arr_len
) return (arr_len
);
21752 if (upos2
>= arr_len
) return (arr_len
);
21754 MANGLE_SWITCH (arr
, upos
, upos2
);
21759 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21761 MANGLE_SWITCH (arr
, upos
, upos2
);
21766 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21768 if (upos
>= arr_len
) return (arr_len
);
21775 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21777 if (upos
>= arr_len
) return (arr_len
);
21784 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21786 if (upos
>= arr_len
) return (arr_len
);
21793 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21795 if (upos
>= arr_len
) return (arr_len
);
21802 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21804 int upper_next
= 1;
21808 for (pos
= 0; pos
< arr_len
; pos
++)
21810 if (arr
[pos
] == ' ')
21821 MANGLE_UPPER_AT (arr
, pos
);
21825 MANGLE_LOWER_AT (arr
, pos
);
21832 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21834 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21840 for (j
= 0; j
< rp_gen_num
; j
++)
21847 switch ((char) get_random_num (0, 9))
21850 r
= get_random_num (0, sizeof (grp_op_nop
));
21851 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21855 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21856 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21857 p1
= get_random_num (0, sizeof (grp_pos
));
21858 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21862 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21863 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21864 p1
= get_random_num (1, 6);
21865 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21869 r
= get_random_num (0, sizeof (grp_op_chr
));
21870 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21871 p1
= get_random_num (0x20, 0x7e);
21872 rule_buf
[rule_pos
++] = (char) p1
;
21876 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21877 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21878 p1
= get_random_num (0x20, 0x7e);
21879 rule_buf
[rule_pos
++] = (char) p1
;
21880 p2
= get_random_num (0x20, 0x7e);
21882 p2
= get_random_num (0x20, 0x7e);
21883 rule_buf
[rule_pos
++] = (char) p2
;
21887 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21888 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21889 p1
= get_random_num (0, sizeof (grp_pos
));
21890 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21891 p2
= get_random_num (0x20, 0x7e);
21892 rule_buf
[rule_pos
++] = (char) p2
;
21896 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21897 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21898 p1
= get_random_num (0, sizeof (grp_pos
));
21899 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21900 p2
= get_random_num (0, sizeof (grp_pos
));
21902 p2
= get_random_num (0, sizeof (grp_pos
));
21903 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21907 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21908 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21909 p1
= get_random_num (0, sizeof (grp_pos
));
21910 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21911 p2
= get_random_num (1, sizeof (grp_pos
));
21913 p2
= get_random_num (1, sizeof (grp_pos
));
21914 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21918 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21919 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21920 p1
= get_random_num (0, sizeof (grp_pos
));
21921 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21922 p2
= get_random_num (1, sizeof (grp_pos
));
21923 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21924 p3
= get_random_num (0, sizeof (grp_pos
));
21925 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21933 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21935 char mem
[BLOCK_SIZE
] = { 0 };
21937 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21939 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21941 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21943 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21945 int out_len
= in_len
;
21946 int mem_len
= in_len
;
21948 memcpy (out
, in
, out_len
);
21952 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21957 switch (rule
[rule_pos
])
21962 case RULE_OP_MANGLE_NOOP
:
21965 case RULE_OP_MANGLE_LREST
:
21966 out_len
= mangle_lrest (out
, out_len
);
21969 case RULE_OP_MANGLE_UREST
:
21970 out_len
= mangle_urest (out
, out_len
);
21973 case RULE_OP_MANGLE_LREST_UFIRST
:
21974 out_len
= mangle_lrest (out
, out_len
);
21975 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21978 case RULE_OP_MANGLE_UREST_LFIRST
:
21979 out_len
= mangle_urest (out
, out_len
);
21980 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21983 case RULE_OP_MANGLE_TREST
:
21984 out_len
= mangle_trest (out
, out_len
);
21987 case RULE_OP_MANGLE_TOGGLE_AT
:
21988 NEXT_RULEPOS (rule_pos
);
21989 NEXT_RPTOI (rule
, rule_pos
, upos
);
21990 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21993 case RULE_OP_MANGLE_REVERSE
:
21994 out_len
= mangle_reverse (out
, out_len
);
21997 case RULE_OP_MANGLE_DUPEWORD
:
21998 out_len
= mangle_double (out
, out_len
);
22001 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
22002 NEXT_RULEPOS (rule_pos
);
22003 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22004 out_len
= mangle_double_times (out
, out_len
, ulen
);
22007 case RULE_OP_MANGLE_REFLECT
:
22008 out_len
= mangle_reflect (out
, out_len
);
22011 case RULE_OP_MANGLE_ROTATE_LEFT
:
22012 mangle_rotate_left (out
, out_len
);
22015 case RULE_OP_MANGLE_ROTATE_RIGHT
:
22016 mangle_rotate_right (out
, out_len
);
22019 case RULE_OP_MANGLE_APPEND
:
22020 NEXT_RULEPOS (rule_pos
);
22021 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
22024 case RULE_OP_MANGLE_PREPEND
:
22025 NEXT_RULEPOS (rule_pos
);
22026 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
22029 case RULE_OP_MANGLE_DELETE_FIRST
:
22030 out_len
= mangle_delete_at (out
, out_len
, 0);
22033 case RULE_OP_MANGLE_DELETE_LAST
:
22034 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
22037 case RULE_OP_MANGLE_DELETE_AT
:
22038 NEXT_RULEPOS (rule_pos
);
22039 NEXT_RPTOI (rule
, rule_pos
, upos
);
22040 out_len
= mangle_delete_at (out
, out_len
, upos
);
22043 case RULE_OP_MANGLE_EXTRACT
:
22044 NEXT_RULEPOS (rule_pos
);
22045 NEXT_RPTOI (rule
, rule_pos
, upos
);
22046 NEXT_RULEPOS (rule_pos
);
22047 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22048 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
22051 case RULE_OP_MANGLE_OMIT
:
22052 NEXT_RULEPOS (rule_pos
);
22053 NEXT_RPTOI (rule
, rule_pos
, upos
);
22054 NEXT_RULEPOS (rule_pos
);
22055 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22056 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
22059 case RULE_OP_MANGLE_INSERT
:
22060 NEXT_RULEPOS (rule_pos
);
22061 NEXT_RPTOI (rule
, rule_pos
, upos
);
22062 NEXT_RULEPOS (rule_pos
);
22063 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22066 case RULE_OP_MANGLE_OVERSTRIKE
:
22067 NEXT_RULEPOS (rule_pos
);
22068 NEXT_RPTOI (rule
, rule_pos
, upos
);
22069 NEXT_RULEPOS (rule_pos
);
22070 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22073 case RULE_OP_MANGLE_TRUNCATE_AT
:
22074 NEXT_RULEPOS (rule_pos
);
22075 NEXT_RPTOI (rule
, rule_pos
, upos
);
22076 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22079 case RULE_OP_MANGLE_REPLACE
:
22080 NEXT_RULEPOS (rule_pos
);
22081 NEXT_RULEPOS (rule_pos
);
22082 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22085 case RULE_OP_MANGLE_PURGECHAR
:
22086 NEXT_RULEPOS (rule_pos
);
22087 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22090 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22094 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22095 NEXT_RULEPOS (rule_pos
);
22096 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22097 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22100 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22101 NEXT_RULEPOS (rule_pos
);
22102 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22103 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22106 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22107 out_len
= mangle_dupechar (out
, out_len
);
22110 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22111 NEXT_RULEPOS (rule_pos
);
22112 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22113 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22116 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22117 NEXT_RULEPOS (rule_pos
);
22118 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22119 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22122 case RULE_OP_MANGLE_SWITCH_FIRST
:
22123 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22126 case RULE_OP_MANGLE_SWITCH_LAST
:
22127 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22130 case RULE_OP_MANGLE_SWITCH_AT
:
22131 NEXT_RULEPOS (rule_pos
);
22132 NEXT_RPTOI (rule
, rule_pos
, upos
);
22133 NEXT_RULEPOS (rule_pos
);
22134 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22135 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22138 case RULE_OP_MANGLE_CHR_SHIFTL
:
22139 NEXT_RULEPOS (rule_pos
);
22140 NEXT_RPTOI (rule
, rule_pos
, upos
);
22141 mangle_chr_shiftl (out
, out_len
, upos
);
22144 case RULE_OP_MANGLE_CHR_SHIFTR
:
22145 NEXT_RULEPOS (rule_pos
);
22146 NEXT_RPTOI (rule
, rule_pos
, upos
);
22147 mangle_chr_shiftr (out
, out_len
, upos
);
22150 case RULE_OP_MANGLE_CHR_INCR
:
22151 NEXT_RULEPOS (rule_pos
);
22152 NEXT_RPTOI (rule
, rule_pos
, upos
);
22153 mangle_chr_incr (out
, out_len
, upos
);
22156 case RULE_OP_MANGLE_CHR_DECR
:
22157 NEXT_RULEPOS (rule_pos
);
22158 NEXT_RPTOI (rule
, rule_pos
, upos
);
22159 mangle_chr_decr (out
, out_len
, upos
);
22162 case RULE_OP_MANGLE_REPLACE_NP1
:
22163 NEXT_RULEPOS (rule_pos
);
22164 NEXT_RPTOI (rule
, rule_pos
, upos
);
22165 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22168 case RULE_OP_MANGLE_REPLACE_NM1
:
22169 NEXT_RULEPOS (rule_pos
);
22170 NEXT_RPTOI (rule
, rule_pos
, upos
);
22171 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22174 case RULE_OP_MANGLE_TITLE
:
22175 out_len
= mangle_title (out
, out_len
);
22178 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22179 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22180 NEXT_RULEPOS (rule_pos
);
22181 NEXT_RPTOI (rule
, rule_pos
, upos
);
22182 NEXT_RULEPOS (rule_pos
);
22183 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22184 NEXT_RULEPOS (rule_pos
);
22185 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22186 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22189 case RULE_OP_MANGLE_APPEND_MEMORY
:
22190 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22191 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22192 memcpy (out
+ out_len
, mem
, mem_len
);
22193 out_len
+= mem_len
;
22196 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22197 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22198 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22199 memcpy (mem
+ mem_len
, out
, out_len
);
22200 out_len
+= mem_len
;
22201 memcpy (out
, mem
, out_len
);
22204 case RULE_OP_MEMORIZE_WORD
:
22205 memcpy (mem
, out
, out_len
);
22209 case RULE_OP_REJECT_LESS
:
22210 NEXT_RULEPOS (rule_pos
);
22211 NEXT_RPTOI (rule
, rule_pos
, upos
);
22212 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22215 case RULE_OP_REJECT_GREATER
:
22216 NEXT_RULEPOS (rule_pos
);
22217 NEXT_RPTOI (rule
, rule_pos
, upos
);
22218 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22221 case RULE_OP_REJECT_CONTAIN
:
22222 NEXT_RULEPOS (rule_pos
);
22223 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22226 case RULE_OP_REJECT_NOT_CONTAIN
:
22227 NEXT_RULEPOS (rule_pos
);
22228 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22231 case RULE_OP_REJECT_EQUAL_FIRST
:
22232 NEXT_RULEPOS (rule_pos
);
22233 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22236 case RULE_OP_REJECT_EQUAL_LAST
:
22237 NEXT_RULEPOS (rule_pos
);
22238 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22241 case RULE_OP_REJECT_EQUAL_AT
:
22242 NEXT_RULEPOS (rule_pos
);
22243 NEXT_RPTOI (rule
, rule_pos
, upos
);
22244 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22245 NEXT_RULEPOS (rule_pos
);
22246 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22249 case RULE_OP_REJECT_CONTAINS
:
22250 NEXT_RULEPOS (rule_pos
);
22251 NEXT_RPTOI (rule
, rule_pos
, upos
);
22252 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22253 NEXT_RULEPOS (rule_pos
);
22254 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22255 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22258 case RULE_OP_REJECT_MEMORY
:
22259 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22263 return (RULE_RC_SYNTAX_ERROR
);
22268 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);