2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
15 #include <pthread_np.h>
25 u32
is_power_of_2(u32 v
)
27 return (v
&& !(v
& (v
- 1)));
30 u32
rotl32 (const u32 a
, const u32 n
)
32 return ((a
<< n
) | (a
>> (32 - n
)));
35 u32
rotr32 (const u32 a
, const u32 n
)
37 return ((a
>> n
) | (a
<< (32 - n
)));
40 u64
rotl64 (const u64 a
, const u64 n
)
42 return ((a
<< n
) | (a
>> (64 - n
)));
45 u64
rotr64 (const u64 a
, const u64 n
)
47 return ((a
>> n
) | (a
<< (64 - n
)));
50 u32
byte_swap_32 (const u32 n
)
52 return (n
& 0xff000000) >> 24
53 | (n
& 0x00ff0000) >> 8
54 | (n
& 0x0000ff00) << 8
55 | (n
& 0x000000ff) << 24;
58 u64
byte_swap_64 (const u64 n
)
60 return (n
& 0xff00000000000000ULL
) >> 56
61 | (n
& 0x00ff000000000000ULL
) >> 40
62 | (n
& 0x0000ff0000000000ULL
) >> 24
63 | (n
& 0x000000ff00000000ULL
) >> 8
64 | (n
& 0x00000000ff000000ULL
) << 8
65 | (n
& 0x0000000000ff0000ULL
) << 24
66 | (n
& 0x000000000000ff00ULL
) << 40
67 | (n
& 0x00000000000000ffULL
) << 56;
71 * ciphers for use on cpu
78 * hashes for use on cpu
83 #include "cpu-sha256.c"
91 int log_final (FILE *fp
, const char *fmt
, va_list ap
)
97 for (int i
= 0; i
< last_len
; i
++)
105 char s
[4096] = { 0 };
107 int max_len
= (int) sizeof (s
);
109 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
111 if (len
> max_len
) len
= max_len
;
113 fwrite (s
, len
, 1, fp
);
122 int log_out_nn (FILE *fp
, const char *fmt
, ...)
124 if (SUPPRESS_OUTPUT
) return 0;
130 const int len
= log_final (fp
, fmt
, ap
);
137 int log_info_nn (const char *fmt
, ...)
139 if (SUPPRESS_OUTPUT
) return 0;
145 const int len
= log_final (stdout
, fmt
, ap
);
152 int log_error_nn (const char *fmt
, ...)
154 if (SUPPRESS_OUTPUT
) return 0;
160 const int len
= log_final (stderr
, fmt
, ap
);
167 int log_out (FILE *fp
, const char *fmt
, ...)
169 if (SUPPRESS_OUTPUT
) return 0;
175 const int len
= log_final (fp
, fmt
, ap
);
186 int log_info (const char *fmt
, ...)
188 if (SUPPRESS_OUTPUT
) return 0;
194 const int len
= log_final (stdout
, fmt
, ap
);
198 fputc ('\n', stdout
);
205 int log_error (const char *fmt
, ...)
207 if (SUPPRESS_OUTPUT
) return 0;
209 fputc ('\n', stderr
);
210 fputc ('\n', stderr
);
216 const int len
= log_final (stderr
, fmt
, ap
);
220 fputc ('\n', stderr
);
221 fputc ('\n', stderr
);
232 u8
int_to_base32 (const u8 c
)
234 static const u8 tbl
[0x20] =
236 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
237 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
243 u8
base32_to_int (const u8 c
)
245 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
246 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
251 u8
int_to_itoa32 (const u8 c
)
253 static const u8 tbl
[0x20] =
255 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
256 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
262 u8
itoa32_to_int (const u8 c
)
264 if ((c
>= '0') && (c
<= '9')) return c
- '0';
265 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
270 u8
int_to_itoa64 (const u8 c
)
272 static const u8 tbl
[0x40] =
274 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
275 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
276 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
277 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
283 u8
itoa64_to_int (const u8 c
)
285 static const u8 tbl
[0x100] =
287 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
288 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
289 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
290 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
291 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
292 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
293 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
294 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
295 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
296 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
297 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
298 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
299 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
300 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
301 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
302 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
308 u8
int_to_base64 (const u8 c
)
310 static const u8 tbl
[0x40] =
312 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
313 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
314 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
315 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
321 u8
base64_to_int (const u8 c
)
323 static const u8 tbl
[0x100] =
325 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
326 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
327 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
328 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
329 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
330 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
331 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
332 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 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,
336 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
337 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
338 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
339 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
340 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
346 u8
int_to_bf64 (const u8 c
)
348 static const u8 tbl
[0x40] =
350 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
351 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
352 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
353 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
359 u8
bf64_to_int (const u8 c
)
361 static const u8 tbl
[0x100] =
363 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
364 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
365 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
366 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
367 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
368 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
369 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
370 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 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,
374 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
375 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
376 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
377 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
378 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
384 u8
int_to_lotus64 (const u8 c
)
386 if (c
< 10) return '0' + c
;
387 else if (c
< 36) return 'A' + c
- 10;
388 else if (c
< 62) return 'a' + c
- 36;
389 else if (c
== 62) return '+';
390 else if (c
== 63) return '/';
395 u8
lotus64_to_int (const u8 c
)
397 if ((c
>= '0') && (c
<= '9')) return c
- '0';
398 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
399 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
400 else if (c
== '+') return 62;
401 else if (c
== '/') return 63;
407 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
409 const u8
*in_ptr
= in_buf
;
411 u8
*out_ptr
= out_buf
;
413 for (int i
= 0; i
< in_len
; i
+= 8)
415 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
416 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
417 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
418 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
419 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
420 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
421 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
422 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
424 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
425 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
426 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
427 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
428 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
434 for (int i
= 0; i
< in_len
; i
++)
436 if (in_buf
[i
] != '=') continue;
441 int out_len
= (in_len
* 5) / 8;
446 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
448 const u8
*in_ptr
= in_buf
;
450 u8
*out_ptr
= out_buf
;
452 for (int i
= 0; i
< in_len
; i
+= 5)
454 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
455 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
456 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
457 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
458 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
459 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
460 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
461 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
463 out_ptr
[0] = out_val0
& 0x7f;
464 out_ptr
[1] = out_val1
& 0x7f;
465 out_ptr
[2] = out_val2
& 0x7f;
466 out_ptr
[3] = out_val3
& 0x7f;
467 out_ptr
[4] = out_val4
& 0x7f;
468 out_ptr
[5] = out_val5
& 0x7f;
469 out_ptr
[6] = out_val6
& 0x7f;
470 out_ptr
[7] = out_val7
& 0x7f;
476 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
480 out_buf
[out_len
] = '=';
488 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
490 const u8
*in_ptr
= in_buf
;
492 u8
*out_ptr
= out_buf
;
494 for (int i
= 0; i
< in_len
; i
+= 4)
496 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
497 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
498 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
499 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
501 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
502 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
503 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
509 for (int i
= 0; i
< in_len
; i
++)
511 if (in_buf
[i
] != '=') continue;
516 int out_len
= (in_len
* 6) / 8;
521 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
523 const u8
*in_ptr
= in_buf
;
525 u8
*out_ptr
= out_buf
;
527 for (int i
= 0; i
< in_len
; i
+= 3)
529 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
530 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
531 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
532 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
534 out_ptr
[0] = out_val0
& 0x7f;
535 out_ptr
[1] = out_val1
& 0x7f;
536 out_ptr
[2] = out_val2
& 0x7f;
537 out_ptr
[3] = out_val3
& 0x7f;
543 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
547 out_buf
[out_len
] = '=';
555 int is_valid_hex_char (const u8 c
)
557 if ((c
>= '0') && (c
<= '9')) return 1;
558 if ((c
>= 'A') && (c
<= 'F')) return 1;
559 if ((c
>= 'a') && (c
<= 'f')) return 1;
564 u8
hex_convert (const u8 c
)
566 return (c
& 15) + (c
>> 6) * 9;
569 u8
hex_to_u8 (const u8 hex
[2])
573 v
|= (hex_convert (hex
[1]) << 0);
574 v
|= (hex_convert (hex
[0]) << 4);
579 u32
hex_to_u32 (const u8 hex
[8])
583 v
|= ((u32
) hex_convert (hex
[7])) << 0;
584 v
|= ((u32
) hex_convert (hex
[6])) << 4;
585 v
|= ((u32
) hex_convert (hex
[5])) << 8;
586 v
|= ((u32
) hex_convert (hex
[4])) << 12;
587 v
|= ((u32
) hex_convert (hex
[3])) << 16;
588 v
|= ((u32
) hex_convert (hex
[2])) << 20;
589 v
|= ((u32
) hex_convert (hex
[1])) << 24;
590 v
|= ((u32
) hex_convert (hex
[0])) << 28;
595 u64
hex_to_u64 (const u8 hex
[16])
599 v
|= ((u64
) hex_convert (hex
[15]) << 0);
600 v
|= ((u64
) hex_convert (hex
[14]) << 4);
601 v
|= ((u64
) hex_convert (hex
[13]) << 8);
602 v
|= ((u64
) hex_convert (hex
[12]) << 12);
603 v
|= ((u64
) hex_convert (hex
[11]) << 16);
604 v
|= ((u64
) hex_convert (hex
[10]) << 20);
605 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
606 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
607 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
608 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
609 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
610 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
611 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
612 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
613 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
614 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
619 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
621 hex
[0] = v
>> 28 & 15;
622 hex
[1] = v
>> 24 & 15;
623 hex
[2] = v
>> 20 & 15;
624 hex
[3] = v
>> 16 & 15;
625 hex
[4] = v
>> 12 & 15;
626 hex
[5] = v
>> 8 & 15;
627 hex
[6] = v
>> 4 & 15;
628 hex
[7] = v
>> 0 & 15;
632 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
633 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
634 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
635 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
636 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
637 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
638 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
639 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
646 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
650 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
659 for (int i
= 0; i
< 16; i
+= 4)
669 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
676 out
[i
+ 0] = _out
[0];
677 out
[i
+ 1] = _out
[1];
678 out
[i
+ 2] = _out
[2];
679 out
[i
+ 3] = _out
[3];
688 static void juniper_decrypt_hash (char *in
, char *out
)
692 u8 base64_buf
[100] = { 0 };
694 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
698 u32 juniper_iv
[4] = { 0 };
700 memcpy (juniper_iv
, base64_buf
, 12);
702 memcpy (out
, juniper_iv
, 12);
706 u32 juniper_key
[4] = { 0 };
708 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
709 juniper_key
[1] = byte_swap_32 (0x8df91059);
710 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
711 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
715 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
716 u32
*out_ptr
= (u32
*) (out
+ 12);
718 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
721 void phpass_decode (u8 digest
[16], u8 buf
[22])
725 l
= itoa64_to_int (buf
[ 0]) << 0;
726 l
|= itoa64_to_int (buf
[ 1]) << 6;
727 l
|= itoa64_to_int (buf
[ 2]) << 12;
728 l
|= itoa64_to_int (buf
[ 3]) << 18;
730 digest
[ 0] = (l
>> 0) & 0xff;
731 digest
[ 1] = (l
>> 8) & 0xff;
732 digest
[ 2] = (l
>> 16) & 0xff;
734 l
= itoa64_to_int (buf
[ 4]) << 0;
735 l
|= itoa64_to_int (buf
[ 5]) << 6;
736 l
|= itoa64_to_int (buf
[ 6]) << 12;
737 l
|= itoa64_to_int (buf
[ 7]) << 18;
739 digest
[ 3] = (l
>> 0) & 0xff;
740 digest
[ 4] = (l
>> 8) & 0xff;
741 digest
[ 5] = (l
>> 16) & 0xff;
743 l
= itoa64_to_int (buf
[ 8]) << 0;
744 l
|= itoa64_to_int (buf
[ 9]) << 6;
745 l
|= itoa64_to_int (buf
[10]) << 12;
746 l
|= itoa64_to_int (buf
[11]) << 18;
748 digest
[ 6] = (l
>> 0) & 0xff;
749 digest
[ 7] = (l
>> 8) & 0xff;
750 digest
[ 8] = (l
>> 16) & 0xff;
752 l
= itoa64_to_int (buf
[12]) << 0;
753 l
|= itoa64_to_int (buf
[13]) << 6;
754 l
|= itoa64_to_int (buf
[14]) << 12;
755 l
|= itoa64_to_int (buf
[15]) << 18;
757 digest
[ 9] = (l
>> 0) & 0xff;
758 digest
[10] = (l
>> 8) & 0xff;
759 digest
[11] = (l
>> 16) & 0xff;
761 l
= itoa64_to_int (buf
[16]) << 0;
762 l
|= itoa64_to_int (buf
[17]) << 6;
763 l
|= itoa64_to_int (buf
[18]) << 12;
764 l
|= itoa64_to_int (buf
[19]) << 18;
766 digest
[12] = (l
>> 0) & 0xff;
767 digest
[13] = (l
>> 8) & 0xff;
768 digest
[14] = (l
>> 16) & 0xff;
770 l
= itoa64_to_int (buf
[20]) << 0;
771 l
|= itoa64_to_int (buf
[21]) << 6;
773 digest
[15] = (l
>> 0) & 0xff;
776 void phpass_encode (u8 digest
[16], u8 buf
[22])
780 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
782 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
783 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
784 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
787 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
789 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
790 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
791 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
794 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
796 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
797 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
798 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[11] = int_to_itoa64 (l
& 0x3f);
801 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
803 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
804 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
805 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
806 buf
[15] = int_to_itoa64 (l
& 0x3f);
808 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
810 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
811 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
812 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
813 buf
[19] = int_to_itoa64 (l
& 0x3f);
815 l
= (digest
[15] << 0);
817 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
818 buf
[21] = int_to_itoa64 (l
& 0x3f);
821 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
825 l
= itoa64_to_int (buf
[ 0]) << 0;
826 l
|= itoa64_to_int (buf
[ 1]) << 6;
827 l
|= itoa64_to_int (buf
[ 2]) << 12;
828 l
|= itoa64_to_int (buf
[ 3]) << 18;
830 digest
[ 0] = (l
>> 16) & 0xff;
831 digest
[ 6] = (l
>> 8) & 0xff;
832 digest
[12] = (l
>> 0) & 0xff;
834 l
= itoa64_to_int (buf
[ 4]) << 0;
835 l
|= itoa64_to_int (buf
[ 5]) << 6;
836 l
|= itoa64_to_int (buf
[ 6]) << 12;
837 l
|= itoa64_to_int (buf
[ 7]) << 18;
839 digest
[ 1] = (l
>> 16) & 0xff;
840 digest
[ 7] = (l
>> 8) & 0xff;
841 digest
[13] = (l
>> 0) & 0xff;
843 l
= itoa64_to_int (buf
[ 8]) << 0;
844 l
|= itoa64_to_int (buf
[ 9]) << 6;
845 l
|= itoa64_to_int (buf
[10]) << 12;
846 l
|= itoa64_to_int (buf
[11]) << 18;
848 digest
[ 2] = (l
>> 16) & 0xff;
849 digest
[ 8] = (l
>> 8) & 0xff;
850 digest
[14] = (l
>> 0) & 0xff;
852 l
= itoa64_to_int (buf
[12]) << 0;
853 l
|= itoa64_to_int (buf
[13]) << 6;
854 l
|= itoa64_to_int (buf
[14]) << 12;
855 l
|= itoa64_to_int (buf
[15]) << 18;
857 digest
[ 3] = (l
>> 16) & 0xff;
858 digest
[ 9] = (l
>> 8) & 0xff;
859 digest
[15] = (l
>> 0) & 0xff;
861 l
= itoa64_to_int (buf
[16]) << 0;
862 l
|= itoa64_to_int (buf
[17]) << 6;
863 l
|= itoa64_to_int (buf
[18]) << 12;
864 l
|= itoa64_to_int (buf
[19]) << 18;
866 digest
[ 4] = (l
>> 16) & 0xff;
867 digest
[10] = (l
>> 8) & 0xff;
868 digest
[ 5] = (l
>> 0) & 0xff;
870 l
= itoa64_to_int (buf
[20]) << 0;
871 l
|= itoa64_to_int (buf
[21]) << 6;
873 digest
[11] = (l
>> 0) & 0xff;
876 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
880 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
882 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
883 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
884 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
889 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
890 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
891 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
896 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
897 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
898 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
901 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
903 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
904 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
905 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
906 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
908 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
910 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
911 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
912 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
913 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
915 l
= (digest
[11] << 0);
917 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
918 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
921 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
925 l
= itoa64_to_int (buf
[ 0]) << 0;
926 l
|= itoa64_to_int (buf
[ 1]) << 6;
927 l
|= itoa64_to_int (buf
[ 2]) << 12;
928 l
|= itoa64_to_int (buf
[ 3]) << 18;
930 digest
[ 0] = (l
>> 16) & 0xff;
931 digest
[21] = (l
>> 8) & 0xff;
932 digest
[42] = (l
>> 0) & 0xff;
934 l
= itoa64_to_int (buf
[ 4]) << 0;
935 l
|= itoa64_to_int (buf
[ 5]) << 6;
936 l
|= itoa64_to_int (buf
[ 6]) << 12;
937 l
|= itoa64_to_int (buf
[ 7]) << 18;
939 digest
[22] = (l
>> 16) & 0xff;
940 digest
[43] = (l
>> 8) & 0xff;
941 digest
[ 1] = (l
>> 0) & 0xff;
943 l
= itoa64_to_int (buf
[ 8]) << 0;
944 l
|= itoa64_to_int (buf
[ 9]) << 6;
945 l
|= itoa64_to_int (buf
[10]) << 12;
946 l
|= itoa64_to_int (buf
[11]) << 18;
948 digest
[44] = (l
>> 16) & 0xff;
949 digest
[ 2] = (l
>> 8) & 0xff;
950 digest
[23] = (l
>> 0) & 0xff;
952 l
= itoa64_to_int (buf
[12]) << 0;
953 l
|= itoa64_to_int (buf
[13]) << 6;
954 l
|= itoa64_to_int (buf
[14]) << 12;
955 l
|= itoa64_to_int (buf
[15]) << 18;
957 digest
[ 3] = (l
>> 16) & 0xff;
958 digest
[24] = (l
>> 8) & 0xff;
959 digest
[45] = (l
>> 0) & 0xff;
961 l
= itoa64_to_int (buf
[16]) << 0;
962 l
|= itoa64_to_int (buf
[17]) << 6;
963 l
|= itoa64_to_int (buf
[18]) << 12;
964 l
|= itoa64_to_int (buf
[19]) << 18;
966 digest
[25] = (l
>> 16) & 0xff;
967 digest
[46] = (l
>> 8) & 0xff;
968 digest
[ 4] = (l
>> 0) & 0xff;
970 l
= itoa64_to_int (buf
[20]) << 0;
971 l
|= itoa64_to_int (buf
[21]) << 6;
972 l
|= itoa64_to_int (buf
[22]) << 12;
973 l
|= itoa64_to_int (buf
[23]) << 18;
975 digest
[47] = (l
>> 16) & 0xff;
976 digest
[ 5] = (l
>> 8) & 0xff;
977 digest
[26] = (l
>> 0) & 0xff;
979 l
= itoa64_to_int (buf
[24]) << 0;
980 l
|= itoa64_to_int (buf
[25]) << 6;
981 l
|= itoa64_to_int (buf
[26]) << 12;
982 l
|= itoa64_to_int (buf
[27]) << 18;
984 digest
[ 6] = (l
>> 16) & 0xff;
985 digest
[27] = (l
>> 8) & 0xff;
986 digest
[48] = (l
>> 0) & 0xff;
988 l
= itoa64_to_int (buf
[28]) << 0;
989 l
|= itoa64_to_int (buf
[29]) << 6;
990 l
|= itoa64_to_int (buf
[30]) << 12;
991 l
|= itoa64_to_int (buf
[31]) << 18;
993 digest
[28] = (l
>> 16) & 0xff;
994 digest
[49] = (l
>> 8) & 0xff;
995 digest
[ 7] = (l
>> 0) & 0xff;
997 l
= itoa64_to_int (buf
[32]) << 0;
998 l
|= itoa64_to_int (buf
[33]) << 6;
999 l
|= itoa64_to_int (buf
[34]) << 12;
1000 l
|= itoa64_to_int (buf
[35]) << 18;
1002 digest
[50] = (l
>> 16) & 0xff;
1003 digest
[ 8] = (l
>> 8) & 0xff;
1004 digest
[29] = (l
>> 0) & 0xff;
1006 l
= itoa64_to_int (buf
[36]) << 0;
1007 l
|= itoa64_to_int (buf
[37]) << 6;
1008 l
|= itoa64_to_int (buf
[38]) << 12;
1009 l
|= itoa64_to_int (buf
[39]) << 18;
1011 digest
[ 9] = (l
>> 16) & 0xff;
1012 digest
[30] = (l
>> 8) & 0xff;
1013 digest
[51] = (l
>> 0) & 0xff;
1015 l
= itoa64_to_int (buf
[40]) << 0;
1016 l
|= itoa64_to_int (buf
[41]) << 6;
1017 l
|= itoa64_to_int (buf
[42]) << 12;
1018 l
|= itoa64_to_int (buf
[43]) << 18;
1020 digest
[31] = (l
>> 16) & 0xff;
1021 digest
[52] = (l
>> 8) & 0xff;
1022 digest
[10] = (l
>> 0) & 0xff;
1024 l
= itoa64_to_int (buf
[44]) << 0;
1025 l
|= itoa64_to_int (buf
[45]) << 6;
1026 l
|= itoa64_to_int (buf
[46]) << 12;
1027 l
|= itoa64_to_int (buf
[47]) << 18;
1029 digest
[53] = (l
>> 16) & 0xff;
1030 digest
[11] = (l
>> 8) & 0xff;
1031 digest
[32] = (l
>> 0) & 0xff;
1033 l
= itoa64_to_int (buf
[48]) << 0;
1034 l
|= itoa64_to_int (buf
[49]) << 6;
1035 l
|= itoa64_to_int (buf
[50]) << 12;
1036 l
|= itoa64_to_int (buf
[51]) << 18;
1038 digest
[12] = (l
>> 16) & 0xff;
1039 digest
[33] = (l
>> 8) & 0xff;
1040 digest
[54] = (l
>> 0) & 0xff;
1042 l
= itoa64_to_int (buf
[52]) << 0;
1043 l
|= itoa64_to_int (buf
[53]) << 6;
1044 l
|= itoa64_to_int (buf
[54]) << 12;
1045 l
|= itoa64_to_int (buf
[55]) << 18;
1047 digest
[34] = (l
>> 16) & 0xff;
1048 digest
[55] = (l
>> 8) & 0xff;
1049 digest
[13] = (l
>> 0) & 0xff;
1051 l
= itoa64_to_int (buf
[56]) << 0;
1052 l
|= itoa64_to_int (buf
[57]) << 6;
1053 l
|= itoa64_to_int (buf
[58]) << 12;
1054 l
|= itoa64_to_int (buf
[59]) << 18;
1056 digest
[56] = (l
>> 16) & 0xff;
1057 digest
[14] = (l
>> 8) & 0xff;
1058 digest
[35] = (l
>> 0) & 0xff;
1060 l
= itoa64_to_int (buf
[60]) << 0;
1061 l
|= itoa64_to_int (buf
[61]) << 6;
1062 l
|= itoa64_to_int (buf
[62]) << 12;
1063 l
|= itoa64_to_int (buf
[63]) << 18;
1065 digest
[15] = (l
>> 16) & 0xff;
1066 digest
[36] = (l
>> 8) & 0xff;
1067 digest
[57] = (l
>> 0) & 0xff;
1069 l
= itoa64_to_int (buf
[64]) << 0;
1070 l
|= itoa64_to_int (buf
[65]) << 6;
1071 l
|= itoa64_to_int (buf
[66]) << 12;
1072 l
|= itoa64_to_int (buf
[67]) << 18;
1074 digest
[37] = (l
>> 16) & 0xff;
1075 digest
[58] = (l
>> 8) & 0xff;
1076 digest
[16] = (l
>> 0) & 0xff;
1078 l
= itoa64_to_int (buf
[68]) << 0;
1079 l
|= itoa64_to_int (buf
[69]) << 6;
1080 l
|= itoa64_to_int (buf
[70]) << 12;
1081 l
|= itoa64_to_int (buf
[71]) << 18;
1083 digest
[59] = (l
>> 16) & 0xff;
1084 digest
[17] = (l
>> 8) & 0xff;
1085 digest
[38] = (l
>> 0) & 0xff;
1087 l
= itoa64_to_int (buf
[72]) << 0;
1088 l
|= itoa64_to_int (buf
[73]) << 6;
1089 l
|= itoa64_to_int (buf
[74]) << 12;
1090 l
|= itoa64_to_int (buf
[75]) << 18;
1092 digest
[18] = (l
>> 16) & 0xff;
1093 digest
[39] = (l
>> 8) & 0xff;
1094 digest
[60] = (l
>> 0) & 0xff;
1096 l
= itoa64_to_int (buf
[76]) << 0;
1097 l
|= itoa64_to_int (buf
[77]) << 6;
1098 l
|= itoa64_to_int (buf
[78]) << 12;
1099 l
|= itoa64_to_int (buf
[79]) << 18;
1101 digest
[40] = (l
>> 16) & 0xff;
1102 digest
[61] = (l
>> 8) & 0xff;
1103 digest
[19] = (l
>> 0) & 0xff;
1105 l
= itoa64_to_int (buf
[80]) << 0;
1106 l
|= itoa64_to_int (buf
[81]) << 6;
1107 l
|= itoa64_to_int (buf
[82]) << 12;
1108 l
|= itoa64_to_int (buf
[83]) << 18;
1110 digest
[62] = (l
>> 16) & 0xff;
1111 digest
[20] = (l
>> 8) & 0xff;
1112 digest
[41] = (l
>> 0) & 0xff;
1114 l
= itoa64_to_int (buf
[84]) << 0;
1115 l
|= itoa64_to_int (buf
[85]) << 6;
1117 digest
[63] = (l
>> 0) & 0xff;
1120 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1124 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1126 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1127 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1128 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1133 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1134 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1135 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1140 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1141 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1142 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1147 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1148 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1149 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1154 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1155 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1156 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1161 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1162 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1163 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1168 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1169 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1170 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1175 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1176 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1177 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1182 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1183 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1184 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1189 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1190 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1191 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1196 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1197 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1198 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1203 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1204 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1205 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1210 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1211 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1212 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1217 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1218 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1219 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1224 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1225 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1226 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1231 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1232 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1233 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1238 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1239 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1240 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1245 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1246 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1247 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1252 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1253 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1254 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1257 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1259 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1260 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1261 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1262 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1264 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1266 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1267 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1268 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1269 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1271 l
= 0 | 0 | (digest
[63] << 0);
1273 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1274 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1277 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1281 l
= itoa64_to_int (buf
[ 0]) << 0;
1282 l
|= itoa64_to_int (buf
[ 1]) << 6;
1283 l
|= itoa64_to_int (buf
[ 2]) << 12;
1284 l
|= itoa64_to_int (buf
[ 3]) << 18;
1286 digest
[ 2] = (l
>> 0) & 0xff;
1287 digest
[ 1] = (l
>> 8) & 0xff;
1288 digest
[ 0] = (l
>> 16) & 0xff;
1290 l
= itoa64_to_int (buf
[ 4]) << 0;
1291 l
|= itoa64_to_int (buf
[ 5]) << 6;
1292 l
|= itoa64_to_int (buf
[ 6]) << 12;
1293 l
|= itoa64_to_int (buf
[ 7]) << 18;
1295 digest
[ 5] = (l
>> 0) & 0xff;
1296 digest
[ 4] = (l
>> 8) & 0xff;
1297 digest
[ 3] = (l
>> 16) & 0xff;
1299 l
= itoa64_to_int (buf
[ 8]) << 0;
1300 l
|= itoa64_to_int (buf
[ 9]) << 6;
1301 l
|= itoa64_to_int (buf
[10]) << 12;
1302 l
|= itoa64_to_int (buf
[11]) << 18;
1304 digest
[ 8] = (l
>> 0) & 0xff;
1305 digest
[ 7] = (l
>> 8) & 0xff;
1306 digest
[ 6] = (l
>> 16) & 0xff;
1308 l
= itoa64_to_int (buf
[12]) << 0;
1309 l
|= itoa64_to_int (buf
[13]) << 6;
1310 l
|= itoa64_to_int (buf
[14]) << 12;
1311 l
|= itoa64_to_int (buf
[15]) << 18;
1313 digest
[11] = (l
>> 0) & 0xff;
1314 digest
[10] = (l
>> 8) & 0xff;
1315 digest
[ 9] = (l
>> 16) & 0xff;
1317 l
= itoa64_to_int (buf
[16]) << 0;
1318 l
|= itoa64_to_int (buf
[17]) << 6;
1319 l
|= itoa64_to_int (buf
[18]) << 12;
1320 l
|= itoa64_to_int (buf
[19]) << 18;
1322 digest
[14] = (l
>> 0) & 0xff;
1323 digest
[13] = (l
>> 8) & 0xff;
1324 digest
[12] = (l
>> 16) & 0xff;
1326 l
= itoa64_to_int (buf
[20]) << 0;
1327 l
|= itoa64_to_int (buf
[21]) << 6;
1328 l
|= itoa64_to_int (buf
[22]) << 12;
1329 l
|= itoa64_to_int (buf
[23]) << 18;
1331 digest
[17] = (l
>> 0) & 0xff;
1332 digest
[16] = (l
>> 8) & 0xff;
1333 digest
[15] = (l
>> 16) & 0xff;
1335 l
= itoa64_to_int (buf
[24]) << 0;
1336 l
|= itoa64_to_int (buf
[25]) << 6;
1337 l
|= itoa64_to_int (buf
[26]) << 12;
1339 digest
[19] = (l
>> 8) & 0xff;
1340 digest
[18] = (l
>> 16) & 0xff;
1343 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1347 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1349 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1350 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1351 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1354 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1356 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1357 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1358 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1361 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1363 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1364 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1365 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[11] = int_to_itoa64 (l
& 0x3f);
1368 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1370 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1371 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1372 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[15] = int_to_itoa64 (l
& 0x3f);
1375 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1377 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1378 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1379 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1380 buf
[19] = int_to_itoa64 (l
& 0x3f);
1382 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1384 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1385 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1386 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1387 buf
[23] = int_to_itoa64 (l
& 0x3f);
1389 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1391 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1392 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1393 buf
[26] = int_to_itoa64 (l
& 0x3f);
1396 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1400 l
= itoa64_to_int (buf
[ 0]) << 0;
1401 l
|= itoa64_to_int (buf
[ 1]) << 6;
1402 l
|= itoa64_to_int (buf
[ 2]) << 12;
1403 l
|= itoa64_to_int (buf
[ 3]) << 18;
1405 digest
[ 2] = (l
>> 0) & 0xff;
1406 digest
[ 1] = (l
>> 8) & 0xff;
1407 digest
[ 0] = (l
>> 16) & 0xff;
1409 l
= itoa64_to_int (buf
[ 4]) << 0;
1410 l
|= itoa64_to_int (buf
[ 5]) << 6;
1411 l
|= itoa64_to_int (buf
[ 6]) << 12;
1412 l
|= itoa64_to_int (buf
[ 7]) << 18;
1414 digest
[ 5] = (l
>> 0) & 0xff;
1415 digest
[ 4] = (l
>> 8) & 0xff;
1416 digest
[ 3] = (l
>> 16) & 0xff;
1418 l
= itoa64_to_int (buf
[ 8]) << 0;
1419 l
|= itoa64_to_int (buf
[ 9]) << 6;
1420 l
|= itoa64_to_int (buf
[10]) << 12;
1421 l
|= itoa64_to_int (buf
[11]) << 18;
1423 digest
[ 8] = (l
>> 0) & 0xff;
1424 digest
[ 7] = (l
>> 8) & 0xff;
1425 digest
[ 6] = (l
>> 16) & 0xff;
1427 l
= itoa64_to_int (buf
[12]) << 0;
1428 l
|= itoa64_to_int (buf
[13]) << 6;
1429 l
|= itoa64_to_int (buf
[14]) << 12;
1430 l
|= itoa64_to_int (buf
[15]) << 18;
1432 digest
[11] = (l
>> 0) & 0xff;
1433 digest
[10] = (l
>> 8) & 0xff;
1434 digest
[ 9] = (l
>> 16) & 0xff;
1436 l
= itoa64_to_int (buf
[16]) << 0;
1437 l
|= itoa64_to_int (buf
[17]) << 6;
1438 l
|= itoa64_to_int (buf
[18]) << 12;
1439 l
|= itoa64_to_int (buf
[19]) << 18;
1441 digest
[14] = (l
>> 0) & 0xff;
1442 digest
[13] = (l
>> 8) & 0xff;
1443 digest
[12] = (l
>> 16) & 0xff;
1445 l
= itoa64_to_int (buf
[20]) << 0;
1446 l
|= itoa64_to_int (buf
[21]) << 6;
1447 l
|= itoa64_to_int (buf
[22]) << 12;
1448 l
|= itoa64_to_int (buf
[23]) << 18;
1450 digest
[17] = (l
>> 0) & 0xff;
1451 digest
[16] = (l
>> 8) & 0xff;
1452 digest
[15] = (l
>> 16) & 0xff;
1454 l
= itoa64_to_int (buf
[24]) << 0;
1455 l
|= itoa64_to_int (buf
[25]) << 6;
1456 l
|= itoa64_to_int (buf
[26]) << 12;
1457 l
|= itoa64_to_int (buf
[27]) << 18;
1459 digest
[20] = (l
>> 0) & 0xff;
1460 digest
[19] = (l
>> 8) & 0xff;
1461 digest
[18] = (l
>> 16) & 0xff;
1463 l
= itoa64_to_int (buf
[28]) << 0;
1464 l
|= itoa64_to_int (buf
[29]) << 6;
1465 l
|= itoa64_to_int (buf
[30]) << 12;
1466 l
|= itoa64_to_int (buf
[31]) << 18;
1468 digest
[23] = (l
>> 0) & 0xff;
1469 digest
[22] = (l
>> 8) & 0xff;
1470 digest
[21] = (l
>> 16) & 0xff;
1472 l
= itoa64_to_int (buf
[32]) << 0;
1473 l
|= itoa64_to_int (buf
[33]) << 6;
1474 l
|= itoa64_to_int (buf
[34]) << 12;
1475 l
|= itoa64_to_int (buf
[35]) << 18;
1477 digest
[26] = (l
>> 0) & 0xff;
1478 digest
[25] = (l
>> 8) & 0xff;
1479 digest
[24] = (l
>> 16) & 0xff;
1481 l
= itoa64_to_int (buf
[36]) << 0;
1482 l
|= itoa64_to_int (buf
[37]) << 6;
1483 l
|= itoa64_to_int (buf
[38]) << 12;
1484 l
|= itoa64_to_int (buf
[39]) << 18;
1486 digest
[29] = (l
>> 0) & 0xff;
1487 digest
[28] = (l
>> 8) & 0xff;
1488 digest
[27] = (l
>> 16) & 0xff;
1490 l
= itoa64_to_int (buf
[40]) << 0;
1491 l
|= itoa64_to_int (buf
[41]) << 6;
1492 l
|= itoa64_to_int (buf
[42]) << 12;
1494 //digest[32] = (l >> 0) & 0xff;
1495 digest
[31] = (l
>> 8) & 0xff;
1496 digest
[30] = (l
>> 16) & 0xff;
1499 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1503 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1505 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1506 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1507 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1510 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1512 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1513 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1514 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1517 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1519 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1520 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1521 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[11] = int_to_itoa64 (l
& 0x3f);
1524 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1526 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1527 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1528 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[15] = int_to_itoa64 (l
& 0x3f);
1531 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1533 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1534 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1535 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[19] = int_to_itoa64 (l
& 0x3f);
1538 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1540 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1541 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1542 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[23] = int_to_itoa64 (l
& 0x3f);
1545 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1547 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1548 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1549 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[27] = int_to_itoa64 (l
& 0x3f);
1552 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1554 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1555 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1556 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[31] = int_to_itoa64 (l
& 0x3f);
1559 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1561 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1562 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1563 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1564 buf
[35] = int_to_itoa64 (l
& 0x3f);
1566 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1568 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1569 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1570 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1571 buf
[39] = int_to_itoa64 (l
& 0x3f);
1573 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1575 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1576 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1577 buf
[42] = int_to_itoa64 (l
& 0x3f);
1580 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1584 l
= itoa64_to_int (buf
[ 0]) << 0;
1585 l
|= itoa64_to_int (buf
[ 1]) << 6;
1586 l
|= itoa64_to_int (buf
[ 2]) << 12;
1587 l
|= itoa64_to_int (buf
[ 3]) << 18;
1589 digest
[ 2] = (l
>> 0) & 0xff;
1590 digest
[ 1] = (l
>> 8) & 0xff;
1591 digest
[ 0] = (l
>> 16) & 0xff;
1593 l
= itoa64_to_int (buf
[ 4]) << 0;
1594 l
|= itoa64_to_int (buf
[ 5]) << 6;
1595 l
|= itoa64_to_int (buf
[ 6]) << 12;
1596 l
|= itoa64_to_int (buf
[ 7]) << 18;
1598 digest
[ 5] = (l
>> 0) & 0xff;
1599 digest
[ 4] = (l
>> 8) & 0xff;
1600 digest
[ 3] = (l
>> 16) & 0xff;
1602 l
= itoa64_to_int (buf
[ 8]) << 0;
1603 l
|= itoa64_to_int (buf
[ 9]) << 6;
1604 l
|= itoa64_to_int (buf
[10]) << 12;
1605 l
|= itoa64_to_int (buf
[11]) << 18;
1607 digest
[ 8] = (l
>> 0) & 0xff;
1608 digest
[ 7] = (l
>> 8) & 0xff;
1609 digest
[ 6] = (l
>> 16) & 0xff;
1611 l
= itoa64_to_int (buf
[12]) << 0;
1612 l
|= itoa64_to_int (buf
[13]) << 6;
1613 l
|= itoa64_to_int (buf
[14]) << 12;
1614 l
|= itoa64_to_int (buf
[15]) << 18;
1616 digest
[11] = (l
>> 0) & 0xff;
1617 digest
[10] = (l
>> 8) & 0xff;
1618 digest
[ 9] = (l
>> 16) & 0xff;
1620 l
= itoa64_to_int (buf
[16]) << 0;
1621 l
|= itoa64_to_int (buf
[17]) << 6;
1622 l
|= itoa64_to_int (buf
[18]) << 12;
1623 l
|= itoa64_to_int (buf
[19]) << 18;
1625 digest
[14] = (l
>> 0) & 0xff;
1626 digest
[13] = (l
>> 8) & 0xff;
1627 digest
[12] = (l
>> 16) & 0xff;
1629 l
= itoa64_to_int (buf
[20]) << 0;
1630 l
|= itoa64_to_int (buf
[21]) << 6;
1631 l
|= itoa64_to_int (buf
[22]) << 12;
1632 l
|= itoa64_to_int (buf
[23]) << 18;
1634 digest
[17] = (l
>> 0) & 0xff;
1635 digest
[16] = (l
>> 8) & 0xff;
1636 digest
[15] = (l
>> 16) & 0xff;
1638 l
= itoa64_to_int (buf
[24]) << 0;
1639 l
|= itoa64_to_int (buf
[25]) << 6;
1640 l
|= itoa64_to_int (buf
[26]) << 12;
1641 l
|= itoa64_to_int (buf
[27]) << 18;
1643 digest
[20] = (l
>> 0) & 0xff;
1644 digest
[19] = (l
>> 8) & 0xff;
1645 digest
[18] = (l
>> 16) & 0xff;
1647 l
= itoa64_to_int (buf
[28]) << 0;
1648 l
|= itoa64_to_int (buf
[29]) << 6;
1649 l
|= itoa64_to_int (buf
[30]) << 12;
1650 l
|= itoa64_to_int (buf
[31]) << 18;
1652 digest
[23] = (l
>> 0) & 0xff;
1653 digest
[22] = (l
>> 8) & 0xff;
1654 digest
[21] = (l
>> 16) & 0xff;
1656 l
= itoa64_to_int (buf
[32]) << 0;
1657 l
|= itoa64_to_int (buf
[33]) << 6;
1658 l
|= itoa64_to_int (buf
[34]) << 12;
1659 l
|= itoa64_to_int (buf
[35]) << 18;
1661 digest
[26] = (l
>> 0) & 0xff;
1662 digest
[25] = (l
>> 8) & 0xff;
1663 digest
[24] = (l
>> 16) & 0xff;
1665 l
= itoa64_to_int (buf
[36]) << 0;
1666 l
|= itoa64_to_int (buf
[37]) << 6;
1667 l
|= itoa64_to_int (buf
[38]) << 12;
1668 l
|= itoa64_to_int (buf
[39]) << 18;
1670 digest
[29] = (l
>> 0) & 0xff;
1671 digest
[28] = (l
>> 8) & 0xff;
1672 digest
[27] = (l
>> 16) & 0xff;
1674 l
= itoa64_to_int (buf
[40]) << 0;
1675 l
|= itoa64_to_int (buf
[41]) << 6;
1676 l
|= itoa64_to_int (buf
[42]) << 12;
1677 l
|= itoa64_to_int (buf
[43]) << 18;
1679 digest
[32] = (l
>> 0) & 0xff;
1680 digest
[31] = (l
>> 8) & 0xff;
1681 digest
[30] = (l
>> 16) & 0xff;
1683 l
= itoa64_to_int (buf
[44]) << 0;
1684 l
|= itoa64_to_int (buf
[45]) << 6;
1685 l
|= itoa64_to_int (buf
[46]) << 12;
1686 l
|= itoa64_to_int (buf
[47]) << 18;
1688 digest
[35] = (l
>> 0) & 0xff;
1689 digest
[34] = (l
>> 8) & 0xff;
1690 digest
[33] = (l
>> 16) & 0xff;
1692 l
= itoa64_to_int (buf
[48]) << 0;
1693 l
|= itoa64_to_int (buf
[49]) << 6;
1694 l
|= itoa64_to_int (buf
[50]) << 12;
1695 l
|= itoa64_to_int (buf
[51]) << 18;
1697 digest
[38] = (l
>> 0) & 0xff;
1698 digest
[37] = (l
>> 8) & 0xff;
1699 digest
[36] = (l
>> 16) & 0xff;
1701 l
= itoa64_to_int (buf
[52]) << 0;
1702 l
|= itoa64_to_int (buf
[53]) << 6;
1703 l
|= itoa64_to_int (buf
[54]) << 12;
1704 l
|= itoa64_to_int (buf
[55]) << 18;
1706 digest
[41] = (l
>> 0) & 0xff;
1707 digest
[40] = (l
>> 8) & 0xff;
1708 digest
[39] = (l
>> 16) & 0xff;
1710 l
= itoa64_to_int (buf
[56]) << 0;
1711 l
|= itoa64_to_int (buf
[57]) << 6;
1712 l
|= itoa64_to_int (buf
[58]) << 12;
1713 l
|= itoa64_to_int (buf
[59]) << 18;
1715 digest
[44] = (l
>> 0) & 0xff;
1716 digest
[43] = (l
>> 8) & 0xff;
1717 digest
[42] = (l
>> 16) & 0xff;
1719 l
= itoa64_to_int (buf
[60]) << 0;
1720 l
|= itoa64_to_int (buf
[61]) << 6;
1721 l
|= itoa64_to_int (buf
[62]) << 12;
1722 l
|= itoa64_to_int (buf
[63]) << 18;
1724 digest
[47] = (l
>> 0) & 0xff;
1725 digest
[46] = (l
>> 8) & 0xff;
1726 digest
[45] = (l
>> 16) & 0xff;
1728 l
= itoa64_to_int (buf
[64]) << 0;
1729 l
|= itoa64_to_int (buf
[65]) << 6;
1730 l
|= itoa64_to_int (buf
[66]) << 12;
1731 l
|= itoa64_to_int (buf
[67]) << 18;
1733 digest
[50] = (l
>> 0) & 0xff;
1734 digest
[49] = (l
>> 8) & 0xff;
1735 digest
[48] = (l
>> 16) & 0xff;
1737 l
= itoa64_to_int (buf
[68]) << 0;
1738 l
|= itoa64_to_int (buf
[69]) << 6;
1739 l
|= itoa64_to_int (buf
[70]) << 12;
1740 l
|= itoa64_to_int (buf
[71]) << 18;
1742 digest
[53] = (l
>> 0) & 0xff;
1743 digest
[52] = (l
>> 8) & 0xff;
1744 digest
[51] = (l
>> 16) & 0xff;
1746 l
= itoa64_to_int (buf
[72]) << 0;
1747 l
|= itoa64_to_int (buf
[73]) << 6;
1748 l
|= itoa64_to_int (buf
[74]) << 12;
1749 l
|= itoa64_to_int (buf
[75]) << 18;
1751 digest
[56] = (l
>> 0) & 0xff;
1752 digest
[55] = (l
>> 8) & 0xff;
1753 digest
[54] = (l
>> 16) & 0xff;
1755 l
= itoa64_to_int (buf
[76]) << 0;
1756 l
|= itoa64_to_int (buf
[77]) << 6;
1757 l
|= itoa64_to_int (buf
[78]) << 12;
1758 l
|= itoa64_to_int (buf
[79]) << 18;
1760 digest
[59] = (l
>> 0) & 0xff;
1761 digest
[58] = (l
>> 8) & 0xff;
1762 digest
[57] = (l
>> 16) & 0xff;
1764 l
= itoa64_to_int (buf
[80]) << 0;
1765 l
|= itoa64_to_int (buf
[81]) << 6;
1766 l
|= itoa64_to_int (buf
[82]) << 12;
1767 l
|= itoa64_to_int (buf
[83]) << 18;
1769 digest
[62] = (l
>> 0) & 0xff;
1770 digest
[61] = (l
>> 8) & 0xff;
1771 digest
[60] = (l
>> 16) & 0xff;
1773 l
= itoa64_to_int (buf
[84]) << 0;
1774 l
|= itoa64_to_int (buf
[85]) << 6;
1776 digest
[63] = (l
>> 16) & 0xff;
1779 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1783 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1785 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1786 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1787 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1790 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1792 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1793 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1794 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1797 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1799 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1800 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1801 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[11] = int_to_itoa64 (l
& 0x3f);
1804 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1806 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1807 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1808 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[15] = int_to_itoa64 (l
& 0x3f);
1811 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1813 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1814 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1815 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[19] = int_to_itoa64 (l
& 0x3f);
1818 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1820 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1821 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1822 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[23] = int_to_itoa64 (l
& 0x3f);
1825 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1827 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1828 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1829 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[27] = int_to_itoa64 (l
& 0x3f);
1832 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1834 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1835 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1836 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[31] = int_to_itoa64 (l
& 0x3f);
1839 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1841 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1842 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1843 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[35] = int_to_itoa64 (l
& 0x3f);
1846 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1848 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1849 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1850 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[39] = int_to_itoa64 (l
& 0x3f);
1853 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1855 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1856 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1857 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[43] = int_to_itoa64 (l
& 0x3f);
1860 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1862 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1863 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1864 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[47] = int_to_itoa64 (l
& 0x3f);
1867 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1869 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1870 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1871 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[51] = int_to_itoa64 (l
& 0x3f);
1874 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1876 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1877 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1878 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[55] = int_to_itoa64 (l
& 0x3f);
1881 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1883 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1884 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1885 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[59] = int_to_itoa64 (l
& 0x3f);
1888 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1890 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1891 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1892 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[63] = int_to_itoa64 (l
& 0x3f);
1895 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1897 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1898 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1899 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[67] = int_to_itoa64 (l
& 0x3f);
1902 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1904 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1905 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1906 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[71] = int_to_itoa64 (l
& 0x3f);
1909 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1911 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1912 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1913 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[75] = int_to_itoa64 (l
& 0x3f);
1916 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1918 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1919 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1920 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1921 buf
[79] = int_to_itoa64 (l
& 0x3f);
1923 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1925 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1926 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1927 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1928 buf
[83] = int_to_itoa64 (l
& 0x3f);
1930 l
= 0 | 0 | (digest
[63] << 16);
1932 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1933 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1936 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1940 l
= itoa64_to_int (buf
[ 0]) << 0;
1941 l
|= itoa64_to_int (buf
[ 1]) << 6;
1942 l
|= itoa64_to_int (buf
[ 2]) << 12;
1943 l
|= itoa64_to_int (buf
[ 3]) << 18;
1945 digest
[ 0] = (l
>> 16) & 0xff;
1946 digest
[10] = (l
>> 8) & 0xff;
1947 digest
[20] = (l
>> 0) & 0xff;
1949 l
= itoa64_to_int (buf
[ 4]) << 0;
1950 l
|= itoa64_to_int (buf
[ 5]) << 6;
1951 l
|= itoa64_to_int (buf
[ 6]) << 12;
1952 l
|= itoa64_to_int (buf
[ 7]) << 18;
1954 digest
[21] = (l
>> 16) & 0xff;
1955 digest
[ 1] = (l
>> 8) & 0xff;
1956 digest
[11] = (l
>> 0) & 0xff;
1958 l
= itoa64_to_int (buf
[ 8]) << 0;
1959 l
|= itoa64_to_int (buf
[ 9]) << 6;
1960 l
|= itoa64_to_int (buf
[10]) << 12;
1961 l
|= itoa64_to_int (buf
[11]) << 18;
1963 digest
[12] = (l
>> 16) & 0xff;
1964 digest
[22] = (l
>> 8) & 0xff;
1965 digest
[ 2] = (l
>> 0) & 0xff;
1967 l
= itoa64_to_int (buf
[12]) << 0;
1968 l
|= itoa64_to_int (buf
[13]) << 6;
1969 l
|= itoa64_to_int (buf
[14]) << 12;
1970 l
|= itoa64_to_int (buf
[15]) << 18;
1972 digest
[ 3] = (l
>> 16) & 0xff;
1973 digest
[13] = (l
>> 8) & 0xff;
1974 digest
[23] = (l
>> 0) & 0xff;
1976 l
= itoa64_to_int (buf
[16]) << 0;
1977 l
|= itoa64_to_int (buf
[17]) << 6;
1978 l
|= itoa64_to_int (buf
[18]) << 12;
1979 l
|= itoa64_to_int (buf
[19]) << 18;
1981 digest
[24] = (l
>> 16) & 0xff;
1982 digest
[ 4] = (l
>> 8) & 0xff;
1983 digest
[14] = (l
>> 0) & 0xff;
1985 l
= itoa64_to_int (buf
[20]) << 0;
1986 l
|= itoa64_to_int (buf
[21]) << 6;
1987 l
|= itoa64_to_int (buf
[22]) << 12;
1988 l
|= itoa64_to_int (buf
[23]) << 18;
1990 digest
[15] = (l
>> 16) & 0xff;
1991 digest
[25] = (l
>> 8) & 0xff;
1992 digest
[ 5] = (l
>> 0) & 0xff;
1994 l
= itoa64_to_int (buf
[24]) << 0;
1995 l
|= itoa64_to_int (buf
[25]) << 6;
1996 l
|= itoa64_to_int (buf
[26]) << 12;
1997 l
|= itoa64_to_int (buf
[27]) << 18;
1999 digest
[ 6] = (l
>> 16) & 0xff;
2000 digest
[16] = (l
>> 8) & 0xff;
2001 digest
[26] = (l
>> 0) & 0xff;
2003 l
= itoa64_to_int (buf
[28]) << 0;
2004 l
|= itoa64_to_int (buf
[29]) << 6;
2005 l
|= itoa64_to_int (buf
[30]) << 12;
2006 l
|= itoa64_to_int (buf
[31]) << 18;
2008 digest
[27] = (l
>> 16) & 0xff;
2009 digest
[ 7] = (l
>> 8) & 0xff;
2010 digest
[17] = (l
>> 0) & 0xff;
2012 l
= itoa64_to_int (buf
[32]) << 0;
2013 l
|= itoa64_to_int (buf
[33]) << 6;
2014 l
|= itoa64_to_int (buf
[34]) << 12;
2015 l
|= itoa64_to_int (buf
[35]) << 18;
2017 digest
[18] = (l
>> 16) & 0xff;
2018 digest
[28] = (l
>> 8) & 0xff;
2019 digest
[ 8] = (l
>> 0) & 0xff;
2021 l
= itoa64_to_int (buf
[36]) << 0;
2022 l
|= itoa64_to_int (buf
[37]) << 6;
2023 l
|= itoa64_to_int (buf
[38]) << 12;
2024 l
|= itoa64_to_int (buf
[39]) << 18;
2026 digest
[ 9] = (l
>> 16) & 0xff;
2027 digest
[19] = (l
>> 8) & 0xff;
2028 digest
[29] = (l
>> 0) & 0xff;
2030 l
= itoa64_to_int (buf
[40]) << 0;
2031 l
|= itoa64_to_int (buf
[41]) << 6;
2032 l
|= itoa64_to_int (buf
[42]) << 12;
2034 digest
[31] = (l
>> 8) & 0xff;
2035 digest
[30] = (l
>> 0) & 0xff;
2038 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2042 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2044 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2045 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2046 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2051 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2052 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2053 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2058 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2059 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2060 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2065 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2066 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2067 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2072 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2073 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2074 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2079 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2080 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2081 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2086 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2087 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2088 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2093 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2094 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2095 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2098 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2100 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2101 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2102 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2103 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2105 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2107 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2108 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2109 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2110 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2112 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2114 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2115 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2116 buf
[42] = int_to_itoa64 (l
& 0x3f);
2119 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2123 l
= itoa64_to_int (buf
[ 0]) << 0;
2124 l
|= itoa64_to_int (buf
[ 1]) << 6;
2125 l
|= itoa64_to_int (buf
[ 2]) << 12;
2126 l
|= itoa64_to_int (buf
[ 3]) << 18;
2128 digest
[ 0] = (l
>> 0) & 0xff;
2129 digest
[ 1] = (l
>> 8) & 0xff;
2130 digest
[ 2] = (l
>> 16) & 0xff;
2132 l
= itoa64_to_int (buf
[ 4]) << 0;
2133 l
|= itoa64_to_int (buf
[ 5]) << 6;
2134 l
|= itoa64_to_int (buf
[ 6]) << 12;
2135 l
|= itoa64_to_int (buf
[ 7]) << 18;
2137 digest
[ 3] = (l
>> 0) & 0xff;
2138 digest
[ 4] = (l
>> 8) & 0xff;
2139 digest
[ 5] = (l
>> 16) & 0xff;
2141 l
= itoa64_to_int (buf
[ 8]) << 0;
2142 l
|= itoa64_to_int (buf
[ 9]) << 6;
2143 l
|= itoa64_to_int (buf
[10]) << 12;
2144 l
|= itoa64_to_int (buf
[11]) << 18;
2146 digest
[ 6] = (l
>> 0) & 0xff;
2147 digest
[ 7] = (l
>> 8) & 0xff;
2148 digest
[ 8] = (l
>> 16) & 0xff;
2150 l
= itoa64_to_int (buf
[12]) << 0;
2151 l
|= itoa64_to_int (buf
[13]) << 6;
2152 l
|= itoa64_to_int (buf
[14]) << 12;
2153 l
|= itoa64_to_int (buf
[15]) << 18;
2155 digest
[ 9] = (l
>> 0) & 0xff;
2156 digest
[10] = (l
>> 8) & 0xff;
2157 digest
[11] = (l
>> 16) & 0xff;
2159 l
= itoa64_to_int (buf
[16]) << 0;
2160 l
|= itoa64_to_int (buf
[17]) << 6;
2161 l
|= itoa64_to_int (buf
[18]) << 12;
2162 l
|= itoa64_to_int (buf
[19]) << 18;
2164 digest
[12] = (l
>> 0) & 0xff;
2165 digest
[13] = (l
>> 8) & 0xff;
2166 digest
[14] = (l
>> 16) & 0xff;
2168 l
= itoa64_to_int (buf
[20]) << 0;
2169 l
|= itoa64_to_int (buf
[21]) << 6;
2170 l
|= itoa64_to_int (buf
[22]) << 12;
2171 l
|= itoa64_to_int (buf
[23]) << 18;
2173 digest
[15] = (l
>> 0) & 0xff;
2174 digest
[16] = (l
>> 8) & 0xff;
2175 digest
[17] = (l
>> 16) & 0xff;
2177 l
= itoa64_to_int (buf
[24]) << 0;
2178 l
|= itoa64_to_int (buf
[25]) << 6;
2179 l
|= itoa64_to_int (buf
[26]) << 12;
2180 l
|= itoa64_to_int (buf
[27]) << 18;
2182 digest
[18] = (l
>> 0) & 0xff;
2183 digest
[19] = (l
>> 8) & 0xff;
2184 digest
[20] = (l
>> 16) & 0xff;
2186 l
= itoa64_to_int (buf
[28]) << 0;
2187 l
|= itoa64_to_int (buf
[29]) << 6;
2188 l
|= itoa64_to_int (buf
[30]) << 12;
2189 l
|= itoa64_to_int (buf
[31]) << 18;
2191 digest
[21] = (l
>> 0) & 0xff;
2192 digest
[22] = (l
>> 8) & 0xff;
2193 digest
[23] = (l
>> 16) & 0xff;
2195 l
= itoa64_to_int (buf
[32]) << 0;
2196 l
|= itoa64_to_int (buf
[33]) << 6;
2197 l
|= itoa64_to_int (buf
[34]) << 12;
2198 l
|= itoa64_to_int (buf
[35]) << 18;
2200 digest
[24] = (l
>> 0) & 0xff;
2201 digest
[25] = (l
>> 8) & 0xff;
2202 digest
[26] = (l
>> 16) & 0xff;
2204 l
= itoa64_to_int (buf
[36]) << 0;
2205 l
|= itoa64_to_int (buf
[37]) << 6;
2206 l
|= itoa64_to_int (buf
[38]) << 12;
2207 l
|= itoa64_to_int (buf
[39]) << 18;
2209 digest
[27] = (l
>> 0) & 0xff;
2210 digest
[28] = (l
>> 8) & 0xff;
2211 digest
[29] = (l
>> 16) & 0xff;
2213 l
= itoa64_to_int (buf
[40]) << 0;
2214 l
|= itoa64_to_int (buf
[41]) << 6;
2215 l
|= itoa64_to_int (buf
[42]) << 12;
2216 l
|= itoa64_to_int (buf
[43]) << 18;
2218 digest
[30] = (l
>> 0) & 0xff;
2219 digest
[31] = (l
>> 8) & 0xff;
2220 digest
[32] = (l
>> 16) & 0xff;
2255 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2259 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2261 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2262 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2263 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2266 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2268 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2269 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2270 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2273 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2275 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2276 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2277 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[11] = int_to_itoa64 (l
& 0x3f);
2280 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2282 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2283 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2284 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[15] = int_to_itoa64 (l
& 0x3f);
2287 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2289 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2290 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2291 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[19] = int_to_itoa64 (l
& 0x3f);
2294 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2296 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2297 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2298 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[23] = int_to_itoa64 (l
& 0x3f);
2301 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2303 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2304 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2305 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[27] = int_to_itoa64 (l
& 0x3f);
2308 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2310 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2311 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2312 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[31] = int_to_itoa64 (l
& 0x3f);
2315 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2317 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2318 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2319 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2320 buf
[35] = int_to_itoa64 (l
& 0x3f);
2322 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2324 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2325 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2326 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2327 buf
[39] = int_to_itoa64 (l
& 0x3f);
2329 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2331 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2332 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2333 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2334 //buf[43] = int_to_itoa64 (l & 0x3f);
2342 static struct termios savemodes
;
2343 static int havemodes
= 0;
2347 struct termios modmodes
;
2349 if (tcgetattr (fileno (stdin
), &savemodes
) < 0) return -1;
2353 modmodes
= savemodes
;
2354 modmodes
.c_lflag
&= ~ICANON
;
2355 modmodes
.c_cc
[VMIN
] = 1;
2356 modmodes
.c_cc
[VTIME
] = 0;
2358 return tcsetattr (fileno (stdin
), TCSANOW
, &modmodes
);
2367 FD_SET (fileno (stdin
), &rfds
);
2374 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2376 if (retval
== 0) return 0;
2377 if (retval
== -1) return -1;
2384 if (!havemodes
) return 0;
2386 return tcsetattr (fileno (stdin
), TCSADRAIN
, &savemodes
);
2390 #if defined(DARWIN) || defined(__FreeBSD__)
2391 static struct termios savemodes
;
2392 static int havemodes
= 0;
2396 struct termios modmodes
;
2398 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2402 modmodes
= savemodes
;
2403 modmodes
.c_lflag
&= ~ICANON
;
2404 modmodes
.c_cc
[VMIN
] = 1;
2405 modmodes
.c_cc
[VTIME
] = 0;
2407 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2416 FD_SET (fileno (stdin
), &rfds
);
2423 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2425 if (retval
== 0) return 0;
2426 if (retval
== -1) return -1;
2433 if (!havemodes
) return 0;
2435 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2440 static DWORD saveMode
= 0;
2444 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2446 GetConsoleMode (stdinHandle
, &saveMode
);
2447 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2454 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2456 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2458 if (rc
== WAIT_TIMEOUT
) return 0;
2459 if (rc
== WAIT_ABANDONED
) return -1;
2460 if (rc
== WAIT_FAILED
) return -1;
2462 // The whole ReadConsoleInput () part is a workaround.
2463 // For some unknown reason, maybe a mingw bug, a random signal
2464 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2465 // Then it wants to read with getche () a keyboard input
2466 // which has never been made.
2468 INPUT_RECORD buf
[100];
2472 memset (buf
, 0, sizeof (buf
));
2474 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2476 FlushConsoleInputBuffer (stdinHandle
);
2478 for (uint i
= 0; i
< num
; i
++)
2480 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2482 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2484 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2486 return KeyEvent
.uChar
.AsciiChar
;
2494 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2496 SetConsoleMode (stdinHandle
, saveMode
);
2506 #define MSG_ENOMEM "Insufficient memory available"
2508 void *mycalloc (size_t nmemb
, size_t size
)
2510 void *p
= calloc (nmemb
, size
);
2514 log_error ("ERROR: %s", MSG_ENOMEM
);
2522 void *mymalloc (size_t size
)
2524 void *p
= malloc (size
);
2528 log_error ("ERROR: %s", MSG_ENOMEM
);
2533 memset (p
, 0, size
);
2538 void myfree (void *ptr
)
2540 if (ptr
== NULL
) return;
2545 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2547 void *p
= realloc (ptr
, oldsz
+ add
);
2551 log_error ("ERROR: %s", MSG_ENOMEM
);
2556 memset ((char *) p
+ oldsz
, 0, add
);
2561 char *mystrdup (const char *s
)
2563 const size_t len
= strlen (s
);
2565 char *b
= (char *) mymalloc (len
+ 1);
2572 FILE *logfile_open (char *logfile
)
2574 FILE *fp
= fopen (logfile
, "ab");
2584 void logfile_close (FILE *fp
)
2586 if (fp
== stdout
) return;
2591 void logfile_append (const char *fmt
, ...)
2593 if (data
.logfile_disable
== 1) return;
2595 FILE *fp
= logfile_open (data
.logfile
);
2601 vfprintf (fp
, fmt
, ap
);
2612 int logfile_generate_id ()
2614 const int n
= rand ();
2623 char *logfile_generate_topid ()
2625 const int id
= logfile_generate_id ();
2627 char *topid
= (char *) mymalloc (1 + 16 + 1);
2629 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2634 char *logfile_generate_subid ()
2636 const int id
= logfile_generate_id ();
2638 char *subid
= (char *) mymalloc (1 + 16 + 1);
2640 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2650 void lock_file (FILE *fp
)
2654 memset (&lock
, 0, sizeof (struct flock
));
2656 lock
.l_type
= F_WRLCK
;
2657 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2661 log_error ("ERROR: Failed acquiring write lock: %s", strerror (errno
));
2668 void unlock_file (FILE *fp
)
2672 memset (&lock
, 0, sizeof (struct flock
));
2674 lock
.l_type
= F_UNLCK
;
2675 fcntl(fileno(fp
), F_SETLK
, &lock
);
2682 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2684 FlushFileBuffers (h
);
2694 int get_adapters_num_adl (void *adl
, int *iNumberAdapters
)
2696 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2698 if (iNumberAdapters
== 0)
2700 log_info ("WARN: No ADL adapters found.");
2709 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2711 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2712 ADLODParameters lpOdParameters;
2714 lpOdParameters.iSize = sizeof (ADLODParameters);
2715 size_t plevels_size = 0;
2717 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2719 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2720 __func__, iAdapterIndex,
2721 lpOdParameters.iNumberOfPerformanceLevels,
2722 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2723 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2725 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2727 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2729 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2731 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2733 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2734 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2735 __func__, iAdapterIndex, j,
2736 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2738 myfree (lpOdPerformanceLevels);
2744 LPAdapterInfo
hm_get_adapter_info_adl (void *adl
, int iNumberAdapters
)
2746 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2748 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2750 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2752 return lpAdapterInfo
;
2755 int hm_get_adapter_index_nvapi (HM_ADAPTER_NVAPI nvapiGPUHandle
[DEVICES_MAX
])
2759 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nvapi
, nvapiGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2763 log_info ("WARN: No NvAPI adapters found");
2771 int hm_get_adapter_index_nvml (HM_ADAPTER_NVML nvmlGPUHandle
[DEVICES_MAX
])
2775 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2777 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nvml
, 1, i
, &nvmlGPUHandle
[i
]) != NVML_SUCCESS
) break;
2779 // can be used to determine if the device by index matches the cuda device by index
2780 // char name[100]; memset (name, 0, sizeof (name));
2781 // hm_NVML_nvmlDeviceGetName (data.hm_nvml, nvGPUHandle[i], name, sizeof (name) - 1);
2788 log_info ("WARN: No NVML adapters found");
2798 // does not help at all, since ADL does not assign different bus id, device id when we have multi GPU setups
2801 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2805 for (uint i = 0; i < num_adl_adapters; i++)
2807 int opencl_bus_num = hm_device[i].busid;
2808 int opencl_dev_num = hm_device[i].devid;
2810 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2818 if (idx >= DEVICES_MAX) return -1;
2823 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2825 for (uint i = 0; i < opencl_num_devices; i++)
2827 cl_device_topology_amd device_topology;
2829 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2831 hm_device[i].busid = device_topology.pcie.bus;
2832 hm_device[i].devid = device_topology.pcie.device;
2837 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2839 // basically bubble sort
2841 for (int i
= 0; i
< num_adl_adapters
; i
++)
2843 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2845 // get info of adapter [x]
2847 u32 adapter_index_x
= valid_adl_device_list
[j
];
2848 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2850 u32 bus_num_x
= info_x
.iBusNumber
;
2851 u32 dev_num_x
= info_x
.iDeviceNumber
;
2853 // get info of adapter [y]
2855 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2856 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2858 u32 bus_num_y
= info_y
.iBusNumber
;
2859 u32 dev_num_y
= info_y
.iDeviceNumber
;
2863 if (bus_num_y
< bus_num_x
)
2867 else if (bus_num_y
== bus_num_x
)
2869 if (dev_num_y
< dev_num_x
)
2877 u32 temp
= valid_adl_device_list
[j
+ 1];
2879 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2880 valid_adl_device_list
[j
+ 0] = temp
;
2886 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2888 *num_adl_adapters
= 0;
2890 u32
*adl_adapters
= NULL
;
2892 int *bus_numbers
= NULL
;
2893 int *device_numbers
= NULL
;
2895 for (int i
= 0; i
< iNumberAdapters
; i
++)
2897 AdapterInfo info
= lpAdapterInfo
[i
];
2899 if (strlen (info
.strUDID
) < 1) continue;
2902 if (info
.iVendorID
!= 1002) continue;
2904 if (info
.iVendorID
!= 0x1002) continue;
2907 if (info
.iBusNumber
< 0) continue;
2908 if (info
.iDeviceNumber
< 0) continue;
2912 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2914 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2921 if (found
) continue;
2923 // add it to the list
2925 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2927 adl_adapters
[*num_adl_adapters
] = i
;
2929 // rest is just bookkeeping
2931 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2932 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2934 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2935 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2937 (*num_adl_adapters
)++;
2940 myfree (bus_numbers
);
2941 myfree (device_numbers
);
2943 // sort the list by increasing bus id, device id number
2945 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2947 return adl_adapters
;
2950 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2952 // loop through all valid devices
2954 for (int i
= 0; i
< num_adl_adapters
; i
++)
2956 u32 adapter_index
= valid_adl_device_list
[i
];
2960 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2962 // unfortunately this doesn't work since bus id and dev id are not unique
2963 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2964 // if (opencl_device_index == -1) continue;
2966 int opencl_device_index
= i
;
2968 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2970 // get fanspeed info
2972 if (hm_device
[opencl_device_index
].od_version
== 5)
2974 ADLFanSpeedInfo FanSpeedInfo
;
2976 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2978 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2980 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2982 // check read and write capability in fanspeedinfo
2984 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2985 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2987 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2991 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2994 else // od_version == 6
2996 ADLOD6FanSpeedInfo faninfo
;
2998 memset (&faninfo
, 0, sizeof (faninfo
));
3000 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
3002 // check read capability in fanspeedinfo
3004 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
3006 hm_device
[opencl_device_index
].fan_get_supported
= 1;
3010 hm_device
[opencl_device_index
].fan_get_supported
= 0;
3018 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3020 for (int i
= 0; i
< num_adl_adapters
; i
++)
3022 u32 adapter_index
= valid_adl_device_list
[i
];
3026 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3028 // get overdrive version
3030 int od_supported
= 0;
3034 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3036 // store the overdrive version in hm_device
3038 // unfortunately this doesn't work since bus id and dev id are not unique
3039 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3040 // if (opencl_device_index == -1) continue;
3042 int opencl_device_index
= i
;
3044 hm_device
[opencl_device_index
].od_version
= od_version
;
3050 int hm_get_adapter_index_adl (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3052 for (int i
= 0; i
< num_adl_adapters
; i
++)
3054 u32 adapter_index
= valid_adl_device_list
[i
];
3058 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3060 // store the iAdapterIndex in hm_device
3062 // unfortunately this doesn't work since bus id and dev id are not unique
3063 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3064 // if (opencl_device_index == -1) continue;
3066 int opencl_device_index
= i
;
3068 hm_device
[opencl_device_index
].adl
= info
.iAdapterIndex
;
3071 return num_adl_adapters
;
3074 int hm_get_threshold_slowdown_with_device_id (const uint device_id
)
3076 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3078 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3082 if (data
.hm_device
[device_id
].od_version
== 5)
3086 else if (data
.hm_device
[device_id
].od_version
== 6)
3088 int CurrentValue
= 0;
3089 int DefaultValue
= 0;
3091 if (hm_ADL_Overdrive6_TargetTemperatureData_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &CurrentValue
, &DefaultValue
) != ADL_OK
) return -1;
3093 // the return value has never been tested since hm_ADL_Overdrive6_TargetTemperatureData_Get() never worked on any system. expect problems.
3095 return DefaultValue
;
3100 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3104 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;
3112 int hm_get_threshold_shutdown_with_device_id (const uint device_id
)
3114 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3116 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3120 if (data
.hm_device
[device_id
].od_version
== 5)
3124 else if (data
.hm_device
[device_id
].od_version
== 6)
3131 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3135 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;
3143 int hm_get_temperature_with_device_id (const uint device_id
)
3145 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3147 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3151 if (data
.hm_device
[device_id
].od_version
== 5)
3153 ADLTemperature Temperature
;
3155 Temperature
.iSize
= sizeof (ADLTemperature
);
3157 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &Temperature
) != ADL_OK
) return -1;
3159 return Temperature
.iTemperature
/ 1000;
3161 else if (data
.hm_device
[device_id
].od_version
== 6)
3163 int Temperature
= 0;
3165 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &Temperature
) != ADL_OK
) return -1;
3167 return Temperature
/ 1000;
3172 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3174 int temperature
= 0;
3176 if (hm_NVML_nvmlDeviceGetTemperature (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
) != NVML_SUCCESS
) return -1;
3184 int hm_get_fanpolicy_with_device_id (const uint device_id
)
3186 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3188 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3190 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3194 if (data
.hm_device
[device_id
].od_version
== 5)
3196 ADLFanSpeedValue lpFanSpeedValue
;
3198 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3200 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3201 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3203 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3205 return (lpFanSpeedValue
.iFanSpeed
& ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
) ? 0 : 1;
3207 else // od_version == 6
3214 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3223 int hm_get_fanspeed_with_device_id (const uint device_id
)
3225 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3227 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3229 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3233 if (data
.hm_device
[device_id
].od_version
== 5)
3235 ADLFanSpeedValue lpFanSpeedValue
;
3237 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3239 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3240 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3241 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3243 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3245 return lpFanSpeedValue
.iFanSpeed
;
3247 else // od_version == 6
3249 ADLOD6FanSpeedInfo faninfo
;
3251 memset (&faninfo
, 0, sizeof (faninfo
));
3253 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &faninfo
) != ADL_OK
) return -1;
3255 return faninfo
.iFanSpeedPercent
;
3260 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3264 if (hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nvml
, 0, data
.hm_device
[device_id
].nvml
, (uint
*) &speed
) != NVML_SUCCESS
) return -1;
3273 int hm_get_buslanes_with_device_id (const uint device_id
)
3275 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3277 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3281 ADLPMActivity PMActivity
;
3283 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3285 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3287 return PMActivity
.iCurrentBusLanes
;
3291 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3293 unsigned int currLinkWidth
;
3295 if (hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &currLinkWidth
) != NVML_SUCCESS
) return -1;
3297 return currLinkWidth
;
3303 int hm_get_utilization_with_device_id (const uint device_id
)
3305 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3307 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3311 ADLPMActivity PMActivity
;
3313 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3315 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3317 return PMActivity
.iActivityPercent
;
3321 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3323 nvmlUtilization_t utilization
;
3325 if (hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &utilization
) != NVML_SUCCESS
) return -1;
3327 return utilization
.gpu
;
3333 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3335 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3337 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3341 ADLPMActivity PMActivity
;
3343 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3345 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3347 return PMActivity
.iMemoryClock
/ 100;
3351 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3355 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_MEM
, &clock
) != NVML_SUCCESS
) return -1;
3363 int hm_get_corespeed_with_device_id (const uint device_id
)
3365 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3367 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3371 ADLPMActivity PMActivity
;
3373 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3375 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3377 return PMActivity
.iEngineClock
/ 100;
3381 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3385 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_SM
, &clock
) != NVML_SUCCESS
) return -1;
3393 int hm_get_throttle_with_device_id (const uint device_id
)
3395 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3397 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3402 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3404 unsigned long long clocksThrottleReasons
= 0;
3405 unsigned long long supportedThrottleReasons
= 0;
3407 if (hm_NVML_nvmlDeviceGetCurrentClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &clocksThrottleReasons
) != NVML_SUCCESS
) return -1;
3408 if (hm_NVML_nvmlDeviceGetSupportedClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &supportedThrottleReasons
) != NVML_SUCCESS
) return -1;
3410 clocksThrottleReasons
&= supportedThrottleReasons
;
3411 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonGpuIdle
;
3412 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonApplicationsClocksSetting
;
3413 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonUnknown
;
3415 if (data
.kernel_power_final
)
3417 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonHwSlowdown
;
3420 return (clocksThrottleReasons
!= nvmlClocksThrottleReasonNone
);
3426 int hm_set_fanspeed_with_device_id_adl (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3428 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3434 if (data
.hm_device
[device_id
].od_version
== 5)
3436 ADLFanSpeedValue lpFanSpeedValue
;
3438 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3440 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3441 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3442 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3443 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3445 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3449 else // od_version == 6
3451 ADLOD6FanSpeedValue fan_speed_value
;
3453 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3455 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3456 fan_speed_value
.iFanSpeed
= fanspeed
;
3458 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &fan_speed_value
) != ADL_OK
) return -1;
3465 if (data
.hm_device
[device_id
].od_version
== 5)
3467 if (hm_ADL_Overdrive5_FanSpeedToDefault_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0) != ADL_OK
) return -1;
3471 else // od_version == 6
3473 if (hm_ADL_Overdrive6_FanSpeed_Reset (data
.hm_adl
, data
.hm_device
[device_id
].adl
) != ADL_OK
) return -1;
3484 int hm_set_fanspeed_with_device_id_nvapi (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3486 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3492 NV_GPU_COOLER_LEVELS CoolerLevels
= { 0 };
3494 CoolerLevels
.Version
= GPU_COOLER_LEVELS_VER
| sizeof (NV_GPU_COOLER_LEVELS
);
3496 CoolerLevels
.Levels
[0].Level
= fanspeed
;
3497 CoolerLevels
.Levels
[0].Policy
= 1;
3499 if (hm_NvAPI_GPU_SetCoolerLevels (data
.hm_nvapi
, data
.hm_device
[device_id
].nvapi
, 0, &CoolerLevels
) != NVAPI_OK
) return -1;
3505 if (hm_NvAPI_GPU_RestoreCoolerSettings (data
.hm_nvapi
, data
.hm_device
[device_id
].nvapi
, 0) != NVAPI_OK
) return -1;
3515 int hm_set_fanspeed_with_device_id_xnvctrl (const uint device_id
, const int fanspeed
)
3517 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3519 if (data
.hm_xnvctrl
)
3521 if (set_fan_speed_target (data
.hm_xnvctrl
, data
.hm_device
[device_id
].xnvctrl
, fanspeed
) != 0) return -1;
3530 #endif // HAVE_HWMON
3536 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3538 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3540 if (css_cnt
> SP_PW_MAX
)
3542 log_error ("ERROR: Mask length is too long");
3547 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3549 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3551 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3552 uint cs_len
= css
[css_pos
].cs_len
;
3554 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3556 uint c
= cs_buf
[cs_pos
] & 0xff;
3563 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3565 cs_t
*cs
= &css
[css_cnt
];
3567 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3569 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3573 for (i
= 0; i
< cs
->cs_len
; i
++)
3575 const uint u
= cs
->cs_buf
[i
];
3580 for (i
= 0; i
< in_len
; i
++)
3582 uint u
= in_buf
[i
] & 0xff;
3584 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3586 if (css_uniq
[u
] == 1) continue;
3590 cs
->cs_buf
[cs
->cs_len
] = u
;
3598 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3602 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3604 uint p0
= in_buf
[in_pos
] & 0xff;
3606 if (interpret
== 1 && p0
== '?')
3610 if (in_pos
== in_len
) break;
3612 uint p1
= in_buf
[in_pos
] & 0xff;
3616 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3618 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3620 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3622 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3624 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3626 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3628 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3629 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3631 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3632 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3634 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3635 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3637 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3638 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3640 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3642 default: log_error ("Syntax error: %s", in_buf
);
3648 if (data
.hex_charset
)
3652 if (in_pos
== in_len
)
3654 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3659 uint p1
= in_buf
[in_pos
] & 0xff;
3661 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3663 log_error ("ERROR: Invalid hex character detected in mask %s", in_buf
);
3670 chr
= hex_convert (p1
) << 0;
3671 chr
|= hex_convert (p0
) << 4;
3673 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3679 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3685 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3689 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3691 sum
*= css
[css_pos
].cs_len
;
3697 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3699 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3704 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3706 char p0
= mask_buf
[mask_pos
];
3712 if (mask_pos
== mask_len
) break;
3714 char p1
= mask_buf
[mask_pos
];
3720 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3722 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3724 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3726 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3728 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3730 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3732 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3733 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3735 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3736 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3738 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3739 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3741 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3742 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3744 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3746 default: log_error ("ERROR: Syntax error: %s", mask_buf
);
3752 if (data
.hex_charset
)
3756 // if there is no 2nd hex character, show an error:
3758 if (mask_pos
== mask_len
)
3760 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3765 char p1
= mask_buf
[mask_pos
];
3767 // if they are not valid hex character, show an error:
3769 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3771 log_error ("ERROR: Invalid hex character detected in mask %s", mask_buf
);
3778 chr
|= hex_convert (p1
) << 0;
3779 chr
|= hex_convert (p0
) << 4;
3781 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3787 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3794 log_error ("ERROR: Invalid mask length (0)");
3804 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3806 for (int i
= 0; i
< css_cnt
; i
++)
3808 uint len
= css
[i
].cs_len
;
3809 u64 next
= val
/ len
;
3810 uint pos
= val
% len
;
3811 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3816 void mp_cut_at (char *mask
, uint max
)
3820 uint mask_len
= strlen (mask
);
3822 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3824 if (mask
[i
] == '?') i
++;
3830 void mp_setup_sys (cs_t
*mp_sys
)
3834 uint donec
[CHARSIZ
] = { 0 };
3836 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3837 mp_sys
[0].cs_buf
[pos
++] = chr
;
3838 mp_sys
[0].cs_len
= pos
; }
3840 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3841 mp_sys
[1].cs_buf
[pos
++] = chr
;
3842 mp_sys
[1].cs_len
= pos
; }
3844 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3845 mp_sys
[2].cs_buf
[pos
++] = chr
;
3846 mp_sys
[2].cs_len
= pos
; }
3848 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3849 mp_sys
[3].cs_buf
[pos
++] = chr
;
3850 mp_sys
[3].cs_len
= pos
; }
3852 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3853 mp_sys
[4].cs_len
= pos
; }
3855 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3856 mp_sys
[5].cs_len
= pos
; }
3859 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3861 FILE *fp
= fopen (buf
, "rb");
3863 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3865 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3869 char mp_file
[1024] = { 0 };
3871 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3875 len
= in_superchop (mp_file
);
3879 log_info ("WARNING: Charset file corrupted");
3881 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3885 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3890 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3892 mp_usr
[index
].cs_len
= 0;
3894 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3897 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3899 char *new_mask_buf
= (char *) mymalloc (256);
3905 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3907 if (css_pos
== len
) break;
3909 char p0
= mask_buf
[mask_pos
];
3911 new_mask_buf
[mask_pos
] = p0
;
3917 if (mask_pos
== mask_len
) break;
3919 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3923 if (data
.hex_charset
)
3927 if (mask_pos
== mask_len
)
3929 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3934 char p1
= mask_buf
[mask_pos
];
3936 // if they are not valid hex character, show an error:
3938 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3940 log_error ("ERROR: Invalid hex character detected in mask: %s", mask_buf
);
3945 new_mask_buf
[mask_pos
] = p1
;
3950 if (css_pos
== len
) return (new_mask_buf
);
3952 myfree (new_mask_buf
);
3961 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3967 for (i
= start
; i
< stop
; i
++)
3969 sum
*= root_css_buf
[i
].cs_len
;
3975 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3979 cs_t
*cs
= &root_css_buf
[start
];
3983 for (i
= start
; i
< stop
; i
++)
3985 const u64 m
= v
% cs
->cs_len
;
3986 const u64 d
= v
/ cs
->cs_len
;
3990 const uint k
= cs
->cs_buf
[m
];
3992 pw_buf
[i
- start
] = (char) k
;
3994 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3998 int sp_comp_val (const void *p1
, const void *p2
)
4000 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
4001 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
4003 return b2
->val
- b1
->val
;
4006 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
)
4013 * Initialize hcstats
4016 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
4018 u64
*root_stats_ptr
= root_stats_buf
;
4020 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
4022 for (i
= 0; i
< SP_PW_MAX
; i
++)
4024 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
4026 root_stats_ptr
+= CHARSIZ
;
4029 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
4031 u64
*markov_stats_ptr
= markov_stats_buf
;
4033 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4035 for (i
= 0; i
< SP_PW_MAX
; i
++)
4037 for (j
= 0; j
< CHARSIZ
; j
++)
4039 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
4041 markov_stats_ptr
+= CHARSIZ
;
4051 char hcstat_tmp
[256] = { 0 };
4053 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
4055 hcstat
= hcstat_tmp
;
4058 FILE *fd
= fopen (hcstat
, "rb");
4062 log_error ("%s: %s", hcstat
, strerror (errno
));
4067 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
4069 log_error ("%s: Could not load data", hcstat
);
4076 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
4078 log_error ("%s: Could not load data", hcstat
);
4088 * Markov modifier of hcstat_table on user request
4093 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4094 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4099 /* Add all stats to first position */
4101 for (i
= 1; i
< SP_PW_MAX
; i
++)
4103 u64
*out
= root_stats_buf_by_pos
[0];
4104 u64
*in
= root_stats_buf_by_pos
[i
];
4106 for (j
= 0; j
< CHARSIZ
; j
++)
4112 for (i
= 1; i
< SP_PW_MAX
; i
++)
4114 u64
*out
= markov_stats_buf_by_key
[0][0];
4115 u64
*in
= markov_stats_buf_by_key
[i
][0];
4117 for (j
= 0; j
< CHARSIZ
; j
++)
4119 for (k
= 0; k
< CHARSIZ
; k
++)
4126 /* copy them to all pw_positions */
4128 for (i
= 1; i
< SP_PW_MAX
; i
++)
4130 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4133 for (i
= 1; i
< SP_PW_MAX
; i
++)
4135 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4143 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4145 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4147 for (i
= 0; i
< SP_PW_MAX
; i
++)
4149 root_table_buf_by_pos
[i
] = root_table_ptr
;
4151 root_table_ptr
+= CHARSIZ
;
4154 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4156 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4158 for (i
= 0; i
< SP_PW_MAX
; i
++)
4160 for (j
= 0; j
< CHARSIZ
; j
++)
4162 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4164 markov_table_ptr
+= CHARSIZ
;
4169 * Convert hcstat to tables
4172 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4174 uint key
= i
% CHARSIZ
;
4176 root_table_buf
[i
].key
= key
;
4177 root_table_buf
[i
].val
= root_stats_buf
[i
];
4180 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4182 uint key
= i
% CHARSIZ
;
4184 markov_table_buf
[i
].key
= key
;
4185 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4188 myfree (root_stats_buf
);
4189 myfree (markov_stats_buf
);
4195 for (i
= 0; i
< SP_PW_MAX
; i
++)
4197 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4200 for (i
= 0; i
< SP_PW_MAX
; i
++)
4202 for (j
= 0; j
< CHARSIZ
; j
++)
4204 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4209 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
])
4212 * Convert tables to css
4215 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4217 uint pw_pos
= i
/ CHARSIZ
;
4219 cs_t
*cs
= &root_css_buf
[pw_pos
];
4221 if (cs
->cs_len
== threshold
) continue;
4223 uint key
= root_table_buf
[i
].key
;
4225 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4227 cs
->cs_buf
[cs
->cs_len
] = key
;
4233 * Convert table to css
4236 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4238 uint c
= i
/ CHARSIZ
;
4240 cs_t
*cs
= &markov_css_buf
[c
];
4242 if (cs
->cs_len
== threshold
) continue;
4244 uint pw_pos
= c
/ CHARSIZ
;
4246 uint key
= markov_table_buf
[i
].key
;
4248 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4250 cs
->cs_buf
[cs
->cs_len
] = key
;
4256 for (uint i = 0; i < 8; i++)
4258 for (uint j = 0x20; j < 0x80; j++)
4260 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4262 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4264 for (uint k = 0; k < 10; k++)
4266 printf (" %u\n", ptr->cs_buf[k]);
4273 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4275 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4277 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4287 for (uint j
= 1; j
< CHARSIZ
; j
++)
4297 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4299 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4301 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4303 out
+= CHARSIZ
* CHARSIZ
;
4304 in
+= CHARSIZ
* CHARSIZ
;
4306 for (uint j
= 0; j
< CHARSIZ
; j
++)
4313 for (uint k
= 1; k
< CHARSIZ
; k
++)
4325 * mixed shared functions
4328 void dump_hex (const u8
*s
, const int sz
)
4330 for (int i
= 0; i
< sz
; i
++)
4332 log_info_nn ("%02x ", s
[i
]);
4338 void usage_mini_print (const char *progname
)
4340 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4343 void usage_big_print (const char *progname
)
4345 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4348 char *get_exec_path ()
4350 int exec_path_len
= 1024;
4352 char *exec_path
= (char *) mymalloc (exec_path_len
);
4356 char tmp
[32] = { 0 };
4358 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4360 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4364 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4368 uint size
= exec_path_len
;
4370 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4372 log_error("! executable path buffer too small\n");
4377 const int len
= strlen (exec_path
);
4381 #include <sys/sysctl.h>
4386 mib
[2] = KERN_PROC_PATHNAME
;
4389 char tmp
[32] = { 0 };
4391 size_t size
= exec_path_len
;
4392 sysctl(mib
, 4, exec_path
, &size
, NULL
, 0);
4394 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4397 #error Your Operating System is not supported or detected
4405 char *get_install_dir (const char *progname
)
4407 char *install_dir
= mystrdup (progname
);
4408 char *last_slash
= NULL
;
4410 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4414 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4420 install_dir
[0] = '.';
4424 return (install_dir
);
4427 char *get_profile_dir (const char *homedir
)
4429 #define DOT_HASHCAT ".hashcat"
4431 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4433 char *profile_dir
= (char *) mymalloc (len
+ 1);
4435 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4440 char *get_session_dir (const char *profile_dir
)
4442 #define SESSIONS_FOLDER "sessions"
4444 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4446 char *session_dir
= (char *) mymalloc (len
+ 1);
4448 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4453 uint
count_lines (FILE *fd
)
4457 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4463 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4465 if (nread
< 1) continue;
4469 for (i
= 0; i
< nread
; i
++)
4471 if (prev
== '\n') cnt
++;
4482 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4486 FILE *fd
= fopen (filename
, "rb");
4490 log_error ("%s: %s", filename
, strerror (errno
));
4495 #define MAX_KEY_SIZE (1024 * 1024)
4497 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4499 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4505 for (int fpos
= 0; fpos
< nread
; fpos
++)
4507 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4509 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4510 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4511 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4512 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4514 if (kpos
>= 64) kpos
= 0;
4521 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4525 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4526 if (CPU_ISSET(core
, cpu_set
)) break;
4528 thread_affinity_policy_data_t policy
= { core
};
4530 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4532 if (data
.quiet
== 0)
4534 if (rc
!= KERN_SUCCESS
)
4536 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4544 void set_cpu_affinity (char *cpu_affinity
)
4547 DWORD_PTR aff_mask
= 0;
4558 char *devices
= strdup (cpu_affinity
);
4560 char *next
= strtok (devices
, ",");
4564 uint cpu_id
= atoi (next
);
4579 log_error ("ERROR: Invalid cpu_id %u specified", cpu_id
);
4585 aff_mask
|= 1 << (cpu_id
- 1);
4587 CPU_SET ((cpu_id
- 1), &cpuset
);
4590 } while ((next
= strtok (NULL
, ",")) != NULL
);
4596 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4597 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4599 pthread_t thread
= pthread_self ();
4600 pthread_setaffinity_np (thread
, sizeof (cpuset_t
), &cpuset
);
4602 pthread_t thread
= pthread_self ();
4603 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4607 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4609 char *element
, *end
;
4611 end
= (char *) base
+ nmemb
* size
;
4613 for (element
= (char *) base
; element
< end
; element
+= size
)
4614 if (!compar (element
, key
))
4620 int sort_by_u32 (const void *v1
, const void *v2
)
4622 const u32
*s1
= (const u32
*) v1
;
4623 const u32
*s2
= (const u32
*) v2
;
4628 int sort_by_salt (const void *v1
, const void *v2
)
4630 const salt_t
*s1
= (const salt_t
*) v1
;
4631 const salt_t
*s2
= (const salt_t
*) v2
;
4633 const int res1
= s1
->salt_len
- s2
->salt_len
;
4635 if (res1
!= 0) return (res1
);
4637 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4639 if (res2
!= 0) return (res2
);
4647 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4648 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4655 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4656 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4662 int sort_by_salt_buf (const void *v1
, const void *v2
)
4664 const pot_t
*p1
= (const pot_t
*) v1
;
4665 const pot_t
*p2
= (const pot_t
*) v2
;
4667 const hash_t
*h1
= &p1
->hash
;
4668 const hash_t
*h2
= &p2
->hash
;
4670 const salt_t
*s1
= h1
->salt
;
4671 const salt_t
*s2
= h2
->salt
;
4677 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4678 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4684 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4686 const hash_t
*h1
= (const hash_t
*) v1
;
4687 const hash_t
*h2
= (const hash_t
*) v2
;
4689 const salt_t
*s1
= h1
->salt
;
4690 const salt_t
*s2
= h2
->salt
;
4692 // testphase: this should work
4697 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4698 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4701 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4702 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4703 if (s1->salt_len > s2->salt_len) return ( 1);
4704 if (s1->salt_len < s2->salt_len) return (-1);
4706 uint n = s1->salt_len;
4710 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4711 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4718 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4720 const hash_t
*h1
= (const hash_t
*) v1
;
4721 const hash_t
*h2
= (const hash_t
*) v2
;
4723 const salt_t
*s1
= h1
->salt
;
4724 const salt_t
*s2
= h2
->salt
;
4726 // last 2: salt_buf[10] and salt_buf[11] contain the digest (skip them)
4728 uint n
= 9; // 9 * 4 = 36 bytes (max length of ESSID)
4732 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4733 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4739 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4741 const hash_t
*h1
= (const hash_t
*) v1
;
4742 const hash_t
*h2
= (const hash_t
*) v2
;
4744 const void *d1
= h1
->digest
;
4745 const void *d2
= h2
->digest
;
4747 return data
.sort_by_digest (d1
, d2
);
4750 int sort_by_hash (const void *v1
, const void *v2
)
4752 const hash_t
*h1
= (const hash_t
*) v1
;
4753 const hash_t
*h2
= (const hash_t
*) v2
;
4757 const salt_t
*s1
= h1
->salt
;
4758 const salt_t
*s2
= h2
->salt
;
4760 int res
= sort_by_salt (s1
, s2
);
4762 if (res
!= 0) return (res
);
4765 const void *d1
= h1
->digest
;
4766 const void *d2
= h2
->digest
;
4768 return data
.sort_by_digest (d1
, d2
);
4771 int sort_by_pot (const void *v1
, const void *v2
)
4773 const pot_t
*p1
= (const pot_t
*) v1
;
4774 const pot_t
*p2
= (const pot_t
*) v2
;
4776 const hash_t
*h1
= &p1
->hash
;
4777 const hash_t
*h2
= &p2
->hash
;
4779 return sort_by_hash (h1
, h2
);
4782 int sort_by_mtime (const void *p1
, const void *p2
)
4784 const char **f1
= (const char **) p1
;
4785 const char **f2
= (const char **) p2
;
4787 struct stat s1
; stat (*f1
, &s1
);
4788 struct stat s2
; stat (*f2
, &s2
);
4790 return s2
.st_mtime
- s1
.st_mtime
;
4793 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4795 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4796 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4798 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4801 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4803 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4804 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4806 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4809 int sort_by_stringptr (const void *p1
, const void *p2
)
4811 const char **s1
= (const char **) p1
;
4812 const char **s2
= (const char **) p2
;
4814 return strcmp (*s1
, *s2
);
4817 int sort_by_dictstat (const void *s1
, const void *s2
)
4819 dictstat_t
*d1
= (dictstat_t
*) s1
;
4820 dictstat_t
*d2
= (dictstat_t
*) s2
;
4823 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4825 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4828 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4831 int sort_by_bitmap (const void *p1
, const void *p2
)
4833 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4834 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4836 return b1
->collisions
- b2
->collisions
;
4839 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4841 const u32
*d1
= (const u32
*) v1
;
4842 const u32
*d2
= (const u32
*) v2
;
4848 if (d1
[n
] > d2
[n
]) return ( 1);
4849 if (d1
[n
] < d2
[n
]) return (-1);
4855 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4857 const u32
*d1
= (const u32
*) v1
;
4858 const u32
*d2
= (const u32
*) v2
;
4864 if (d1
[n
] > d2
[n
]) return ( 1);
4865 if (d1
[n
] < d2
[n
]) return (-1);
4871 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4873 const u32
*d1
= (const u32
*) v1
;
4874 const u32
*d2
= (const u32
*) v2
;
4880 if (d1
[n
] > d2
[n
]) return ( 1);
4881 if (d1
[n
] < d2
[n
]) return (-1);
4887 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4889 const u32
*d1
= (const u32
*) v1
;
4890 const u32
*d2
= (const u32
*) v2
;
4896 if (d1
[n
] > d2
[n
]) return ( 1);
4897 if (d1
[n
] < d2
[n
]) return (-1);
4903 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4905 const u32
*d1
= (const u32
*) v1
;
4906 const u32
*d2
= (const u32
*) v2
;
4912 if (d1
[n
] > d2
[n
]) return ( 1);
4913 if (d1
[n
] < d2
[n
]) return (-1);
4919 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4921 const u32
*d1
= (const u32
*) v1
;
4922 const u32
*d2
= (const u32
*) v2
;
4928 if (d1
[n
] > d2
[n
]) return ( 1);
4929 if (d1
[n
] < d2
[n
]) return (-1);
4935 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4937 const u32
*d1
= (const u32
*) v1
;
4938 const u32
*d2
= (const u32
*) v2
;
4944 if (d1
[n
] > d2
[n
]) return ( 1);
4945 if (d1
[n
] < d2
[n
]) return (-1);
4951 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4953 const u32
*d1
= (const u32
*) v1
;
4954 const u32
*d2
= (const u32
*) v2
;
4960 if (d1
[n
] > d2
[n
]) return ( 1);
4961 if (d1
[n
] < d2
[n
]) return (-1);
4967 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4969 const u64
*d1
= (const u64
*) v1
;
4970 const u64
*d2
= (const u64
*) v2
;
4976 if (d1
[n
] > d2
[n
]) return ( 1);
4977 if (d1
[n
] < d2
[n
]) return (-1);
4983 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4985 const u64
*d1
= (const u64
*) v1
;
4986 const u64
*d2
= (const u64
*) v2
;
4992 if (d1
[n
] > d2
[n
]) return ( 1);
4993 if (d1
[n
] < d2
[n
]) return (-1);
4999 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
5001 const u64
*d1
= (const u64
*) v1
;
5002 const u64
*d2
= (const u64
*) v2
;
5008 if (d1
[n
] > d2
[n
]) return ( 1);
5009 if (d1
[n
] < d2
[n
]) return (-1);
5015 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
5017 const u32
*d1
= (const u32
*) v1
;
5018 const u32
*d2
= (const u32
*) v2
;
5020 const uint dgst_pos0
= data
.dgst_pos0
;
5021 const uint dgst_pos1
= data
.dgst_pos1
;
5022 const uint dgst_pos2
= data
.dgst_pos2
;
5023 const uint dgst_pos3
= data
.dgst_pos3
;
5025 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
5026 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
5027 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
5028 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
5029 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
5030 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
5031 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
5032 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
5037 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
5039 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
5040 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
5042 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
5044 if (res1
!= 0) return (res1
);
5049 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
5051 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
5052 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
5054 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
5056 if (res1
!= 0) return (res1
);
5058 const int res2
= t1
->attack_mode
5061 if (res2
!= 0) return (res2
);
5063 const int res3
= t1
->hash_type
5066 if (res3
!= 0) return (res3
);
5071 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
)
5073 uint outfile_autohex
= data
.outfile_autohex
;
5075 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
5077 FILE *debug_fp
= NULL
;
5079 if (debug_file
!= NULL
)
5081 debug_fp
= fopen (debug_file
, "ab");
5083 lock_file (debug_fp
);
5090 if (debug_fp
== NULL
)
5092 log_info ("WARNING: Could not open debug-file for writing");
5096 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
5098 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
5100 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
5103 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
5105 if (debug_mode
== 4)
5107 fputc (':', debug_fp
);
5109 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5112 fputc ('\n', debug_fp
);
5114 if (debug_file
!= NULL
) fclose (debug_fp
);
5118 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5120 int needs_hexify
= 0;
5122 if (outfile_autohex
== 1)
5124 for (uint i
= 0; i
< plain_len
; i
++)
5126 if (plain_ptr
[i
] < 0x20)
5133 if (plain_ptr
[i
] > 0x7f)
5142 if (needs_hexify
== 1)
5144 fprintf (fp
, "$HEX[");
5146 for (uint i
= 0; i
< plain_len
; i
++)
5148 fprintf (fp
, "%02x", plain_ptr
[i
]);
5155 fwrite (plain_ptr
, plain_len
, 1, fp
);
5159 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
)
5161 uint outfile_format
= data
.outfile_format
;
5163 char separator
= data
.separator
;
5165 if (outfile_format
& OUTFILE_FMT_HASH
)
5167 fprintf (out_fp
, "%s", out_buf
);
5169 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5171 fputc (separator
, out_fp
);
5174 else if (data
.username
)
5176 if (username
!= NULL
)
5178 for (uint i
= 0; i
< user_len
; i
++)
5180 fprintf (out_fp
, "%c", username
[i
]);
5183 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5185 fputc (separator
, out_fp
);
5190 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5192 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5194 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5196 fputc (separator
, out_fp
);
5200 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5202 for (uint i
= 0; i
< plain_len
; i
++)
5204 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5207 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5209 fputc (separator
, out_fp
);
5213 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5216 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5221 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5223 fprintf (out_fp
, "%llu", crackpos
);
5228 fputc ('\n', out_fp
);
5231 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
)
5235 pot_key
.hash
.salt
= hashes_buf
->salt
;
5236 pot_key
.hash
.digest
= hashes_buf
->digest
;
5238 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5244 input_buf
[input_len
] = 0;
5247 unsigned char *username
= NULL
;
5252 user_t
*user
= hashes_buf
->hash_info
->user
;
5256 username
= (unsigned char *) (user
->user_name
);
5258 user_len
= user
->user_len
;
5262 // do output the line
5263 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5267 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5268 #define LM_MASKED_PLAIN "[notfound]"
5270 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
)
5276 pot_left_key
.hash
.salt
= hash_left
->salt
;
5277 pot_left_key
.hash
.digest
= hash_left
->digest
;
5279 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5283 uint weak_hash_found
= 0;
5285 pot_t pot_right_key
;
5287 pot_right_key
.hash
.salt
= hash_right
->salt
;
5288 pot_right_key
.hash
.digest
= hash_right
->digest
;
5290 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5292 if (pot_right_ptr
== NULL
)
5294 // special case, if "weak hash"
5296 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5298 weak_hash_found
= 1;
5300 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5302 // in theory this is not needed, but we are paranoia:
5304 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5305 pot_right_ptr
->plain_len
= 0;
5309 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5311 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
5316 // at least one half was found:
5320 input_buf
[input_len
] = 0;
5324 unsigned char *username
= NULL
;
5329 user_t
*user
= hash_left
->hash_info
->user
;
5333 username
= (unsigned char *) (user
->user_name
);
5335 user_len
= user
->user_len
;
5339 // mask the part which was not found
5341 uint left_part_masked
= 0;
5342 uint right_part_masked
= 0;
5344 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5346 if (pot_left_ptr
== NULL
)
5348 left_part_masked
= 1;
5350 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5352 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5354 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5355 pot_left_ptr
->plain_len
= mask_plain_len
;
5358 if (pot_right_ptr
== NULL
)
5360 right_part_masked
= 1;
5362 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5364 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5366 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5367 pot_right_ptr
->plain_len
= mask_plain_len
;
5370 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5374 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5376 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5378 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5380 // do output the line
5382 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5384 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5386 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5387 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5390 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
)
5394 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5396 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5398 if (pot_ptr
== NULL
)
5402 input_buf
[input_len
] = 0;
5404 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5408 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
)
5414 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5416 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5420 pot_t pot_right_key
;
5422 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5424 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5426 uint weak_hash_found
= 0;
5428 if (pot_right_ptr
== NULL
)
5430 // special case, if "weak hash"
5432 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5434 weak_hash_found
= 1;
5436 // we just need that pot_right_ptr is not a NULL pointer
5438 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5442 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5444 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5449 // ... at least one part was not cracked
5453 input_buf
[input_len
] = 0;
5455 // only show the hash part which is still not cracked
5457 uint user_len
= input_len
- 32;
5459 char *hash_output
= (char *) mymalloc (33);
5461 memcpy (hash_output
, input_buf
, input_len
);
5463 if (pot_left_ptr
!= NULL
)
5465 // only show right part (because left part was already found)
5467 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5469 hash_output
[user_len
+ 16] = 0;
5472 if (pot_right_ptr
!= NULL
)
5474 // only show left part (because right part was already found)
5476 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5478 hash_output
[user_len
+ 16] = 0;
5481 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5483 myfree (hash_output
);
5485 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5488 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5490 uint opencl_platforms_filter
= 0;
5492 if (opencl_platforms
)
5494 char *platforms
= strdup (opencl_platforms
);
5496 char *next
= strtok (platforms
, ",");
5500 int platform
= atoi (next
);
5502 if (platform
< 1 || platform
> 32)
5504 log_error ("ERROR: Invalid OpenCL platform %u specified", platform
);
5509 opencl_platforms_filter
|= 1 << (platform
- 1);
5511 } while ((next
= strtok (NULL
, ",")) != NULL
);
5517 opencl_platforms_filter
= -1;
5520 return opencl_platforms_filter
;
5523 u32
setup_devices_filter (char *opencl_devices
)
5525 u32 devices_filter
= 0;
5529 char *devices
= strdup (opencl_devices
);
5531 char *next
= strtok (devices
, ",");
5535 int device_id
= atoi (next
);
5537 if (device_id
< 1 || device_id
> 32)
5539 log_error ("ERROR: Invalid device_id %u specified", device_id
);
5544 devices_filter
|= 1 << (device_id
- 1);
5546 } while ((next
= strtok (NULL
, ",")) != NULL
);
5552 devices_filter
= -1;
5555 return devices_filter
;
5558 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5560 cl_device_type device_types_filter
= 0;
5562 if (opencl_device_types
)
5564 char *device_types
= strdup (opencl_device_types
);
5566 char *next
= strtok (device_types
, ",");
5570 int device_type
= atoi (next
);
5572 if (device_type
< 1 || device_type
> 3)
5574 log_error ("ERROR: Invalid device_type %u specified", device_type
);
5579 device_types_filter
|= 1 << device_type
;
5581 } while ((next
= strtok (NULL
, ",")) != NULL
);
5583 free (device_types
);
5587 // Do not use CPU by default, this often reduces GPU performance because
5588 // the CPU is too busy to handle GPU synchronization
5590 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5593 return device_types_filter
;
5596 u32
get_random_num (const u32 min
, const u32 max
)
5598 if (min
== max
) return (min
);
5600 return ((rand () % (max
- min
)) + min
);
5603 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5605 u32 quotient
= dividend
/ divisor
;
5607 if (dividend
% divisor
) quotient
++;
5612 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5614 u64 quotient
= dividend
/ divisor
;
5616 if (dividend
% divisor
) quotient
++;
5621 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5623 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5624 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5626 if (tm
->tm_year
- 70)
5628 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5629 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5631 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5633 else if (tm
->tm_yday
)
5635 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5636 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5638 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5640 else if (tm
->tm_hour
)
5642 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5643 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5645 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5647 else if (tm
->tm_min
)
5649 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5650 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5652 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5656 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5658 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5662 void format_speed_display (float val
, char *buf
, size_t len
)
5673 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5684 /* generate output */
5688 snprintf (buf
, len
- 1, "%.0f ", val
);
5692 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5696 void lowercase (u8
*buf
, int len
)
5698 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5701 void uppercase (u8
*buf
, int len
)
5703 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5706 int fgetl (FILE *fp
, char *line_buf
)
5712 const int c
= fgetc (fp
);
5714 if (c
== EOF
) break;
5716 line_buf
[line_len
] = (char) c
;
5720 if (line_len
== HCBUFSIZ
) line_len
--;
5722 if (c
== '\n') break;
5725 if (line_len
== 0) return 0;
5727 if (line_buf
[line_len
- 1] == '\n')
5731 line_buf
[line_len
] = 0;
5734 if (line_len
== 0) return 0;
5736 if (line_buf
[line_len
- 1] == '\r')
5740 line_buf
[line_len
] = 0;
5746 int in_superchop (char *buf
)
5748 int len
= strlen (buf
);
5752 if (buf
[len
- 1] == '\n')
5759 if (buf
[len
- 1] == '\r')
5774 char **scan_directory (const char *path
)
5776 char *tmp_path
= mystrdup (path
);
5778 size_t tmp_path_len
= strlen (tmp_path
);
5780 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5782 tmp_path
[tmp_path_len
- 1] = 0;
5784 tmp_path_len
= strlen (tmp_path
);
5787 char **files
= NULL
;
5793 if ((d
= opendir (tmp_path
)) != NULL
)
5799 memset (&e
, 0, sizeof (e
));
5800 struct dirent
*de
= NULL
;
5802 if (readdir_r (d
, &e
, &de
) != 0)
5804 log_error ("ERROR: readdir_r() failed");
5809 if (de
== NULL
) break;
5813 while ((de
= readdir (d
)) != NULL
)
5816 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5818 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5820 char *path_file
= (char *) mymalloc (path_size
+ 1);
5822 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5824 path_file
[path_size
] = 0;
5828 if ((d_test
= opendir (path_file
)) != NULL
)
5836 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5840 files
[num_files
- 1] = path_file
;
5846 else if (errno
== ENOTDIR
)
5848 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5852 files
[num_files
- 1] = mystrdup (path
);
5855 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5859 files
[num_files
- 1] = NULL
;
5866 int count_dictionaries (char **dictionary_files
)
5868 if (dictionary_files
== NULL
) return 0;
5872 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5880 char *stroptitype (const uint opti_type
)
5884 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5885 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5886 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5887 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5888 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5889 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5890 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5891 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5892 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5893 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5894 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5895 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5896 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5897 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5898 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5899 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5900 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5901 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5902 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5908 char *strparser (const uint parser_status
)
5910 switch (parser_status
)
5912 case PARSER_OK
: return ((char *) PA_000
); break;
5913 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5914 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5915 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5916 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5917 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5918 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5919 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5920 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5921 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5922 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5923 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5924 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5925 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5926 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5927 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5928 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5931 return ((char *) PA_255
);
5934 char *strhashtype (const uint hash_mode
)
5938 case 0: return ((char *) HT_00000
); break;
5939 case 10: return ((char *) HT_00010
); break;
5940 case 11: return ((char *) HT_00011
); break;
5941 case 12: return ((char *) HT_00012
); break;
5942 case 20: return ((char *) HT_00020
); break;
5943 case 21: return ((char *) HT_00021
); break;
5944 case 22: return ((char *) HT_00022
); break;
5945 case 23: return ((char *) HT_00023
); break;
5946 case 30: return ((char *) HT_00030
); break;
5947 case 40: return ((char *) HT_00040
); break;
5948 case 50: return ((char *) HT_00050
); break;
5949 case 60: return ((char *) HT_00060
); break;
5950 case 100: return ((char *) HT_00100
); break;
5951 case 101: return ((char *) HT_00101
); break;
5952 case 110: return ((char *) HT_00110
); break;
5953 case 111: return ((char *) HT_00111
); break;
5954 case 112: return ((char *) HT_00112
); break;
5955 case 120: return ((char *) HT_00120
); break;
5956 case 121: return ((char *) HT_00121
); break;
5957 case 122: return ((char *) HT_00122
); break;
5958 case 124: return ((char *) HT_00124
); break;
5959 case 125: return ((char *) HT_00125
); break;
5960 case 130: return ((char *) HT_00130
); break;
5961 case 131: return ((char *) HT_00131
); break;
5962 case 132: return ((char *) HT_00132
); break;
5963 case 133: return ((char *) HT_00133
); break;
5964 case 140: return ((char *) HT_00140
); break;
5965 case 141: return ((char *) HT_00141
); break;
5966 case 150: return ((char *) HT_00150
); break;
5967 case 160: return ((char *) HT_00160
); break;
5968 case 200: return ((char *) HT_00200
); break;
5969 case 300: return ((char *) HT_00300
); break;
5970 case 400: return ((char *) HT_00400
); break;
5971 case 500: return ((char *) HT_00500
); break;
5972 case 501: return ((char *) HT_00501
); break;
5973 case 900: return ((char *) HT_00900
); break;
5974 case 910: return ((char *) HT_00910
); break;
5975 case 1000: return ((char *) HT_01000
); break;
5976 case 1100: return ((char *) HT_01100
); break;
5977 case 1400: return ((char *) HT_01400
); break;
5978 case 1410: return ((char *) HT_01410
); break;
5979 case 1420: return ((char *) HT_01420
); break;
5980 case 1421: return ((char *) HT_01421
); break;
5981 case 1430: return ((char *) HT_01430
); break;
5982 case 1440: return ((char *) HT_01440
); break;
5983 case 1441: return ((char *) HT_01441
); break;
5984 case 1450: return ((char *) HT_01450
); break;
5985 case 1460: return ((char *) HT_01460
); break;
5986 case 1500: return ((char *) HT_01500
); break;
5987 case 1600: return ((char *) HT_01600
); break;
5988 case 1700: return ((char *) HT_01700
); break;
5989 case 1710: return ((char *) HT_01710
); break;
5990 case 1711: return ((char *) HT_01711
); break;
5991 case 1720: return ((char *) HT_01720
); break;
5992 case 1722: return ((char *) HT_01722
); break;
5993 case 1730: return ((char *) HT_01730
); break;
5994 case 1731: return ((char *) HT_01731
); break;
5995 case 1740: return ((char *) HT_01740
); break;
5996 case 1750: return ((char *) HT_01750
); break;
5997 case 1760: return ((char *) HT_01760
); break;
5998 case 1800: return ((char *) HT_01800
); break;
5999 case 2100: return ((char *) HT_02100
); break;
6000 case 2400: return ((char *) HT_02400
); break;
6001 case 2410: return ((char *) HT_02410
); break;
6002 case 2500: return ((char *) HT_02500
); break;
6003 case 2600: return ((char *) HT_02600
); break;
6004 case 2611: return ((char *) HT_02611
); break;
6005 case 2612: return ((char *) HT_02612
); break;
6006 case 2711: return ((char *) HT_02711
); break;
6007 case 2811: return ((char *) HT_02811
); break;
6008 case 3000: return ((char *) HT_03000
); break;
6009 case 3100: return ((char *) HT_03100
); break;
6010 case 3200: return ((char *) HT_03200
); break;
6011 case 3710: return ((char *) HT_03710
); break;
6012 case 3711: return ((char *) HT_03711
); break;
6013 case 3800: return ((char *) HT_03800
); break;
6014 case 4300: return ((char *) HT_04300
); break;
6015 case 4400: return ((char *) HT_04400
); break;
6016 case 4500: return ((char *) HT_04500
); break;
6017 case 4700: return ((char *) HT_04700
); break;
6018 case 4800: return ((char *) HT_04800
); break;
6019 case 4900: return ((char *) HT_04900
); break;
6020 case 5000: return ((char *) HT_05000
); break;
6021 case 5100: return ((char *) HT_05100
); break;
6022 case 5200: return ((char *) HT_05200
); break;
6023 case 5300: return ((char *) HT_05300
); break;
6024 case 5400: return ((char *) HT_05400
); break;
6025 case 5500: return ((char *) HT_05500
); break;
6026 case 5600: return ((char *) HT_05600
); break;
6027 case 5700: return ((char *) HT_05700
); break;
6028 case 5800: return ((char *) HT_05800
); break;
6029 case 6000: return ((char *) HT_06000
); break;
6030 case 6100: return ((char *) HT_06100
); break;
6031 case 6211: return ((char *) HT_06211
); break;
6032 case 6212: return ((char *) HT_06212
); break;
6033 case 6213: return ((char *) HT_06213
); break;
6034 case 6221: return ((char *) HT_06221
); break;
6035 case 6222: return ((char *) HT_06222
); break;
6036 case 6223: return ((char *) HT_06223
); break;
6037 case 6231: return ((char *) HT_06231
); break;
6038 case 6232: return ((char *) HT_06232
); break;
6039 case 6233: return ((char *) HT_06233
); break;
6040 case 6241: return ((char *) HT_06241
); break;
6041 case 6242: return ((char *) HT_06242
); break;
6042 case 6243: return ((char *) HT_06243
); break;
6043 case 6300: return ((char *) HT_06300
); break;
6044 case 6400: return ((char *) HT_06400
); break;
6045 case 6500: return ((char *) HT_06500
); break;
6046 case 6600: return ((char *) HT_06600
); break;
6047 case 6700: return ((char *) HT_06700
); break;
6048 case 6800: return ((char *) HT_06800
); break;
6049 case 6900: return ((char *) HT_06900
); break;
6050 case 7100: return ((char *) HT_07100
); break;
6051 case 7200: return ((char *) HT_07200
); break;
6052 case 7300: return ((char *) HT_07300
); break;
6053 case 7400: return ((char *) HT_07400
); break;
6054 case 7500: return ((char *) HT_07500
); break;
6055 case 7600: return ((char *) HT_07600
); break;
6056 case 7700: return ((char *) HT_07700
); break;
6057 case 7800: return ((char *) HT_07800
); break;
6058 case 7900: return ((char *) HT_07900
); break;
6059 case 8000: return ((char *) HT_08000
); break;
6060 case 8100: return ((char *) HT_08100
); break;
6061 case 8200: return ((char *) HT_08200
); break;
6062 case 8300: return ((char *) HT_08300
); break;
6063 case 8400: return ((char *) HT_08400
); break;
6064 case 8500: return ((char *) HT_08500
); break;
6065 case 8600: return ((char *) HT_08600
); break;
6066 case 8700: return ((char *) HT_08700
); break;
6067 case 8800: return ((char *) HT_08800
); break;
6068 case 8900: return ((char *) HT_08900
); break;
6069 case 9000: return ((char *) HT_09000
); break;
6070 case 9100: return ((char *) HT_09100
); break;
6071 case 9200: return ((char *) HT_09200
); break;
6072 case 9300: return ((char *) HT_09300
); break;
6073 case 9400: return ((char *) HT_09400
); break;
6074 case 9500: return ((char *) HT_09500
); break;
6075 case 9600: return ((char *) HT_09600
); break;
6076 case 9700: return ((char *) HT_09700
); break;
6077 case 9710: return ((char *) HT_09710
); break;
6078 case 9720: return ((char *) HT_09720
); break;
6079 case 9800: return ((char *) HT_09800
); break;
6080 case 9810: return ((char *) HT_09810
); break;
6081 case 9820: return ((char *) HT_09820
); break;
6082 case 9900: return ((char *) HT_09900
); break;
6083 case 10000: return ((char *) HT_10000
); break;
6084 case 10100: return ((char *) HT_10100
); break;
6085 case 10200: return ((char *) HT_10200
); break;
6086 case 10300: return ((char *) HT_10300
); break;
6087 case 10400: return ((char *) HT_10400
); break;
6088 case 10410: return ((char *) HT_10410
); break;
6089 case 10420: return ((char *) HT_10420
); break;
6090 case 10500: return ((char *) HT_10500
); break;
6091 case 10600: return ((char *) HT_10600
); break;
6092 case 10700: return ((char *) HT_10700
); break;
6093 case 10800: return ((char *) HT_10800
); break;
6094 case 10900: return ((char *) HT_10900
); break;
6095 case 11000: return ((char *) HT_11000
); break;
6096 case 11100: return ((char *) HT_11100
); break;
6097 case 11200: return ((char *) HT_11200
); break;
6098 case 11300: return ((char *) HT_11300
); break;
6099 case 11400: return ((char *) HT_11400
); break;
6100 case 11500: return ((char *) HT_11500
); break;
6101 case 11600: return ((char *) HT_11600
); break;
6102 case 11700: return ((char *) HT_11700
); break;
6103 case 11800: return ((char *) HT_11800
); break;
6104 case 11900: return ((char *) HT_11900
); break;
6105 case 12000: return ((char *) HT_12000
); break;
6106 case 12100: return ((char *) HT_12100
); break;
6107 case 12200: return ((char *) HT_12200
); break;
6108 case 12300: return ((char *) HT_12300
); break;
6109 case 12400: return ((char *) HT_12400
); break;
6110 case 12500: return ((char *) HT_12500
); break;
6111 case 12600: return ((char *) HT_12600
); break;
6112 case 12700: return ((char *) HT_12700
); break;
6113 case 12800: return ((char *) HT_12800
); break;
6114 case 12900: return ((char *) HT_12900
); break;
6115 case 13000: return ((char *) HT_13000
); break;
6116 case 13100: return ((char *) HT_13100
); break;
6117 case 13200: return ((char *) HT_13200
); break;
6118 case 13300: return ((char *) HT_13300
); break;
6119 case 13400: return ((char *) HT_13400
); break;
6120 case 13500: return ((char *) HT_13500
); break;
6121 case 13600: return ((char *) HT_13600
); break;
6122 case 13711: return ((char *) HT_13711
); break;
6123 case 13712: return ((char *) HT_13712
); break;
6124 case 13713: return ((char *) HT_13713
); break;
6125 case 13721: return ((char *) HT_13721
); break;
6126 case 13722: return ((char *) HT_13722
); break;
6127 case 13723: return ((char *) HT_13723
); break;
6128 case 13731: return ((char *) HT_13731
); break;
6129 case 13732: return ((char *) HT_13732
); break;
6130 case 13733: return ((char *) HT_13733
); break;
6131 case 13741: return ((char *) HT_13741
); break;
6132 case 13742: return ((char *) HT_13742
); break;
6133 case 13743: return ((char *) HT_13743
); break;
6134 case 13751: return ((char *) HT_13751
); break;
6135 case 13752: return ((char *) HT_13752
); break;
6136 case 13753: return ((char *) HT_13753
); break;
6137 case 13761: return ((char *) HT_13761
); break;
6138 case 13762: return ((char *) HT_13762
); break;
6139 case 13763: return ((char *) HT_13763
); break;
6140 case 13800: return ((char *) HT_13800
); break;
6143 return ((char *) "Unknown");
6146 char *strstatus (const uint devices_status
)
6148 switch (devices_status
)
6150 case STATUS_INIT
: return ((char *) ST_0000
); break;
6151 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6152 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6153 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6154 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6155 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6156 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6157 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6158 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6159 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6160 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6163 return ((char *) "Unknown");
6166 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6168 uint hash_type
= data
.hash_type
;
6169 uint hash_mode
= data
.hash_mode
;
6170 uint salt_type
= data
.salt_type
;
6171 uint opts_type
= data
.opts_type
;
6172 uint opti_type
= data
.opti_type
;
6173 uint dgst_size
= data
.dgst_size
;
6175 char *hashfile
= data
.hashfile
;
6179 uint digest_buf
[64] = { 0 };
6181 u64
*digest_buf64
= (u64
*) digest_buf
;
6183 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6185 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6187 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6193 case HASH_TYPE_DESCRYPT
:
6194 FP (digest_buf
[1], digest_buf
[0], tt
);
6197 case HASH_TYPE_DESRACF
:
6198 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6199 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6201 FP (digest_buf
[1], digest_buf
[0], tt
);
6205 FP (digest_buf
[1], digest_buf
[0], tt
);
6208 case HASH_TYPE_NETNTLM
:
6209 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6210 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6211 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6212 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6214 FP (digest_buf
[1], digest_buf
[0], tt
);
6215 FP (digest_buf
[3], digest_buf
[2], tt
);
6218 case HASH_TYPE_BSDICRYPT
:
6219 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6220 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6222 FP (digest_buf
[1], digest_buf
[0], tt
);
6227 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6232 digest_buf
[0] += MD4M_A
;
6233 digest_buf
[1] += MD4M_B
;
6234 digest_buf
[2] += MD4M_C
;
6235 digest_buf
[3] += MD4M_D
;
6239 digest_buf
[0] += MD5M_A
;
6240 digest_buf
[1] += MD5M_B
;
6241 digest_buf
[2] += MD5M_C
;
6242 digest_buf
[3] += MD5M_D
;
6245 case HASH_TYPE_SHA1
:
6246 digest_buf
[0] += SHA1M_A
;
6247 digest_buf
[1] += SHA1M_B
;
6248 digest_buf
[2] += SHA1M_C
;
6249 digest_buf
[3] += SHA1M_D
;
6250 digest_buf
[4] += SHA1M_E
;
6253 case HASH_TYPE_SHA256
:
6254 digest_buf
[0] += SHA256M_A
;
6255 digest_buf
[1] += SHA256M_B
;
6256 digest_buf
[2] += SHA256M_C
;
6257 digest_buf
[3] += SHA256M_D
;
6258 digest_buf
[4] += SHA256M_E
;
6259 digest_buf
[5] += SHA256M_F
;
6260 digest_buf
[6] += SHA256M_G
;
6261 digest_buf
[7] += SHA256M_H
;
6264 case HASH_TYPE_SHA384
:
6265 digest_buf64
[0] += SHA384M_A
;
6266 digest_buf64
[1] += SHA384M_B
;
6267 digest_buf64
[2] += SHA384M_C
;
6268 digest_buf64
[3] += SHA384M_D
;
6269 digest_buf64
[4] += SHA384M_E
;
6270 digest_buf64
[5] += SHA384M_F
;
6271 digest_buf64
[6] += 0;
6272 digest_buf64
[7] += 0;
6275 case HASH_TYPE_SHA512
:
6276 digest_buf64
[0] += SHA512M_A
;
6277 digest_buf64
[1] += SHA512M_B
;
6278 digest_buf64
[2] += SHA512M_C
;
6279 digest_buf64
[3] += SHA512M_D
;
6280 digest_buf64
[4] += SHA512M_E
;
6281 digest_buf64
[5] += SHA512M_F
;
6282 digest_buf64
[6] += SHA512M_G
;
6283 digest_buf64
[7] += SHA512M_H
;
6288 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6290 if (dgst_size
== DGST_SIZE_4_2
)
6292 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6294 else if (dgst_size
== DGST_SIZE_4_4
)
6296 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6298 else if (dgst_size
== DGST_SIZE_4_5
)
6300 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6302 else if (dgst_size
== DGST_SIZE_4_6
)
6304 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6306 else if (dgst_size
== DGST_SIZE_4_8
)
6308 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6310 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6312 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6314 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6316 else if (hash_type
== HASH_TYPE_SHA384
)
6318 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6320 else if (hash_type
== HASH_TYPE_SHA512
)
6322 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6324 else if (hash_type
== HASH_TYPE_GOST
)
6326 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6329 else if (dgst_size
== DGST_SIZE_4_64
)
6331 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6333 else if (dgst_size
== DGST_SIZE_8_25
)
6335 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6339 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6340 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6341 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6347 memset (&salt
, 0, sizeof (salt_t
));
6349 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6351 char *ptr
= (char *) salt
.salt_buf
;
6353 uint len
= salt
.salt_len
;
6355 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6361 case HASH_TYPE_NETNTLM
:
6363 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6364 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6366 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6372 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6374 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6382 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6384 uint max
= salt
.salt_len
/ 4;
6388 for (uint i
= 0; i
< max
; i
++)
6390 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6394 if (opts_type
& OPTS_TYPE_ST_HEX
)
6396 char tmp
[64] = { 0 };
6398 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6400 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6405 memcpy (ptr
, tmp
, len
);
6408 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6410 memset (ptr
+ len
, 0, memset_size
);
6412 salt
.salt_len
= len
;
6416 // some modes require special encoding
6419 uint out_buf_plain
[256] = { 0 };
6420 uint out_buf_salt
[256] = { 0 };
6422 char tmp_buf
[1024] = { 0 };
6424 char *ptr_plain
= (char *) out_buf_plain
;
6425 char *ptr_salt
= (char *) out_buf_salt
;
6427 if (hash_mode
== 22)
6429 char username
[30] = { 0 };
6431 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6433 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6435 u16
*ptr
= (u16
*) digest_buf
;
6437 tmp_buf
[ 0] = sig
[0];
6438 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6439 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6440 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6441 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6442 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6443 tmp_buf
[ 6] = sig
[1];
6444 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6445 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6446 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6447 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6448 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6449 tmp_buf
[12] = sig
[2];
6450 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6451 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6452 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6453 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6454 tmp_buf
[17] = sig
[3];
6455 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6456 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6457 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6458 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6459 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6460 tmp_buf
[23] = sig
[4];
6461 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6462 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6463 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6464 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6465 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6466 tmp_buf
[29] = sig
[5];
6468 snprintf (out_buf
, len
-1, "%s:%s",
6472 else if (hash_mode
== 23)
6474 // do not show the skyper part in output
6476 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6478 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6480 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6487 else if (hash_mode
== 101)
6489 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6491 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6492 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6493 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6494 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6495 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6497 memcpy (tmp_buf
, digest_buf
, 20);
6499 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6501 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6503 else if (hash_mode
== 111)
6505 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6507 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6508 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6509 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6510 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6511 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6513 memcpy (tmp_buf
, digest_buf
, 20);
6514 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6516 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6518 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6520 else if ((hash_mode
== 122) || (hash_mode
== 125))
6522 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6523 (char *) salt
.salt_buf
,
6530 else if (hash_mode
== 124)
6532 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6533 (char *) salt
.salt_buf
,
6540 else if (hash_mode
== 131)
6542 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6543 (char *) salt
.salt_buf
,
6551 else if (hash_mode
== 132)
6553 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6554 (char *) salt
.salt_buf
,
6561 else if (hash_mode
== 133)
6563 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6565 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6566 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6567 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6568 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6569 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6571 memcpy (tmp_buf
, digest_buf
, 20);
6573 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6575 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6577 else if (hash_mode
== 141)
6579 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6581 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6583 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6585 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6587 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6588 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6589 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6590 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6591 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6593 memcpy (tmp_buf
, digest_buf
, 20);
6595 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6599 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6601 else if (hash_mode
== 400)
6603 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6605 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6606 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6607 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6608 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6610 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6612 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6614 else if (hash_mode
== 500)
6616 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6618 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6619 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6620 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6621 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6623 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6625 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6627 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6631 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6634 else if (hash_mode
== 501)
6636 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6638 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6639 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6641 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6643 else if (hash_mode
== 1421)
6645 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6647 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6663 else if (hash_mode
== 1441)
6665 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6667 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6669 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6671 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6673 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6674 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6675 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6676 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6677 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6678 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6679 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6680 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6682 memcpy (tmp_buf
, digest_buf
, 32);
6684 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6688 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6690 else if (hash_mode
== 1500)
6692 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6693 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6694 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6695 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6696 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6698 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6700 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6702 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6703 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6705 memcpy (tmp_buf
, digest_buf
, 8);
6707 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6709 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6713 else if (hash_mode
== 1600)
6715 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6717 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6718 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6719 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6720 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6722 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6724 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6726 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6730 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6733 else if (hash_mode
== 1711)
6735 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6737 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6738 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6739 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6740 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6741 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6742 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6743 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6744 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6746 memcpy (tmp_buf
, digest_buf
, 64);
6747 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6749 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6751 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6753 else if (hash_mode
== 1722)
6755 uint
*ptr
= digest_buf
;
6757 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6758 (unsigned char *) salt
.salt_buf
,
6768 else if (hash_mode
== 1731)
6770 uint
*ptr
= digest_buf
;
6772 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6773 (unsigned char *) salt
.salt_buf
,
6783 else if (hash_mode
== 1800)
6787 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6788 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6789 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6790 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6791 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6792 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6793 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6794 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6796 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6798 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6800 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6804 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6807 else if (hash_mode
== 2100)
6811 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6813 salt
.salt_iter
+ 1);
6815 uint signature_len
= strlen (out_buf
);
6817 pos
+= signature_len
;
6818 len
-= signature_len
;
6820 char *salt_ptr
= (char *) salt
.salt_buf
;
6822 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6824 snprintf (out_buf
+ pos
, 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
== 2400) || (hash_mode
== 2410))
6832 memcpy (tmp_buf
, digest_buf
, 16);
6834 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6836 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6837 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6838 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6839 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6841 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6842 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6843 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6844 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6846 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6847 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6848 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6849 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6851 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6852 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6853 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6854 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6856 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6857 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6858 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6859 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6863 else if (hash_mode
== 2500)
6865 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6867 wpa_t
*wpa
= &wpas
[salt_pos
];
6869 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6870 (char *) salt
.salt_buf
,
6884 else if (hash_mode
== 4400)
6886 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6887 byte_swap_32 (digest_buf
[0]),
6888 byte_swap_32 (digest_buf
[1]),
6889 byte_swap_32 (digest_buf
[2]),
6890 byte_swap_32 (digest_buf
[3]));
6892 else if (hash_mode
== 4700)
6894 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6895 byte_swap_32 (digest_buf
[0]),
6896 byte_swap_32 (digest_buf
[1]),
6897 byte_swap_32 (digest_buf
[2]),
6898 byte_swap_32 (digest_buf
[3]),
6899 byte_swap_32 (digest_buf
[4]));
6901 else if (hash_mode
== 4800)
6903 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6905 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6910 byte_swap_32 (salt
.salt_buf
[0]),
6911 byte_swap_32 (salt
.salt_buf
[1]),
6912 byte_swap_32 (salt
.salt_buf
[2]),
6913 byte_swap_32 (salt
.salt_buf
[3]),
6916 else if (hash_mode
== 4900)
6918 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6919 byte_swap_32 (digest_buf
[0]),
6920 byte_swap_32 (digest_buf
[1]),
6921 byte_swap_32 (digest_buf
[2]),
6922 byte_swap_32 (digest_buf
[3]),
6923 byte_swap_32 (digest_buf
[4]));
6925 else if (hash_mode
== 5100)
6927 snprintf (out_buf
, len
-1, "%08x%08x",
6931 else if (hash_mode
== 5200)
6933 snprintf (out_buf
, len
-1, "%s", hashfile
);
6935 else if (hash_mode
== 5300)
6937 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6939 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6941 int buf_len
= len
-1;
6945 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6947 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6949 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6951 snprintf (out_buf
, buf_len
, ":");
6957 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6965 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6967 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6969 if ((i
== 0) || (i
== 5))
6971 snprintf (out_buf
, buf_len
, ":");
6977 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6985 for (uint i
= 0; i
< 4; i
++)
6989 snprintf (out_buf
, buf_len
, ":");
6995 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
7001 else if (hash_mode
== 5400)
7003 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
7005 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
7007 int buf_len
= len
-1;
7011 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
7013 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
7015 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
7017 snprintf (out_buf
, buf_len
, ":");
7023 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
7031 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
7033 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
7035 if ((i
== 0) || (i
== 5))
7037 snprintf (out_buf
, buf_len
, ":");
7043 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
7051 for (uint i
= 0; i
< 5; i
++)
7055 snprintf (out_buf
, buf_len
, ":");
7061 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
7067 else if (hash_mode
== 5500)
7069 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7071 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7073 char user_buf
[64] = { 0 };
7074 char domain_buf
[64] = { 0 };
7075 char srvchall_buf
[1024] = { 0 };
7076 char clichall_buf
[1024] = { 0 };
7078 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7080 char *ptr
= (char *) netntlm
->userdomain_buf
;
7082 user_buf
[i
] = ptr
[j
];
7085 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7087 char *ptr
= (char *) netntlm
->userdomain_buf
;
7089 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7092 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7094 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7096 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7099 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7101 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7103 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7106 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7114 byte_swap_32 (salt
.salt_buf_pc
[0]),
7115 byte_swap_32 (salt
.salt_buf_pc
[1]),
7118 else if (hash_mode
== 5600)
7120 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7122 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7124 char user_buf
[64] = { 0 };
7125 char domain_buf
[64] = { 0 };
7126 char srvchall_buf
[1024] = { 0 };
7127 char clichall_buf
[1024] = { 0 };
7129 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7131 char *ptr
= (char *) netntlm
->userdomain_buf
;
7133 user_buf
[i
] = ptr
[j
];
7136 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7138 char *ptr
= (char *) netntlm
->userdomain_buf
;
7140 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7143 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7145 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7147 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7150 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7152 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7154 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7157 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7167 else if (hash_mode
== 5700)
7169 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7171 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7172 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7173 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7174 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7175 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7176 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7177 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7178 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7180 memcpy (tmp_buf
, digest_buf
, 32);
7182 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7186 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7188 else if (hash_mode
== 5800)
7190 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7191 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7192 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7193 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7194 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7196 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7203 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7205 snprintf (out_buf
, len
-1, "%s", hashfile
);
7207 else if (hash_mode
== 6300)
7209 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7211 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7212 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7213 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7214 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7216 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7218 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7220 else if (hash_mode
== 6400)
7222 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7224 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7226 else if (hash_mode
== 6500)
7228 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7230 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7232 else if (hash_mode
== 6600)
7234 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7236 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7238 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7239 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7241 uint buf_len
= len
- 1;
7243 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7246 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7248 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7253 else if (hash_mode
== 6700)
7255 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7257 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7259 else if (hash_mode
== 6800)
7261 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7263 else if (hash_mode
== 7100)
7265 uint
*ptr
= digest_buf
;
7267 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7269 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7271 uint esalt
[8] = { 0 };
7273 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7274 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7275 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7276 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7277 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7278 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7279 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7280 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7282 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",
7283 SIGNATURE_SHA512OSX
,
7285 esalt
[ 0], esalt
[ 1],
7286 esalt
[ 2], esalt
[ 3],
7287 esalt
[ 4], esalt
[ 5],
7288 esalt
[ 6], esalt
[ 7],
7296 ptr
[15], ptr
[14]);
7298 else if (hash_mode
== 7200)
7300 uint
*ptr
= digest_buf
;
7302 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7304 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7308 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7310 len_used
= strlen (out_buf
);
7312 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7314 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7316 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7319 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",
7327 ptr
[15], ptr
[14]);
7329 else if (hash_mode
== 7300)
7331 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7333 rakp_t
*rakp
= &rakps
[salt_pos
];
7335 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7337 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7340 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7347 else if (hash_mode
== 7400)
7349 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7351 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7352 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7353 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7354 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7355 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7356 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7357 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7358 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7360 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7362 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7364 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7368 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7371 else if (hash_mode
== 7500)
7373 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7375 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7377 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7378 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7380 char data
[128] = { 0 };
7382 char *ptr_data
= data
;
7384 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7386 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7389 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7391 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7396 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7398 (char *) krb5pa
->user
,
7399 (char *) krb5pa
->realm
,
7400 (char *) krb5pa
->salt
,
7403 else if (hash_mode
== 7700)
7405 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7406 (char *) salt
.salt_buf
,
7410 else if (hash_mode
== 7800)
7412 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7413 (char *) salt
.salt_buf
,
7420 else if (hash_mode
== 7900)
7422 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7426 char *tmp
= (char *) salt
.salt_buf_pc
;
7428 ptr_plain
[42] = tmp
[0];
7434 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7436 else if (hash_mode
== 8000)
7438 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7439 (unsigned char *) salt
.salt_buf
,
7449 else if (hash_mode
== 8100)
7451 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7452 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7454 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7455 (unsigned char *) salt
.salt_buf
,
7462 else if (hash_mode
== 8200)
7464 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7466 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7468 char data_buf
[4096] = { 0 };
7470 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7472 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7475 data_buf
[cloudkey
->data_len
* 2] = 0;
7477 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7478 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7479 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7480 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7481 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7482 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7483 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7484 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7486 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7487 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7488 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7489 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7491 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7507 else if (hash_mode
== 8300)
7509 char digest_buf_c
[34] = { 0 };
7511 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7512 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7513 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7514 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7515 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7517 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7519 digest_buf_c
[32] = 0;
7523 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7525 char domain_buf_c
[33] = { 0 };
7527 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7529 for (uint i
= 0; i
< salt_pc_len
; i
++)
7531 const char next
= domain_buf_c
[i
];
7533 domain_buf_c
[i
] = '.';
7538 domain_buf_c
[salt_pc_len
] = 0;
7542 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7544 else if (hash_mode
== 8500)
7546 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7548 else if (hash_mode
== 2612)
7550 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7552 (char *) salt
.salt_buf
,
7558 else if (hash_mode
== 3711)
7560 char *salt_ptr
= (char *) salt
.salt_buf
;
7562 salt_ptr
[salt
.salt_len
- 1] = 0;
7564 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7565 SIGNATURE_MEDIAWIKI_B
,
7572 else if (hash_mode
== 8800)
7574 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7576 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7578 char tmp
[3073] = { 0 };
7580 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7582 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7587 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7588 SIGNATURE_ANDROIDFDE
,
7589 byte_swap_32 (salt
.salt_buf
[0]),
7590 byte_swap_32 (salt
.salt_buf
[1]),
7591 byte_swap_32 (salt
.salt_buf
[2]),
7592 byte_swap_32 (salt
.salt_buf
[3]),
7593 byte_swap_32 (digest_buf
[0]),
7594 byte_swap_32 (digest_buf
[1]),
7595 byte_swap_32 (digest_buf
[2]),
7596 byte_swap_32 (digest_buf
[3]),
7599 else if (hash_mode
== 8900)
7601 uint N
= salt
.scrypt_N
;
7602 uint r
= salt
.scrypt_r
;
7603 uint p
= salt
.scrypt_p
;
7605 char base64_salt
[32] = { 0 };
7607 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7609 memset (tmp_buf
, 0, 46);
7611 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7612 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7613 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7614 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7615 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7616 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7617 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7618 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7619 digest_buf
[8] = 0; // needed for base64_encode ()
7621 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7623 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7631 else if (hash_mode
== 9000)
7633 snprintf (out_buf
, len
-1, "%s", hashfile
);
7635 else if (hash_mode
== 9200)
7639 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7641 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7643 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7647 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7648 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7649 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7650 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7651 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7652 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7653 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7654 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7655 digest_buf
[8] = 0; // needed for base64_encode ()
7657 char tmp_buf
[64] = { 0 };
7659 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7660 tmp_buf
[43] = 0; // cut it here
7664 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7666 else if (hash_mode
== 9300)
7668 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7669 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7670 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7671 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7672 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7673 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7674 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7675 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7676 digest_buf
[8] = 0; // needed for base64_encode ()
7678 char tmp_buf
[64] = { 0 };
7680 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7681 tmp_buf
[43] = 0; // cut it here
7683 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7685 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7687 else if (hash_mode
== 9400)
7689 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7691 office2007_t
*office2007
= &office2007s
[salt_pos
];
7693 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7694 SIGNATURE_OFFICE2007
,
7697 office2007
->keySize
,
7703 office2007
->encryptedVerifier
[0],
7704 office2007
->encryptedVerifier
[1],
7705 office2007
->encryptedVerifier
[2],
7706 office2007
->encryptedVerifier
[3],
7707 office2007
->encryptedVerifierHash
[0],
7708 office2007
->encryptedVerifierHash
[1],
7709 office2007
->encryptedVerifierHash
[2],
7710 office2007
->encryptedVerifierHash
[3],
7711 office2007
->encryptedVerifierHash
[4]);
7713 else if (hash_mode
== 9500)
7715 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7717 office2010_t
*office2010
= &office2010s
[salt_pos
];
7719 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,
7725 office2010
->encryptedVerifier
[0],
7726 office2010
->encryptedVerifier
[1],
7727 office2010
->encryptedVerifier
[2],
7728 office2010
->encryptedVerifier
[3],
7729 office2010
->encryptedVerifierHash
[0],
7730 office2010
->encryptedVerifierHash
[1],
7731 office2010
->encryptedVerifierHash
[2],
7732 office2010
->encryptedVerifierHash
[3],
7733 office2010
->encryptedVerifierHash
[4],
7734 office2010
->encryptedVerifierHash
[5],
7735 office2010
->encryptedVerifierHash
[6],
7736 office2010
->encryptedVerifierHash
[7]);
7738 else if (hash_mode
== 9600)
7740 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7742 office2013_t
*office2013
= &office2013s
[salt_pos
];
7744 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,
7750 office2013
->encryptedVerifier
[0],
7751 office2013
->encryptedVerifier
[1],
7752 office2013
->encryptedVerifier
[2],
7753 office2013
->encryptedVerifier
[3],
7754 office2013
->encryptedVerifierHash
[0],
7755 office2013
->encryptedVerifierHash
[1],
7756 office2013
->encryptedVerifierHash
[2],
7757 office2013
->encryptedVerifierHash
[3],
7758 office2013
->encryptedVerifierHash
[4],
7759 office2013
->encryptedVerifierHash
[5],
7760 office2013
->encryptedVerifierHash
[6],
7761 office2013
->encryptedVerifierHash
[7]);
7763 else if (hash_mode
== 9700)
7765 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7767 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7769 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7770 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7771 byte_swap_32 (salt
.salt_buf
[0]),
7772 byte_swap_32 (salt
.salt_buf
[1]),
7773 byte_swap_32 (salt
.salt_buf
[2]),
7774 byte_swap_32 (salt
.salt_buf
[3]),
7775 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7776 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7777 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7778 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7779 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7780 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7781 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7782 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7784 else if (hash_mode
== 9710)
7786 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7788 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7790 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7791 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7792 byte_swap_32 (salt
.salt_buf
[0]),
7793 byte_swap_32 (salt
.salt_buf
[1]),
7794 byte_swap_32 (salt
.salt_buf
[2]),
7795 byte_swap_32 (salt
.salt_buf
[3]),
7796 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7797 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7798 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7799 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7800 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7801 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7802 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7803 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7805 else if (hash_mode
== 9720)
7807 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7809 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7811 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7813 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7814 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7815 byte_swap_32 (salt
.salt_buf
[0]),
7816 byte_swap_32 (salt
.salt_buf
[1]),
7817 byte_swap_32 (salt
.salt_buf
[2]),
7818 byte_swap_32 (salt
.salt_buf
[3]),
7819 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7820 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7821 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7822 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7823 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7824 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7825 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7826 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7833 else if (hash_mode
== 9800)
7835 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7837 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7839 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7840 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7845 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7846 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7847 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7848 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7849 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7850 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7851 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7852 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7853 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7855 else if (hash_mode
== 9810)
7857 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7859 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7861 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7862 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7867 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7868 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7869 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7870 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7871 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7872 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7873 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7874 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7875 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7877 else if (hash_mode
== 9820)
7879 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7881 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7883 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7885 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7886 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7891 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7892 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7893 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7894 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7895 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7896 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7897 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7898 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7899 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7906 else if (hash_mode
== 10000)
7910 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7912 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7914 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7918 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7919 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7920 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7921 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7922 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7923 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7924 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7925 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7926 digest_buf
[8] = 0; // needed for base64_encode ()
7928 char tmp_buf
[64] = { 0 };
7930 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7934 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7936 else if (hash_mode
== 10100)
7938 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7943 byte_swap_32 (salt
.salt_buf
[0]),
7944 byte_swap_32 (salt
.salt_buf
[1]),
7945 byte_swap_32 (salt
.salt_buf
[2]),
7946 byte_swap_32 (salt
.salt_buf
[3]));
7948 else if (hash_mode
== 10200)
7950 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7952 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7956 char challenge
[100] = { 0 };
7958 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7962 char tmp_buf
[100] = { 0 };
7964 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7965 (char *) cram_md5
->user
,
7971 char response
[100] = { 0 };
7973 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7975 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7977 else if (hash_mode
== 10300)
7979 char tmp_buf
[100] = { 0 };
7981 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7982 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7984 uint tmp_len
= 20 + salt
.salt_len
;
7988 char base64_encoded
[100] = { 0 };
7990 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7992 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7994 else if (hash_mode
== 10400)
7996 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7998 pdf_t
*pdf
= &pdfs
[salt_pos
];
8000 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",
8008 byte_swap_32 (pdf
->id_buf
[0]),
8009 byte_swap_32 (pdf
->id_buf
[1]),
8010 byte_swap_32 (pdf
->id_buf
[2]),
8011 byte_swap_32 (pdf
->id_buf
[3]),
8013 byte_swap_32 (pdf
->u_buf
[0]),
8014 byte_swap_32 (pdf
->u_buf
[1]),
8015 byte_swap_32 (pdf
->u_buf
[2]),
8016 byte_swap_32 (pdf
->u_buf
[3]),
8017 byte_swap_32 (pdf
->u_buf
[4]),
8018 byte_swap_32 (pdf
->u_buf
[5]),
8019 byte_swap_32 (pdf
->u_buf
[6]),
8020 byte_swap_32 (pdf
->u_buf
[7]),
8022 byte_swap_32 (pdf
->o_buf
[0]),
8023 byte_swap_32 (pdf
->o_buf
[1]),
8024 byte_swap_32 (pdf
->o_buf
[2]),
8025 byte_swap_32 (pdf
->o_buf
[3]),
8026 byte_swap_32 (pdf
->o_buf
[4]),
8027 byte_swap_32 (pdf
->o_buf
[5]),
8028 byte_swap_32 (pdf
->o_buf
[6]),
8029 byte_swap_32 (pdf
->o_buf
[7])
8032 else if (hash_mode
== 10410)
8034 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8036 pdf_t
*pdf
= &pdfs
[salt_pos
];
8038 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",
8046 byte_swap_32 (pdf
->id_buf
[0]),
8047 byte_swap_32 (pdf
->id_buf
[1]),
8048 byte_swap_32 (pdf
->id_buf
[2]),
8049 byte_swap_32 (pdf
->id_buf
[3]),
8051 byte_swap_32 (pdf
->u_buf
[0]),
8052 byte_swap_32 (pdf
->u_buf
[1]),
8053 byte_swap_32 (pdf
->u_buf
[2]),
8054 byte_swap_32 (pdf
->u_buf
[3]),
8055 byte_swap_32 (pdf
->u_buf
[4]),
8056 byte_swap_32 (pdf
->u_buf
[5]),
8057 byte_swap_32 (pdf
->u_buf
[6]),
8058 byte_swap_32 (pdf
->u_buf
[7]),
8060 byte_swap_32 (pdf
->o_buf
[0]),
8061 byte_swap_32 (pdf
->o_buf
[1]),
8062 byte_swap_32 (pdf
->o_buf
[2]),
8063 byte_swap_32 (pdf
->o_buf
[3]),
8064 byte_swap_32 (pdf
->o_buf
[4]),
8065 byte_swap_32 (pdf
->o_buf
[5]),
8066 byte_swap_32 (pdf
->o_buf
[6]),
8067 byte_swap_32 (pdf
->o_buf
[7])
8070 else if (hash_mode
== 10420)
8072 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8074 pdf_t
*pdf
= &pdfs
[salt_pos
];
8076 u8
*rc4key
= (u8
*) pdf
->rc4key
;
8078 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",
8086 byte_swap_32 (pdf
->id_buf
[0]),
8087 byte_swap_32 (pdf
->id_buf
[1]),
8088 byte_swap_32 (pdf
->id_buf
[2]),
8089 byte_swap_32 (pdf
->id_buf
[3]),
8091 byte_swap_32 (pdf
->u_buf
[0]),
8092 byte_swap_32 (pdf
->u_buf
[1]),
8093 byte_swap_32 (pdf
->u_buf
[2]),
8094 byte_swap_32 (pdf
->u_buf
[3]),
8095 byte_swap_32 (pdf
->u_buf
[4]),
8096 byte_swap_32 (pdf
->u_buf
[5]),
8097 byte_swap_32 (pdf
->u_buf
[6]),
8098 byte_swap_32 (pdf
->u_buf
[7]),
8100 byte_swap_32 (pdf
->o_buf
[0]),
8101 byte_swap_32 (pdf
->o_buf
[1]),
8102 byte_swap_32 (pdf
->o_buf
[2]),
8103 byte_swap_32 (pdf
->o_buf
[3]),
8104 byte_swap_32 (pdf
->o_buf
[4]),
8105 byte_swap_32 (pdf
->o_buf
[5]),
8106 byte_swap_32 (pdf
->o_buf
[6]),
8107 byte_swap_32 (pdf
->o_buf
[7]),
8115 else if (hash_mode
== 10500)
8117 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8119 pdf_t
*pdf
= &pdfs
[salt_pos
];
8121 if (pdf
->id_len
== 32)
8123 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",
8131 byte_swap_32 (pdf
->id_buf
[0]),
8132 byte_swap_32 (pdf
->id_buf
[1]),
8133 byte_swap_32 (pdf
->id_buf
[2]),
8134 byte_swap_32 (pdf
->id_buf
[3]),
8135 byte_swap_32 (pdf
->id_buf
[4]),
8136 byte_swap_32 (pdf
->id_buf
[5]),
8137 byte_swap_32 (pdf
->id_buf
[6]),
8138 byte_swap_32 (pdf
->id_buf
[7]),
8140 byte_swap_32 (pdf
->u_buf
[0]),
8141 byte_swap_32 (pdf
->u_buf
[1]),
8142 byte_swap_32 (pdf
->u_buf
[2]),
8143 byte_swap_32 (pdf
->u_buf
[3]),
8144 byte_swap_32 (pdf
->u_buf
[4]),
8145 byte_swap_32 (pdf
->u_buf
[5]),
8146 byte_swap_32 (pdf
->u_buf
[6]),
8147 byte_swap_32 (pdf
->u_buf
[7]),
8149 byte_swap_32 (pdf
->o_buf
[0]),
8150 byte_swap_32 (pdf
->o_buf
[1]),
8151 byte_swap_32 (pdf
->o_buf
[2]),
8152 byte_swap_32 (pdf
->o_buf
[3]),
8153 byte_swap_32 (pdf
->o_buf
[4]),
8154 byte_swap_32 (pdf
->o_buf
[5]),
8155 byte_swap_32 (pdf
->o_buf
[6]),
8156 byte_swap_32 (pdf
->o_buf
[7])
8161 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",
8169 byte_swap_32 (pdf
->id_buf
[0]),
8170 byte_swap_32 (pdf
->id_buf
[1]),
8171 byte_swap_32 (pdf
->id_buf
[2]),
8172 byte_swap_32 (pdf
->id_buf
[3]),
8174 byte_swap_32 (pdf
->u_buf
[0]),
8175 byte_swap_32 (pdf
->u_buf
[1]),
8176 byte_swap_32 (pdf
->u_buf
[2]),
8177 byte_swap_32 (pdf
->u_buf
[3]),
8178 byte_swap_32 (pdf
->u_buf
[4]),
8179 byte_swap_32 (pdf
->u_buf
[5]),
8180 byte_swap_32 (pdf
->u_buf
[6]),
8181 byte_swap_32 (pdf
->u_buf
[7]),
8183 byte_swap_32 (pdf
->o_buf
[0]),
8184 byte_swap_32 (pdf
->o_buf
[1]),
8185 byte_swap_32 (pdf
->o_buf
[2]),
8186 byte_swap_32 (pdf
->o_buf
[3]),
8187 byte_swap_32 (pdf
->o_buf
[4]),
8188 byte_swap_32 (pdf
->o_buf
[5]),
8189 byte_swap_32 (pdf
->o_buf
[6]),
8190 byte_swap_32 (pdf
->o_buf
[7])
8194 else if (hash_mode
== 10600)
8196 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8198 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8199 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8201 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8203 else if (hash_mode
== 10700)
8205 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8207 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8208 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8210 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8212 else if (hash_mode
== 10900)
8214 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8216 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8217 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8219 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8221 else if (hash_mode
== 11100)
8223 u32 salt_challenge
= salt
.salt_buf
[0];
8225 salt_challenge
= byte_swap_32 (salt_challenge
);
8227 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8229 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8230 SIGNATURE_POSTGRESQL_AUTH
,
8238 else if (hash_mode
== 11200)
8240 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8241 SIGNATURE_MYSQL_AUTH
,
8242 (unsigned char *) salt
.salt_buf
,
8249 else if (hash_mode
== 11300)
8251 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8253 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8255 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8256 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8257 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8259 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8260 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8261 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8263 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8265 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8267 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8270 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8272 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8274 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8277 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8279 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8281 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8284 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8285 SIGNATURE_BITCOIN_WALLET
,
8289 (unsigned char *) salt
.salt_buf
,
8297 free (cry_master_buf
);
8299 free (public_key_buf
);
8301 else if (hash_mode
== 11400)
8303 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8305 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8306 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8308 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8310 else if (hash_mode
== 11600)
8312 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8314 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8316 const uint data_len
= seven_zip
->data_len
;
8318 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8320 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8322 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8324 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8327 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8328 SIGNATURE_SEVEN_ZIP
,
8332 (char *) seven_zip
->salt_buf
,
8334 seven_zip
->iv_buf
[0],
8335 seven_zip
->iv_buf
[1],
8336 seven_zip
->iv_buf
[2],
8337 seven_zip
->iv_buf
[3],
8339 seven_zip
->data_len
,
8340 seven_zip
->unpack_size
,
8345 else if (hash_mode
== 11700)
8347 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8357 else if (hash_mode
== 11800)
8359 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8377 else if (hash_mode
== 11900)
8379 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8381 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8382 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8384 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8386 else if (hash_mode
== 12000)
8388 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8390 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8391 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8393 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8395 else if (hash_mode
== 12100)
8397 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8399 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8400 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8402 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8404 else if (hash_mode
== 12200)
8406 uint
*ptr_digest
= digest_buf
;
8407 uint
*ptr_salt
= salt
.salt_buf
;
8409 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8416 else if (hash_mode
== 12300)
8418 uint
*ptr_digest
= digest_buf
;
8419 uint
*ptr_salt
= salt
.salt_buf
;
8421 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",
8422 ptr_digest
[ 0], ptr_digest
[ 1],
8423 ptr_digest
[ 2], ptr_digest
[ 3],
8424 ptr_digest
[ 4], ptr_digest
[ 5],
8425 ptr_digest
[ 6], ptr_digest
[ 7],
8426 ptr_digest
[ 8], ptr_digest
[ 9],
8427 ptr_digest
[10], ptr_digest
[11],
8428 ptr_digest
[12], ptr_digest
[13],
8429 ptr_digest
[14], ptr_digest
[15],
8435 else if (hash_mode
== 12400)
8437 // encode iteration count
8439 char salt_iter
[5] = { 0 };
8441 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8442 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8443 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8444 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8449 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8450 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8451 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8452 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8457 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8459 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8460 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8462 memcpy (tmp_buf
, digest_buf
, 8);
8464 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8468 // fill the resulting buffer
8470 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8472 else if (hash_mode
== 12500)
8474 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8476 byte_swap_32 (salt
.salt_buf
[0]),
8477 byte_swap_32 (salt
.salt_buf
[1]),
8483 else if (hash_mode
== 12600)
8485 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8486 digest_buf
[0] + salt
.salt_buf_pc
[0],
8487 digest_buf
[1] + salt
.salt_buf_pc
[1],
8488 digest_buf
[2] + salt
.salt_buf_pc
[2],
8489 digest_buf
[3] + salt
.salt_buf_pc
[3],
8490 digest_buf
[4] + salt
.salt_buf_pc
[4],
8491 digest_buf
[5] + salt
.salt_buf_pc
[5],
8492 digest_buf
[6] + salt
.salt_buf_pc
[6],
8493 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8495 else if (hash_mode
== 12700)
8497 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8499 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8500 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8502 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8504 else if (hash_mode
== 12800)
8506 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8508 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",
8521 byte_swap_32 (digest_buf
[0]),
8522 byte_swap_32 (digest_buf
[1]),
8523 byte_swap_32 (digest_buf
[2]),
8524 byte_swap_32 (digest_buf
[3]),
8525 byte_swap_32 (digest_buf
[4]),
8526 byte_swap_32 (digest_buf
[5]),
8527 byte_swap_32 (digest_buf
[6]),
8528 byte_swap_32 (digest_buf
[7])
8531 else if (hash_mode
== 12900)
8533 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",
8542 byte_swap_32 (digest_buf
[0]),
8543 byte_swap_32 (digest_buf
[1]),
8544 byte_swap_32 (digest_buf
[2]),
8545 byte_swap_32 (digest_buf
[3]),
8546 byte_swap_32 (digest_buf
[4]),
8547 byte_swap_32 (digest_buf
[5]),
8548 byte_swap_32 (digest_buf
[6]),
8549 byte_swap_32 (digest_buf
[7]),
8556 else if (hash_mode
== 13000)
8558 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8560 rar5_t
*rar5
= &rar5s
[salt_pos
];
8562 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8572 byte_swap_32 (digest_buf
[0]),
8573 byte_swap_32 (digest_buf
[1])
8576 else if (hash_mode
== 13100)
8578 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8580 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8582 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8583 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8585 char data
[2560 * 4 * 2] = { 0 };
8587 char *ptr_data
= data
;
8589 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8590 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8595 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8596 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8598 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8600 (char *) krb5tgs
->account_info
,
8604 else if (hash_mode
== 13200)
8606 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8620 else if (hash_mode
== 13300)
8622 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8623 SIGNATURE_AXCRYPT_SHA1
,
8629 else if (hash_mode
== 13400)
8631 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8633 keepass_t
*keepass
= &keepasss
[salt_pos
];
8635 u32 version
= (u32
) keepass
->version
;
8636 u32 rounds
= salt
.salt_iter
;
8637 u32 algorithm
= (u32
) keepass
->algorithm
;
8638 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8640 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8641 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8642 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8643 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8644 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8646 /* specific to version 1 */
8650 /* specific to version 2 */
8651 u32 expected_bytes_len
;
8652 u32
*ptr_expected_bytes
;
8654 u32 final_random_seed_len
;
8655 u32 transf_random_seed_len
;
8657 u32 contents_hash_len
;
8659 transf_random_seed_len
= 8;
8661 contents_hash_len
= 8;
8662 final_random_seed_len
= 8;
8665 final_random_seed_len
= 4;
8667 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8673 char *ptr_data
= out_buf
;
8675 ptr_data
+= strlen(out_buf
);
8680 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8681 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8686 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8687 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8692 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8693 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8700 contents_len
= (u32
) keepass
->contents_len
;
8701 ptr_contents
= (u32
*) keepass
->contents
;
8703 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8704 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8716 char ptr_contents_len
[10] = { 0 };
8718 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8720 sprintf (ptr_data
, "%d", contents_len
);
8722 ptr_data
+= strlen(ptr_contents_len
);
8727 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8728 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8730 else if (version
== 2)
8732 expected_bytes_len
= 8;
8733 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8735 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8736 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8741 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8742 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8756 sprintf (ptr_data
, "%d", keyfile_len
);
8763 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8764 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8767 else if (hash_mode
== 13500)
8769 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8771 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8773 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8775 char pstoken_tmp
[1024 + 1] = { 0 };
8777 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8779 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8781 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8784 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8792 else if (hash_mode
== 13600)
8794 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8796 zip2_t
*zip2
= &zip2s
[salt_pos
];
8798 const u32 salt_len
= zip2
->salt_len
;
8800 char salt_tmp
[32 + 1] = { 0 };
8802 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8804 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8806 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8809 const u32 data_len
= zip2
->data_len
;
8811 char data_tmp
[8192 + 1] = { 0 };
8813 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8815 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8817 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8820 const u32 auth_len
= zip2
->auth_len
;
8822 char auth_tmp
[20 + 1] = { 0 };
8824 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8826 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8828 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8831 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8832 SIGNATURE_ZIP2_START
,
8838 zip2
->compress_length
,
8841 SIGNATURE_ZIP2_STOP
);
8843 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8845 snprintf (out_buf
, len
-1, "%s", hashfile
);
8847 else if (hash_mode
== 13800)
8849 win8phone_t
*esalts
= (win8phone_t
*) data
.esalts_buf
;
8851 win8phone_t
*esalt
= &esalts
[salt_pos
];
8853 char buf
[256 + 1] = { 0 };
8855 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
8857 sprintf (buf
+ j
, "%08x", esalt
->salt_buf
[i
]);
8860 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%s",
8873 if (hash_type
== HASH_TYPE_MD4
)
8875 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8881 else if (hash_type
== HASH_TYPE_MD5
)
8883 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8889 else if (hash_type
== HASH_TYPE_SHA1
)
8891 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8898 else if (hash_type
== HASH_TYPE_SHA256
)
8900 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8910 else if (hash_type
== HASH_TYPE_SHA384
)
8912 uint
*ptr
= digest_buf
;
8914 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8922 else if (hash_type
== HASH_TYPE_SHA512
)
8924 uint
*ptr
= digest_buf
;
8926 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8936 else if (hash_type
== HASH_TYPE_LM
)
8938 snprintf (out_buf
, len
-1, "%08x%08x",
8942 else if (hash_type
== HASH_TYPE_ORACLEH
)
8944 snprintf (out_buf
, len
-1, "%08X%08X",
8948 else if (hash_type
== HASH_TYPE_BCRYPT
)
8950 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8951 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8953 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8955 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8957 else if (hash_type
== HASH_TYPE_KECCAK
)
8959 uint
*ptr
= digest_buf
;
8961 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",
8989 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8991 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8993 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
9000 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
9002 digest_buf
[ 0] = digest_buf
[ 0];
9003 digest_buf
[ 1] = digest_buf
[ 1];
9004 digest_buf
[ 2] = digest_buf
[ 2];
9005 digest_buf
[ 3] = digest_buf
[ 3];
9006 digest_buf
[ 4] = digest_buf
[ 4];
9007 digest_buf
[ 5] = digest_buf
[ 5];
9008 digest_buf
[ 6] = digest_buf
[ 6];
9009 digest_buf
[ 7] = digest_buf
[ 7];
9010 digest_buf
[ 8] = digest_buf
[ 8];
9011 digest_buf
[ 9] = digest_buf
[ 9];
9012 digest_buf
[10] = digest_buf
[10];
9013 digest_buf
[11] = digest_buf
[11];
9014 digest_buf
[12] = digest_buf
[12];
9015 digest_buf
[13] = digest_buf
[13];
9016 digest_buf
[14] = digest_buf
[14];
9017 digest_buf
[15] = digest_buf
[15];
9019 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
9037 else if (hash_type
== HASH_TYPE_GOST
)
9039 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
9049 else if (hash_type
== HASH_TYPE_MYSQL
)
9051 snprintf (out_buf
, len
-1, "%08x%08x",
9055 else if (hash_type
== HASH_TYPE_LOTUS5
)
9057 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
9063 else if (hash_type
== HASH_TYPE_LOTUS6
)
9065 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
9066 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
9067 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
9068 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
9070 char buf
[16] = { 0 };
9072 memcpy (buf
+ 0, salt
.salt_buf
, 5);
9073 memcpy (buf
+ 5, digest_buf
, 9);
9077 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
9079 tmp_buf
[18] = salt
.salt_buf_pc
[7];
9082 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
9084 else if (hash_type
== HASH_TYPE_LOTUS8
)
9086 char buf
[52] = { 0 };
9090 memcpy (buf
+ 0, salt
.salt_buf
, 16);
9096 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
9100 buf
[26] = salt
.salt_buf_pc
[0];
9101 buf
[27] = salt
.salt_buf_pc
[1];
9105 memcpy (buf
+ 28, digest_buf
, 8);
9107 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9111 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9113 else if (hash_type
== HASH_TYPE_CRC32
)
9115 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9119 if (salt_type
== SALT_TYPE_INTERN
)
9121 size_t pos
= strlen (out_buf
);
9123 out_buf
[pos
] = data
.separator
;
9125 char *ptr
= (char *) salt
.salt_buf
;
9127 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9129 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9133 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9135 memset (hccap
, 0, sizeof (hccap_t
));
9137 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9139 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9141 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9142 wpa_t
*wpa
= &wpas
[salt_pos
];
9144 hccap
->keyver
= wpa
->keyver
;
9146 hccap
->eapol_size
= wpa
->eapol_size
;
9148 if (wpa
->keyver
!= 1)
9150 uint eapol_tmp
[64] = { 0 };
9152 for (uint i
= 0; i
< 64; i
++)
9154 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9157 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9161 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9164 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9165 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9166 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9167 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9169 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9171 uint dgst_size
= data
.dgst_size
;
9173 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9175 if (wpa
->keyver
!= 1)
9177 uint digest_tmp
[4] = { 0 };
9179 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9180 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9181 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9182 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9184 memcpy (hccap
->keymic
, digest_tmp
, 16);
9188 memcpy (hccap
->keymic
, digest_ptr
, 16);
9192 void SuspendThreads ()
9194 if (data
.devices_status
!= STATUS_RUNNING
) return;
9196 hc_timer_set (&data
.timer_paused
);
9198 data
.devices_status
= STATUS_PAUSED
;
9200 log_info ("Paused");
9203 void ResumeThreads ()
9205 if (data
.devices_status
!= STATUS_PAUSED
) return;
9209 hc_timer_get (data
.timer_paused
, ms_paused
);
9211 data
.ms_paused
+= ms_paused
;
9213 data
.devices_status
= STATUS_RUNNING
;
9215 log_info ("Resumed");
9220 data
.devices_status
= STATUS_BYPASS
;
9222 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9225 void stop_at_checkpoint ()
9227 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9229 if (data
.devices_status
!= STATUS_RUNNING
) return;
9232 // this feature only makes sense if --restore-disable was not specified
9234 if (data
.restore_disable
== 1)
9236 log_info ("WARNING: This feature is disabled when --restore-disable is specified");
9241 // check if monitoring of Restore Point updates should be enabled or disabled
9243 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9245 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9247 // save the current restore point value
9249 data
.checkpoint_cur_words
= get_lowest_words_done ();
9251 log_info ("Checkpoint enabled: Will quit at next Restore Point update");
9255 data
.devices_status
= STATUS_RUNNING
;
9257 // reset the global value for checkpoint checks
9259 data
.checkpoint_cur_words
= 0;
9261 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9267 data
.devices_status
= STATUS_ABORTED
;
9272 data
.devices_status
= STATUS_QUIT
;
9275 void naive_replace (char *s
, const u8 key_char
, const u8 replace_char
)
9277 const size_t len
= strlen (s
);
9279 for (size_t in
= 0; in
< len
; in
++)
9285 s
[in
] = replace_char
;
9290 void naive_escape (char *s
, size_t s_max
, const u8 key_char
, const u8 escape_char
)
9292 char s_escaped
[1024] = { 0 };
9294 size_t s_escaped_max
= sizeof (s_escaped
);
9296 const size_t len
= strlen (s
);
9298 for (size_t in
= 0, out
= 0; in
< len
; in
++, out
++)
9304 s_escaped
[out
] = escape_char
;
9309 if (out
== s_escaped_max
- 2) break;
9314 strncpy (s
, s_escaped
, s_max
- 1);
9317 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9319 FILE *fp
= fopen (kernel_file
, "rb");
9325 memset (&st
, 0, sizeof (st
));
9327 stat (kernel_file
, &st
);
9329 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9331 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9333 if (num_read
!= (size_t) st
.st_size
)
9335 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9342 buf
[st
.st_size
] = 0;
9344 for (int i
= 0; i
< num_devices
; i
++)
9346 kernel_lengths
[i
] = (size_t) st
.st_size
;
9348 kernel_sources
[i
] = buf
;
9353 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9361 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9363 if (binary_size
> 0)
9365 FILE *fp
= fopen (dst
, "wb");
9368 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9379 restore_data_t
*init_restore (int argc
, char **argv
)
9381 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9383 if (data
.restore_disable
== 0)
9385 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9389 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9393 log_error ("ERROR: Cannot read %s", data
.eff_restore_file
);
9402 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9404 int pidbin_len
= -1;
9407 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9409 FILE *fd
= fopen (pidbin
, "rb");
9413 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9415 pidbin
[pidbin_len
] = 0;
9419 char *argv0_r
= strrchr (argv
[0], '/');
9421 char *pidbin_r
= strrchr (pidbin
, '/');
9423 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9425 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9427 if (strcmp (argv0_r
, pidbin_r
) == 0)
9429 log_error ("ERROR: Already an instance %s running on pid %d", pidbin
, rd
->pid
);
9436 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9438 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9440 int pidbin2_len
= -1;
9442 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9443 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9445 pidbin
[pidbin_len
] = 0;
9446 pidbin2
[pidbin2_len
] = 0;
9450 if (strcmp (pidbin
, pidbin2
) == 0)
9452 log_error ("ERROR: Already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9465 if (rd
->version_bin
< RESTORE_MIN
)
9467 log_error ("ERROR: Cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9474 memset (rd
, 0, sizeof (restore_data_t
));
9476 rd
->version_bin
= VERSION_BIN
;
9479 rd
->pid
= getpid ();
9481 rd
->pid
= GetCurrentProcessId ();
9484 if (getcwd (rd
->cwd
, 255) == NULL
)
9497 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9499 FILE *fp
= fopen (eff_restore_file
, "rb");
9503 log_error ("ERROR: Restore file '%s': %s", eff_restore_file
, strerror (errno
));
9508 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9510 log_error ("ERROR: Can't read %s", eff_restore_file
);
9515 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9517 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9519 for (uint i
= 0; i
< rd
->argc
; i
++)
9521 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9523 log_error ("ERROR: Can't read %s", eff_restore_file
);
9528 size_t len
= strlen (buf
);
9530 if (len
) buf
[len
- 1] = 0;
9532 rd
->argv
[i
] = mystrdup (buf
);
9539 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9541 if (chdir (rd
->cwd
))
9543 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9544 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9545 " https://github.com/philsmd/analyze_hc_restore\n"
9546 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9552 u64
get_lowest_words_done ()
9556 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9558 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9560 if (device_param
->skipped
) continue;
9562 const u64 words_done
= device_param
->words_done
;
9564 if (words_done
< words_cur
) words_cur
= words_done
;
9567 // It's possible that a device's workload isn't finished right after a restore-case.
9568 // In that case, this function would return 0 and overwrite the real restore point
9569 // There's also data.words_cur which is set to rd->words_cur but it changes while
9570 // the attack is running therefore we should stick to rd->words_cur.
9571 // Note that -s influences rd->words_cur we should keep a close look on that.
9573 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9578 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9580 u64 words_cur
= get_lowest_words_done ();
9582 rd
->words_cur
= words_cur
;
9584 FILE *fp
= fopen (new_restore_file
, "wb");
9588 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9593 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9595 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9600 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9602 for (uint i
= 0; i
< rd
->argc
; i
++)
9604 fprintf (fp
, "%s", rd
->argv
[i
]);
9610 fsync (fileno (fp
));
9615 void cycle_restore ()
9617 const char *eff_restore_file
= data
.eff_restore_file
;
9618 const char *new_restore_file
= data
.new_restore_file
;
9620 restore_data_t
*rd
= data
.rd
;
9622 write_restore (new_restore_file
, rd
);
9626 memset (&st
, 0, sizeof(st
));
9628 if (stat (eff_restore_file
, &st
) == 0)
9630 if (unlink (eff_restore_file
))
9632 log_info ("WARN: Unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9636 if (rename (new_restore_file
, eff_restore_file
))
9638 log_info ("WARN: Rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9642 void check_checkpoint ()
9644 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9646 u64 words_cur
= get_lowest_words_done ();
9648 if (words_cur
!= data
.checkpoint_cur_words
)
9658 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9662 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9664 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9666 myfree (alias
->device_name
);
9667 myfree (alias
->alias_name
);
9670 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9672 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9674 myfree (entry
->device_name
);
9677 myfree (tuning_db
->alias_buf
);
9678 myfree (tuning_db
->entry_buf
);
9683 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9685 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9687 int num_lines
= count_lines (fp
);
9689 // a bit over-allocated
9691 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9692 tuning_db
->alias_cnt
= 0;
9694 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9695 tuning_db
->entry_cnt
= 0;
9700 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9702 FILE *fp
= fopen (tuning_db_file
, "rb");
9706 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9711 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9717 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9721 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9723 if (line_buf
== NULL
) break;
9727 const int line_len
= in_superchop (line_buf
);
9729 if (line_len
== 0) continue;
9731 if (line_buf
[0] == '#') continue;
9735 char *token_ptr
[7] = { NULL
};
9739 char *next
= strtok (line_buf
, "\t ");
9741 token_ptr
[token_cnt
] = next
;
9745 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9747 token_ptr
[token_cnt
] = next
;
9754 char *device_name
= token_ptr
[0];
9755 char *alias_name
= token_ptr
[1];
9757 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9759 alias
->device_name
= mystrdup (device_name
);
9760 alias
->alias_name
= mystrdup (alias_name
);
9762 tuning_db
->alias_cnt
++;
9764 else if (token_cnt
== 6)
9766 if ((token_ptr
[1][0] != '0') &&
9767 (token_ptr
[1][0] != '1') &&
9768 (token_ptr
[1][0] != '3') &&
9769 (token_ptr
[1][0] != '*'))
9771 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9776 if ((token_ptr
[3][0] != '1') &&
9777 (token_ptr
[3][0] != '2') &&
9778 (token_ptr
[3][0] != '4') &&
9779 (token_ptr
[3][0] != '8') &&
9780 (token_ptr
[3][0] != 'N'))
9782 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9787 char *device_name
= token_ptr
[0];
9789 int attack_mode
= -1;
9791 int vector_width
= -1;
9792 int kernel_accel
= -1;
9793 int kernel_loops
= -1;
9795 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9796 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9797 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9799 if (token_ptr
[4][0] != 'A')
9801 kernel_accel
= atoi (token_ptr
[4]);
9803 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9805 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9815 if (token_ptr
[5][0] != 'A')
9817 kernel_loops
= atoi (token_ptr
[5]);
9819 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9821 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9831 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9833 entry
->device_name
= mystrdup (device_name
);
9834 entry
->attack_mode
= attack_mode
;
9835 entry
->hash_type
= hash_type
;
9836 entry
->vector_width
= vector_width
;
9837 entry
->kernel_accel
= kernel_accel
;
9838 entry
->kernel_loops
= kernel_loops
;
9840 tuning_db
->entry_cnt
++;
9844 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9854 // todo: print loaded 'cnt' message
9856 // sort the database
9858 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9859 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9864 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9866 static tuning_db_entry_t s
;
9868 // first we need to convert all spaces in the device_name to underscore
9870 char *device_name_nospace
= strdup (device_param
->device_name
);
9872 int device_name_length
= strlen (device_name_nospace
);
9876 for (i
= 0; i
< device_name_length
; i
++)
9878 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9881 // find out if there's an alias configured
9883 tuning_db_alias_t a
;
9885 a
.device_name
= device_name_nospace
;
9887 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
);
9889 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9891 // attack-mode 6 and 7 are attack-mode 1 basically
9893 if (attack_mode
== 6) attack_mode
= 1;
9894 if (attack_mode
== 7) attack_mode
= 1;
9896 // bsearch is not ideal but fast enough
9898 s
.device_name
= device_name_nospace
;
9899 s
.attack_mode
= attack_mode
;
9900 s
.hash_type
= hash_type
;
9902 tuning_db_entry_t
*entry
= NULL
;
9904 // this will produce all 2^3 combinations required
9906 for (i
= 0; i
< 8; i
++)
9908 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9909 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9910 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9912 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9914 if (entry
!= NULL
) break;
9916 // in non-wildcard mode do some additional checks:
9920 // in case we have an alias-name
9922 if (alias_name
!= NULL
)
9924 s
.device_name
= alias_name
;
9926 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9928 if (entry
!= NULL
) break;
9931 // or by device type
9933 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9935 s
.device_name
= "DEVICE_TYPE_CPU";
9937 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9939 s
.device_name
= "DEVICE_TYPE_GPU";
9941 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9943 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9946 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9948 if (entry
!= NULL
) break;
9952 // free converted device_name
9954 myfree (device_name_nospace
);
9963 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9965 u8 tmp
[256] = { 0 };
9967 if (salt_len
> sizeof (tmp
))
9972 memcpy (tmp
, in
, salt_len
);
9974 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9976 if ((salt_len
% 2) == 0)
9978 u32 new_salt_len
= salt_len
/ 2;
9980 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9985 tmp
[i
] = hex_convert (p1
) << 0;
9986 tmp
[i
] |= hex_convert (p0
) << 4;
9989 salt_len
= new_salt_len
;
9996 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9998 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
10001 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
10003 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
10007 u32
*tmp_uint
= (u32
*) tmp
;
10009 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
10010 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
10011 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
10012 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
10013 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
10014 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
10015 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
10016 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
10017 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
10018 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
10020 salt_len
= salt_len
* 2;
10028 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
10030 lowercase (tmp
, salt_len
);
10033 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
10035 uppercase (tmp
, salt_len
);
10038 u32 len
= salt_len
;
10040 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
10045 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
10050 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
10052 u32
*tmp_uint
= (uint
*) tmp
;
10056 if (len
% 4) max
++;
10058 for (u32 i
= 0; i
< max
; i
++)
10060 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
10063 // Important: we may need to increase the length of memcpy since
10064 // we don't want to "loose" some swapped bytes (could happen if
10065 // they do not perfectly fit in the 4-byte blocks)
10066 // Memcpy does always copy the bytes in the BE order, but since
10067 // we swapped them, some important bytes could be in positions
10068 // we normally skip with the original len
10070 if (len
% 4) len
+= 4 - (len
% 4);
10073 memcpy (out
, tmp
, len
);
10078 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10080 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
10082 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
10084 u32
*digest
= (u32
*) hash_buf
->digest
;
10086 salt_t
*salt
= hash_buf
->salt
;
10088 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
10090 char *iter_pos
= input_buf
+ 4;
10092 salt
->salt_iter
= 1 << atoi (iter_pos
);
10094 char *salt_pos
= strchr (iter_pos
, '$');
10096 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10100 uint salt_len
= 16;
10102 salt
->salt_len
= salt_len
;
10104 u8 tmp_buf
[100] = { 0 };
10106 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
10108 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10110 memcpy (salt_buf_ptr
, tmp_buf
, 16);
10112 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
10113 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
10114 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
10115 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
10117 char *hash_pos
= salt_pos
+ 22;
10119 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10121 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
10123 memcpy (digest
, tmp_buf
, 24);
10125 digest
[0] = byte_swap_32 (digest
[0]);
10126 digest
[1] = byte_swap_32 (digest
[1]);
10127 digest
[2] = byte_swap_32 (digest
[2]);
10128 digest
[3] = byte_swap_32 (digest
[3]);
10129 digest
[4] = byte_swap_32 (digest
[4]);
10130 digest
[5] = byte_swap_32 (digest
[5]);
10132 digest
[5] &= ~0xff; // its just 23 not 24 !
10134 return (PARSER_OK
);
10137 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10139 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10141 u32
*digest
= (u32
*) hash_buf
->digest
;
10143 u8 tmp_buf
[100] = { 0 };
10145 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10147 memcpy (digest
, tmp_buf
, 32);
10149 digest
[0] = byte_swap_32 (digest
[0]);
10150 digest
[1] = byte_swap_32 (digest
[1]);
10151 digest
[2] = byte_swap_32 (digest
[2]);
10152 digest
[3] = byte_swap_32 (digest
[3]);
10153 digest
[4] = byte_swap_32 (digest
[4]);
10154 digest
[5] = byte_swap_32 (digest
[5]);
10155 digest
[6] = byte_swap_32 (digest
[6]);
10156 digest
[7] = byte_swap_32 (digest
[7]);
10158 digest
[0] -= SHA256M_A
;
10159 digest
[1] -= SHA256M_B
;
10160 digest
[2] -= SHA256M_C
;
10161 digest
[3] -= SHA256M_D
;
10162 digest
[4] -= SHA256M_E
;
10163 digest
[5] -= SHA256M_F
;
10164 digest
[6] -= SHA256M_G
;
10165 digest
[7] -= SHA256M_H
;
10167 return (PARSER_OK
);
10170 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10172 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10174 u32
*digest
= (u32
*) hash_buf
->digest
;
10176 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10177 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10179 digest
[0] = byte_swap_32 (digest
[0]);
10180 digest
[1] = byte_swap_32 (digest
[1]);
10184 IP (digest
[0], digest
[1], tt
);
10186 digest
[0] = digest
[0];
10187 digest
[1] = digest
[1];
10191 return (PARSER_OK
);
10194 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10196 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10198 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10200 u32
*digest
= (u32
*) hash_buf
->digest
;
10202 salt_t
*salt
= hash_buf
->salt
;
10204 char *hash_pos
= input_buf
+ 10;
10206 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10207 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10208 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10209 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10210 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10212 digest
[0] -= SHA1M_A
;
10213 digest
[1] -= SHA1M_B
;
10214 digest
[2] -= SHA1M_C
;
10215 digest
[3] -= SHA1M_D
;
10216 digest
[4] -= SHA1M_E
;
10218 uint salt_len
= 10;
10220 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10222 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10224 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10226 salt
->salt_len
= salt_len
;
10228 return (PARSER_OK
);
10231 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10233 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10235 u32
*digest
= (u32
*) hash_buf
->digest
;
10237 salt_t
*salt
= hash_buf
->salt
;
10239 char *hash_pos
= input_buf
+ 8;
10241 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10242 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10243 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10244 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10245 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10247 digest
[0] -= SHA1M_A
;
10248 digest
[1] -= SHA1M_B
;
10249 digest
[2] -= SHA1M_C
;
10250 digest
[3] -= SHA1M_D
;
10251 digest
[4] -= SHA1M_E
;
10255 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10257 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10259 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10261 salt
->salt_len
= salt_len
;
10263 return (PARSER_OK
);
10266 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10268 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10270 u64
*digest
= (u64
*) hash_buf
->digest
;
10272 salt_t
*salt
= hash_buf
->salt
;
10274 char *hash_pos
= input_buf
+ 8;
10276 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10277 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10278 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10279 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10280 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10281 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10282 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10283 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10285 digest
[0] -= SHA512M_A
;
10286 digest
[1] -= SHA512M_B
;
10287 digest
[2] -= SHA512M_C
;
10288 digest
[3] -= SHA512M_D
;
10289 digest
[4] -= SHA512M_E
;
10290 digest
[5] -= SHA512M_F
;
10291 digest
[6] -= SHA512M_G
;
10292 digest
[7] -= SHA512M_H
;
10296 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10298 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10300 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10302 salt
->salt_len
= salt_len
;
10304 return (PARSER_OK
);
10307 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10309 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10311 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10315 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10318 u32
*digest
= (u32
*) hash_buf
->digest
;
10320 salt_t
*salt
= hash_buf
->salt
;
10322 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10323 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10324 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10325 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10327 digest
[0] = byte_swap_32 (digest
[0]);
10328 digest
[1] = byte_swap_32 (digest
[1]);
10329 digest
[2] = byte_swap_32 (digest
[2]);
10330 digest
[3] = byte_swap_32 (digest
[3]);
10332 digest
[0] -= MD5M_A
;
10333 digest
[1] -= MD5M_B
;
10334 digest
[2] -= MD5M_C
;
10335 digest
[3] -= MD5M_D
;
10337 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10339 uint salt_len
= input_len
- 32 - 1;
10341 char *salt_buf
= input_buf
+ 32 + 1;
10343 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10345 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10347 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10349 salt
->salt_len
= salt_len
;
10351 return (PARSER_OK
);
10354 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10356 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10358 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10362 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10367 char clean_input_buf
[32] = { 0 };
10369 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10370 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10372 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10376 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10382 clean_input_buf
[k
] = input_buf
[i
];
10390 u32
*digest
= (u32
*) hash_buf
->digest
;
10392 salt_t
*salt
= hash_buf
->salt
;
10394 u32 a
, b
, c
, d
, e
, f
;
10396 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10397 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10398 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10399 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10400 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10401 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10403 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10404 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10406 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10407 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10408 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10409 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10410 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10411 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10413 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10414 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10416 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10417 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10418 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10419 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10420 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10421 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10423 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10424 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10426 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10427 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10428 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10429 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10430 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10431 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10433 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10434 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10436 digest
[0] = byte_swap_32 (digest
[0]);
10437 digest
[1] = byte_swap_32 (digest
[1]);
10438 digest
[2] = byte_swap_32 (digest
[2]);
10439 digest
[3] = byte_swap_32 (digest
[3]);
10441 digest
[0] -= MD5M_A
;
10442 digest
[1] -= MD5M_B
;
10443 digest
[2] -= MD5M_C
;
10444 digest
[3] -= MD5M_D
;
10446 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10448 uint salt_len
= input_len
- 30 - 1;
10450 char *salt_buf
= input_buf
+ 30 + 1;
10452 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10454 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10456 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10457 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10459 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10461 salt
->salt_len
= salt_len
;
10463 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10465 salt
->salt_len
+= 22;
10467 return (PARSER_OK
);
10470 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10472 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10474 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10478 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10481 u32
*digest
= (u32
*) hash_buf
->digest
;
10483 salt_t
*salt
= hash_buf
->salt
;
10485 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10486 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10487 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10488 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10489 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10491 digest
[0] -= SHA1M_A
;
10492 digest
[1] -= SHA1M_B
;
10493 digest
[2] -= SHA1M_C
;
10494 digest
[3] -= SHA1M_D
;
10495 digest
[4] -= SHA1M_E
;
10497 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10499 uint salt_len
= input_len
- 40 - 1;
10501 char *salt_buf
= input_buf
+ 40 + 1;
10503 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10505 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10507 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10509 salt
->salt_len
= salt_len
;
10511 return (PARSER_OK
);
10514 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10516 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10518 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10522 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10525 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10527 char *iter_pos
= input_buf
+ 6;
10529 salt_t
*salt
= hash_buf
->salt
;
10531 uint iter
= atoi (iter_pos
);
10535 iter
= ROUNDS_DCC2
;
10538 salt
->salt_iter
= iter
- 1;
10540 char *salt_pos
= strchr (iter_pos
, '#');
10542 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10546 char *digest_pos
= strchr (salt_pos
, '#');
10548 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10552 uint salt_len
= digest_pos
- salt_pos
- 1;
10554 u32
*digest
= (u32
*) hash_buf
->digest
;
10556 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10557 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10558 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10559 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10561 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10563 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10565 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10567 salt
->salt_len
= salt_len
;
10569 return (PARSER_OK
);
10572 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10574 u32
*digest
= (u32
*) hash_buf
->digest
;
10576 salt_t
*salt
= hash_buf
->salt
;
10578 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10582 memcpy (&in
, input_buf
, input_len
);
10584 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10586 memcpy (digest
, in
.keymic
, 16);
10589 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10590 The phrase "Pairwise key expansion"
10591 Access Point Address (referred to as Authenticator Address AA)
10592 Supplicant Address (referred to as Supplicant Address SA)
10593 Access Point Nonce (referred to as Authenticator Anonce)
10594 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10597 uint salt_len
= strlen (in
.essid
);
10601 log_info ("WARNING: The ESSID length is too long, the hccap file may be invalid or corrupted");
10603 return (PARSER_SALT_LENGTH
);
10606 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10608 salt
->salt_len
= salt_len
;
10610 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10612 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10614 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10616 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10618 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10619 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10623 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10624 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10627 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10629 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10630 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10634 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10635 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10638 for (int i
= 0; i
< 25; i
++)
10640 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10643 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10644 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10645 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10646 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10648 wpa
->keyver
= in
.keyver
;
10650 if (wpa
->keyver
> 255)
10652 log_info ("ATTENTION!");
10653 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10654 log_info (" This could be due to a recent aircrack-ng bug.");
10655 log_info (" The key version was automatically reset to a reasonable value.");
10658 wpa
->keyver
&= 0xff;
10661 wpa
->eapol_size
= in
.eapol_size
;
10663 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10665 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10667 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10669 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10671 if (wpa
->keyver
== 1)
10677 digest
[0] = byte_swap_32 (digest
[0]);
10678 digest
[1] = byte_swap_32 (digest
[1]);
10679 digest
[2] = byte_swap_32 (digest
[2]);
10680 digest
[3] = byte_swap_32 (digest
[3]);
10682 for (int i
= 0; i
< 64; i
++)
10684 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10688 uint32_t *p0
= (uint32_t *) in
.essid
;
10692 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10693 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10695 salt
->salt_buf
[10] = c0
;
10696 salt
->salt_buf
[11] = c1
;
10698 return (PARSER_OK
);
10701 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10703 u32
*digest
= (u32
*) hash_buf
->digest
;
10705 salt_t
*salt
= hash_buf
->salt
;
10707 if (input_len
== 0)
10709 log_error ("Password Safe v2 container not specified");
10714 FILE *fp
= fopen (input_buf
, "rb");
10718 log_error ("%s: %s", input_buf
, strerror (errno
));
10725 memset (&buf
, 0, sizeof (psafe2_hdr
));
10727 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10731 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10733 salt
->salt_buf
[0] = buf
.random
[0];
10734 salt
->salt_buf
[1] = buf
.random
[1];
10736 salt
->salt_len
= 8;
10737 salt
->salt_iter
= 1000;
10739 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10740 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10741 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10742 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10743 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10745 return (PARSER_OK
);
10748 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10750 u32
*digest
= (u32
*) hash_buf
->digest
;
10752 salt_t
*salt
= hash_buf
->salt
;
10754 if (input_len
== 0)
10756 log_error (".psafe3 not specified");
10761 FILE *fp
= fopen (input_buf
, "rb");
10765 log_error ("%s: %s", input_buf
, strerror (errno
));
10772 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10776 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10778 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10780 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10782 salt
->salt_iter
= in
.iterations
+ 1;
10784 salt
->salt_buf
[0] = in
.salt_buf
[0];
10785 salt
->salt_buf
[1] = in
.salt_buf
[1];
10786 salt
->salt_buf
[2] = in
.salt_buf
[2];
10787 salt
->salt_buf
[3] = in
.salt_buf
[3];
10788 salt
->salt_buf
[4] = in
.salt_buf
[4];
10789 salt
->salt_buf
[5] = in
.salt_buf
[5];
10790 salt
->salt_buf
[6] = in
.salt_buf
[6];
10791 salt
->salt_buf
[7] = in
.salt_buf
[7];
10793 salt
->salt_len
= 32;
10795 digest
[0] = in
.hash_buf
[0];
10796 digest
[1] = in
.hash_buf
[1];
10797 digest
[2] = in
.hash_buf
[2];
10798 digest
[3] = in
.hash_buf
[3];
10799 digest
[4] = in
.hash_buf
[4];
10800 digest
[5] = in
.hash_buf
[5];
10801 digest
[6] = in
.hash_buf
[6];
10802 digest
[7] = in
.hash_buf
[7];
10804 digest
[0] = byte_swap_32 (digest
[0]);
10805 digest
[1] = byte_swap_32 (digest
[1]);
10806 digest
[2] = byte_swap_32 (digest
[2]);
10807 digest
[3] = byte_swap_32 (digest
[3]);
10808 digest
[4] = byte_swap_32 (digest
[4]);
10809 digest
[5] = byte_swap_32 (digest
[5]);
10810 digest
[6] = byte_swap_32 (digest
[6]);
10811 digest
[7] = byte_swap_32 (digest
[7]);
10813 return (PARSER_OK
);
10816 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10818 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10820 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10822 u32
*digest
= (u32
*) hash_buf
->digest
;
10824 salt_t
*salt
= hash_buf
->salt
;
10826 char *iter_pos
= input_buf
+ 3;
10828 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10830 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10832 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10834 salt
->salt_iter
= salt_iter
;
10836 char *salt_pos
= iter_pos
+ 1;
10840 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10842 salt
->salt_len
= salt_len
;
10844 char *hash_pos
= salt_pos
+ salt_len
;
10846 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10848 return (PARSER_OK
);
10851 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10853 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10855 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10857 u32
*digest
= (u32
*) hash_buf
->digest
;
10859 salt_t
*salt
= hash_buf
->salt
;
10861 char *salt_pos
= input_buf
+ 3;
10863 uint iterations_len
= 0;
10865 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10869 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10871 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10872 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10876 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10880 iterations_len
+= 8;
10884 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10887 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10889 char *hash_pos
= strchr (salt_pos
, '$');
10891 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10893 uint salt_len
= hash_pos
- salt_pos
;
10895 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10897 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10899 salt
->salt_len
= salt_len
;
10903 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10905 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10907 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10909 return (PARSER_OK
);
10912 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10914 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10916 u32
*digest
= (u32
*) hash_buf
->digest
;
10918 salt_t
*salt
= hash_buf
->salt
;
10920 char *salt_pos
= input_buf
+ 6;
10922 uint iterations_len
= 0;
10924 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10928 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10930 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10931 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10935 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10939 iterations_len
+= 8;
10943 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10946 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10948 char *hash_pos
= strchr (salt_pos
, '$');
10950 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10952 uint salt_len
= hash_pos
- salt_pos
;
10954 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10956 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10958 salt
->salt_len
= salt_len
;
10962 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10964 return (PARSER_OK
);
10967 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10969 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10971 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10973 u32
*digest
= (u32
*) hash_buf
->digest
;
10975 salt_t
*salt
= hash_buf
->salt
;
10977 char *salt_pos
= input_buf
+ 14;
10979 char *hash_pos
= strchr (salt_pos
, '*');
10981 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10985 uint salt_len
= hash_pos
- salt_pos
- 1;
10987 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10989 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10991 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10993 salt
->salt_len
= salt_len
;
10995 u8 tmp_buf
[100] = { 0 };
10997 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10999 memcpy (digest
, tmp_buf
, 20);
11001 digest
[0] = byte_swap_32 (digest
[0]);
11002 digest
[1] = byte_swap_32 (digest
[1]);
11003 digest
[2] = byte_swap_32 (digest
[2]);
11004 digest
[3] = byte_swap_32 (digest
[3]);
11005 digest
[4] = byte_swap_32 (digest
[4]);
11007 digest
[0] -= SHA1M_A
;
11008 digest
[1] -= SHA1M_B
;
11009 digest
[2] -= SHA1M_C
;
11010 digest
[3] -= SHA1M_D
;
11011 digest
[4] -= SHA1M_E
;
11013 return (PARSER_OK
);
11016 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11018 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
11020 unsigned char c12
= itoa64_to_int (input_buf
[12]);
11022 if (c12
& 3) return (PARSER_HASH_VALUE
);
11024 u32
*digest
= (u32
*) hash_buf
->digest
;
11026 salt_t
*salt
= hash_buf
->salt
;
11028 // for ascii_digest
11029 salt
->salt_sign
[0] = input_buf
[0];
11030 salt
->salt_sign
[1] = input_buf
[1];
11032 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
11033 | itoa64_to_int (input_buf
[1]) << 6;
11035 salt
->salt_len
= 2;
11037 u8 tmp_buf
[100] = { 0 };
11039 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
11041 memcpy (digest
, tmp_buf
, 8);
11045 IP (digest
[0], digest
[1], tt
);
11050 return (PARSER_OK
);
11053 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11055 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) 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] -= MD4M_A
;
11070 digest
[1] -= MD4M_B
;
11071 digest
[2] -= MD4M_C
;
11072 digest
[3] -= MD4M_D
;
11074 return (PARSER_OK
);
11077 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11079 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11081 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
11085 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
11088 u32
*digest
= (u32
*) hash_buf
->digest
;
11090 salt_t
*salt
= hash_buf
->salt
;
11092 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11093 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11094 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11095 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11097 digest
[0] = byte_swap_32 (digest
[0]);
11098 digest
[1] = byte_swap_32 (digest
[1]);
11099 digest
[2] = byte_swap_32 (digest
[2]);
11100 digest
[3] = byte_swap_32 (digest
[3]);
11102 digest
[0] -= MD4M_A
;
11103 digest
[1] -= MD4M_B
;
11104 digest
[2] -= MD4M_C
;
11105 digest
[3] -= MD4M_D
;
11107 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11109 uint salt_len
= input_len
- 32 - 1;
11111 char *salt_buf
= input_buf
+ 32 + 1;
11113 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11115 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11117 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11119 salt
->salt_len
= salt_len
;
11121 return (PARSER_OK
);
11124 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11126 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
11128 u32
*digest
= (u32
*) hash_buf
->digest
;
11130 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11131 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11132 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11133 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11135 digest
[0] = byte_swap_32 (digest
[0]);
11136 digest
[1] = byte_swap_32 (digest
[1]);
11137 digest
[2] = byte_swap_32 (digest
[2]);
11138 digest
[3] = byte_swap_32 (digest
[3]);
11140 digest
[0] -= MD5M_A
;
11141 digest
[1] -= MD5M_B
;
11142 digest
[2] -= MD5M_C
;
11143 digest
[3] -= MD5M_D
;
11145 return (PARSER_OK
);
11148 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11150 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11152 u32
*digest
= (u32
*) hash_buf
->digest
;
11154 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11155 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11159 digest
[0] = byte_swap_32 (digest
[0]);
11160 digest
[1] = byte_swap_32 (digest
[1]);
11162 return (PARSER_OK
);
11165 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11167 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11169 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11173 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11176 u32
*digest
= (u32
*) hash_buf
->digest
;
11178 salt_t
*salt
= hash_buf
->salt
;
11180 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11181 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11182 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11183 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11185 digest
[0] = byte_swap_32 (digest
[0]);
11186 digest
[1] = byte_swap_32 (digest
[1]);
11187 digest
[2] = byte_swap_32 (digest
[2]);
11188 digest
[3] = byte_swap_32 (digest
[3]);
11190 digest
[0] -= MD5M_A
;
11191 digest
[1] -= MD5M_B
;
11192 digest
[2] -= MD5M_C
;
11193 digest
[3] -= MD5M_D
;
11195 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11197 uint salt_len
= input_len
- 32 - 1;
11199 char *salt_buf
= input_buf
+ 32 + 1;
11201 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11203 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11205 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11207 salt
->salt_len
= salt_len
;
11209 return (PARSER_OK
);
11212 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11214 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11216 u32
*digest
= (u32
*) hash_buf
->digest
;
11218 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11219 | itoa64_to_int (input_buf
[ 1]) << 6
11220 | itoa64_to_int (input_buf
[ 2]) << 12
11221 | itoa64_to_int (input_buf
[ 3]) << 18;
11222 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11223 | itoa64_to_int (input_buf
[ 5]) << 6
11224 | itoa64_to_int (input_buf
[ 6]) << 12
11225 | itoa64_to_int (input_buf
[ 7]) << 18;
11226 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11227 | itoa64_to_int (input_buf
[ 9]) << 6
11228 | itoa64_to_int (input_buf
[10]) << 12
11229 | itoa64_to_int (input_buf
[11]) << 18;
11230 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11231 | itoa64_to_int (input_buf
[13]) << 6
11232 | itoa64_to_int (input_buf
[14]) << 12
11233 | itoa64_to_int (input_buf
[15]) << 18;
11235 digest
[0] -= MD5M_A
;
11236 digest
[1] -= MD5M_B
;
11237 digest
[2] -= MD5M_C
;
11238 digest
[3] -= MD5M_D
;
11240 digest
[0] &= 0x00ffffff;
11241 digest
[1] &= 0x00ffffff;
11242 digest
[2] &= 0x00ffffff;
11243 digest
[3] &= 0x00ffffff;
11245 return (PARSER_OK
);
11248 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11250 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11252 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11256 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11259 u32
*digest
= (u32
*) hash_buf
->digest
;
11261 salt_t
*salt
= hash_buf
->salt
;
11263 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11264 | itoa64_to_int (input_buf
[ 1]) << 6
11265 | itoa64_to_int (input_buf
[ 2]) << 12
11266 | itoa64_to_int (input_buf
[ 3]) << 18;
11267 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11268 | itoa64_to_int (input_buf
[ 5]) << 6
11269 | itoa64_to_int (input_buf
[ 6]) << 12
11270 | itoa64_to_int (input_buf
[ 7]) << 18;
11271 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11272 | itoa64_to_int (input_buf
[ 9]) << 6
11273 | itoa64_to_int (input_buf
[10]) << 12
11274 | itoa64_to_int (input_buf
[11]) << 18;
11275 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11276 | itoa64_to_int (input_buf
[13]) << 6
11277 | itoa64_to_int (input_buf
[14]) << 12
11278 | itoa64_to_int (input_buf
[15]) << 18;
11280 digest
[0] -= MD5M_A
;
11281 digest
[1] -= MD5M_B
;
11282 digest
[2] -= MD5M_C
;
11283 digest
[3] -= MD5M_D
;
11285 digest
[0] &= 0x00ffffff;
11286 digest
[1] &= 0x00ffffff;
11287 digest
[2] &= 0x00ffffff;
11288 digest
[3] &= 0x00ffffff;
11290 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11292 uint salt_len
= input_len
- 16 - 1;
11294 char *salt_buf
= input_buf
+ 16 + 1;
11296 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11298 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11300 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11302 salt
->salt_len
= salt_len
;
11304 return (PARSER_OK
);
11307 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11309 key
[0] = (nthash
[0] >> 0);
11310 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11311 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11312 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11313 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11314 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11315 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11316 key
[7] = (nthash
[6] << 1);
11328 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11330 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11332 u32
*digest
= (u32
*) hash_buf
->digest
;
11334 salt_t
*salt
= hash_buf
->salt
;
11336 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11342 char *user_pos
= input_buf
;
11344 char *unused_pos
= strchr (user_pos
, ':');
11346 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11348 uint user_len
= unused_pos
- user_pos
;
11350 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11354 char *domain_pos
= strchr (unused_pos
, ':');
11356 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11358 uint unused_len
= domain_pos
- unused_pos
;
11360 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11364 char *srvchall_pos
= strchr (domain_pos
, ':');
11366 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11368 uint domain_len
= srvchall_pos
- domain_pos
;
11370 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11374 char *hash_pos
= strchr (srvchall_pos
, ':');
11376 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11378 uint srvchall_len
= hash_pos
- srvchall_pos
;
11380 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11384 char *clichall_pos
= strchr (hash_pos
, ':');
11386 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11388 uint hash_len
= clichall_pos
- hash_pos
;
11390 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11394 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11396 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11399 * store some data for later use
11402 netntlm
->user_len
= user_len
* 2;
11403 netntlm
->domain_len
= domain_len
* 2;
11404 netntlm
->srvchall_len
= srvchall_len
/ 2;
11405 netntlm
->clichall_len
= clichall_len
/ 2;
11407 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11408 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11411 * handle username and domainname
11414 for (uint i
= 0; i
< user_len
; i
++)
11416 *userdomain_ptr
++ = user_pos
[i
];
11417 *userdomain_ptr
++ = 0;
11420 for (uint i
= 0; i
< domain_len
; i
++)
11422 *userdomain_ptr
++ = domain_pos
[i
];
11423 *userdomain_ptr
++ = 0;
11427 * handle server challenge encoding
11430 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11432 const char p0
= srvchall_pos
[i
+ 0];
11433 const char p1
= srvchall_pos
[i
+ 1];
11435 *chall_ptr
++ = hex_convert (p1
) << 0
11436 | hex_convert (p0
) << 4;
11440 * handle client challenge encoding
11443 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11445 const char p0
= clichall_pos
[i
+ 0];
11446 const char p1
= clichall_pos
[i
+ 1];
11448 *chall_ptr
++ = hex_convert (p1
) << 0
11449 | hex_convert (p0
) << 4;
11456 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11458 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11460 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11462 salt
->salt_len
= salt_len
;
11464 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11465 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11466 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11467 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11469 digest
[0] = byte_swap_32 (digest
[0]);
11470 digest
[1] = byte_swap_32 (digest
[1]);
11471 digest
[2] = byte_swap_32 (digest
[2]);
11472 digest
[3] = byte_swap_32 (digest
[3]);
11474 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11476 uint digest_tmp
[2] = { 0 };
11478 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11479 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11481 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11482 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11484 /* special case 2: ESS */
11486 if (srvchall_len
== 48)
11488 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11490 uint w
[16] = { 0 };
11492 w
[ 0] = netntlm
->chall_buf
[6];
11493 w
[ 1] = netntlm
->chall_buf
[7];
11494 w
[ 2] = netntlm
->chall_buf
[0];
11495 w
[ 3] = netntlm
->chall_buf
[1];
11499 uint dgst
[4] = { 0 };
11508 salt
->salt_buf
[0] = dgst
[0];
11509 salt
->salt_buf
[1] = dgst
[1];
11513 /* precompute netntlmv1 exploit start */
11515 for (uint i
= 0; i
< 0x10000; i
++)
11517 uint key_md4
[2] = { i
, 0 };
11518 uint key_des
[2] = { 0, 0 };
11520 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11522 uint Kc
[16] = { 0 };
11523 uint Kd
[16] = { 0 };
11525 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11527 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11529 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11531 if (data3
[0] != digest_tmp
[0]) continue;
11532 if (data3
[1] != digest_tmp
[1]) continue;
11534 salt
->salt_buf
[2] = i
;
11536 salt
->salt_len
= 24;
11541 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11542 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11544 /* precompute netntlmv1 exploit stop */
11548 IP (digest
[0], digest
[1], tt
);
11549 IP (digest
[2], digest
[3], tt
);
11551 digest
[0] = rotr32 (digest
[0], 29);
11552 digest
[1] = rotr32 (digest
[1], 29);
11553 digest
[2] = rotr32 (digest
[2], 29);
11554 digest
[3] = rotr32 (digest
[3], 29);
11556 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11558 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11559 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11561 return (PARSER_OK
);
11564 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11566 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11568 u32
*digest
= (u32
*) hash_buf
->digest
;
11570 salt_t
*salt
= hash_buf
->salt
;
11572 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11578 char *user_pos
= input_buf
;
11580 char *unused_pos
= strchr (user_pos
, ':');
11582 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11584 uint user_len
= unused_pos
- user_pos
;
11586 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11590 char *domain_pos
= strchr (unused_pos
, ':');
11592 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11594 uint unused_len
= domain_pos
- unused_pos
;
11596 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11600 char *srvchall_pos
= strchr (domain_pos
, ':');
11602 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11604 uint domain_len
= srvchall_pos
- domain_pos
;
11606 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11610 char *hash_pos
= strchr (srvchall_pos
, ':');
11612 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11614 uint srvchall_len
= hash_pos
- srvchall_pos
;
11616 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11620 char *clichall_pos
= strchr (hash_pos
, ':');
11622 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11624 uint hash_len
= clichall_pos
- hash_pos
;
11626 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11630 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11632 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11634 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11637 * store some data for later use
11640 netntlm
->user_len
= user_len
* 2;
11641 netntlm
->domain_len
= domain_len
* 2;
11642 netntlm
->srvchall_len
= srvchall_len
/ 2;
11643 netntlm
->clichall_len
= clichall_len
/ 2;
11645 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11646 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11649 * handle username and domainname
11652 for (uint i
= 0; i
< user_len
; i
++)
11654 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11655 *userdomain_ptr
++ = 0;
11658 for (uint i
= 0; i
< domain_len
; i
++)
11660 *userdomain_ptr
++ = domain_pos
[i
];
11661 *userdomain_ptr
++ = 0;
11664 *userdomain_ptr
++ = 0x80;
11667 * handle server challenge encoding
11670 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11672 const char p0
= srvchall_pos
[i
+ 0];
11673 const char p1
= srvchall_pos
[i
+ 1];
11675 *chall_ptr
++ = hex_convert (p1
) << 0
11676 | hex_convert (p0
) << 4;
11680 * handle client challenge encoding
11683 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11685 const char p0
= clichall_pos
[i
+ 0];
11686 const char p1
= clichall_pos
[i
+ 1];
11688 *chall_ptr
++ = hex_convert (p1
) << 0
11689 | hex_convert (p0
) << 4;
11692 *chall_ptr
++ = 0x80;
11695 * handle hash itself
11698 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11699 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11700 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11701 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11703 digest
[0] = byte_swap_32 (digest
[0]);
11704 digest
[1] = byte_swap_32 (digest
[1]);
11705 digest
[2] = byte_swap_32 (digest
[2]);
11706 digest
[3] = byte_swap_32 (digest
[3]);
11709 * reuse challange data as salt_buf, its the buffer that is most likely unique
11712 salt
->salt_buf
[0] = 0;
11713 salt
->salt_buf
[1] = 0;
11714 salt
->salt_buf
[2] = 0;
11715 salt
->salt_buf
[3] = 0;
11716 salt
->salt_buf
[4] = 0;
11717 salt
->salt_buf
[5] = 0;
11718 salt
->salt_buf
[6] = 0;
11719 salt
->salt_buf
[7] = 0;
11723 uptr
= (uint
*) netntlm
->userdomain_buf
;
11725 for (uint i
= 0; i
< 16; i
+= 16)
11727 md5_64 (uptr
, salt
->salt_buf
);
11730 uptr
= (uint
*) netntlm
->chall_buf
;
11732 for (uint i
= 0; i
< 256; i
+= 16)
11734 md5_64 (uptr
, salt
->salt_buf
);
11737 salt
->salt_len
= 16;
11739 return (PARSER_OK
);
11742 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11744 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11746 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11750 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11753 u32
*digest
= (u32
*) hash_buf
->digest
;
11755 salt_t
*salt
= hash_buf
->salt
;
11757 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11758 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11759 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11760 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11762 digest
[0] = byte_swap_32 (digest
[0]);
11763 digest
[1] = byte_swap_32 (digest
[1]);
11764 digest
[2] = byte_swap_32 (digest
[2]);
11765 digest
[3] = byte_swap_32 (digest
[3]);
11767 digest
[0] -= MD5M_A
;
11768 digest
[1] -= MD5M_B
;
11769 digest
[2] -= MD5M_C
;
11770 digest
[3] -= MD5M_D
;
11772 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11774 uint salt_len
= input_len
- 32 - 1;
11776 char *salt_buf
= input_buf
+ 32 + 1;
11778 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11780 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11782 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11784 salt
->salt_len
= salt_len
;
11786 return (PARSER_OK
);
11789 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11791 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11793 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11797 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11800 u32
*digest
= (u32
*) hash_buf
->digest
;
11802 salt_t
*salt
= hash_buf
->salt
;
11804 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11805 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11806 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11807 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11809 digest
[0] = byte_swap_32 (digest
[0]);
11810 digest
[1] = byte_swap_32 (digest
[1]);
11811 digest
[2] = byte_swap_32 (digest
[2]);
11812 digest
[3] = byte_swap_32 (digest
[3]);
11814 digest
[0] -= MD5M_A
;
11815 digest
[1] -= MD5M_B
;
11816 digest
[2] -= MD5M_C
;
11817 digest
[3] -= MD5M_D
;
11819 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11821 uint salt_len
= input_len
- 32 - 1;
11823 char *salt_buf
= input_buf
+ 32 + 1;
11825 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11827 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11829 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11831 salt
->salt_len
= salt_len
;
11833 return (PARSER_OK
);
11836 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11838 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11840 u32
*digest
= (u32
*) hash_buf
->digest
;
11842 salt_t
*salt
= hash_buf
->salt
;
11844 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11845 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11846 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11847 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11849 digest
[0] = byte_swap_32 (digest
[0]);
11850 digest
[1] = byte_swap_32 (digest
[1]);
11851 digest
[2] = byte_swap_32 (digest
[2]);
11852 digest
[3] = byte_swap_32 (digest
[3]);
11854 digest
[0] -= MD5M_A
;
11855 digest
[1] -= MD5M_B
;
11856 digest
[2] -= MD5M_C
;
11857 digest
[3] -= MD5M_D
;
11860 * This is a virtual salt. While the algorithm is basically not salted
11861 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11862 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11865 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11867 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11869 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11871 salt
->salt_len
= salt_len
;
11873 return (PARSER_OK
);
11876 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11878 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11880 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11884 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11887 u32
*digest
= (u32
*) hash_buf
->digest
;
11889 salt_t
*salt
= hash_buf
->salt
;
11891 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11892 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11893 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11894 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11896 digest
[0] = byte_swap_32 (digest
[0]);
11897 digest
[1] = byte_swap_32 (digest
[1]);
11898 digest
[2] = byte_swap_32 (digest
[2]);
11899 digest
[3] = byte_swap_32 (digest
[3]);
11901 digest
[0] -= MD5M_A
;
11902 digest
[1] -= MD5M_B
;
11903 digest
[2] -= MD5M_C
;
11904 digest
[3] -= MD5M_D
;
11906 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11908 uint salt_len
= input_len
- 32 - 1;
11910 char *salt_buf
= input_buf
+ 32 + 1;
11912 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11914 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11916 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11918 salt
->salt_len
= salt_len
;
11920 return (PARSER_OK
);
11923 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11925 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11927 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11931 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11934 u32
*digest
= (u32
*) hash_buf
->digest
;
11936 salt_t
*salt
= hash_buf
->salt
;
11938 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11939 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11940 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11941 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11943 digest
[0] = byte_swap_32 (digest
[0]);
11944 digest
[1] = byte_swap_32 (digest
[1]);
11945 digest
[2] = byte_swap_32 (digest
[2]);
11946 digest
[3] = byte_swap_32 (digest
[3]);
11948 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11950 uint salt_len
= input_len
- 32 - 1;
11952 char *salt_buf
= input_buf
+ 32 + 1;
11954 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11956 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11958 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11960 salt
->salt_len
= salt_len
;
11962 return (PARSER_OK
);
11965 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11967 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11969 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11973 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11976 u32
*digest
= (u32
*) hash_buf
->digest
;
11978 salt_t
*salt
= hash_buf
->salt
;
11980 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11981 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11982 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11983 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11985 digest
[0] = byte_swap_32 (digest
[0]);
11986 digest
[1] = byte_swap_32 (digest
[1]);
11987 digest
[2] = byte_swap_32 (digest
[2]);
11988 digest
[3] = byte_swap_32 (digest
[3]);
11990 digest
[0] -= MD4M_A
;
11991 digest
[1] -= MD4M_B
;
11992 digest
[2] -= MD4M_C
;
11993 digest
[3] -= MD4M_D
;
11995 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11997 uint salt_len
= input_len
- 32 - 1;
11999 char *salt_buf
= input_buf
+ 32 + 1;
12001 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12003 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12005 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12007 salt
->salt_len
= salt_len
;
12009 return (PARSER_OK
);
12012 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12014 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12016 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
12020 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
12023 u32
*digest
= (u32
*) hash_buf
->digest
;
12025 salt_t
*salt
= hash_buf
->salt
;
12027 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12028 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12029 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12030 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12032 digest
[0] = byte_swap_32 (digest
[0]);
12033 digest
[1] = byte_swap_32 (digest
[1]);
12034 digest
[2] = byte_swap_32 (digest
[2]);
12035 digest
[3] = byte_swap_32 (digest
[3]);
12037 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12039 uint salt_len
= input_len
- 32 - 1;
12041 char *salt_buf
= input_buf
+ 32 + 1;
12043 uint salt_pc_block
[16] = { 0 };
12045 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
12047 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
12049 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12051 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
12053 salt_pc_block
[14] = salt_len
* 8;
12055 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
12057 md5_64 (salt_pc_block
, salt_pc_digest
);
12059 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
12060 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
12061 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
12062 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
12064 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
12066 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
12068 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
12070 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
12071 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
12072 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
12073 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
12075 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
12077 return (PARSER_OK
);
12080 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12082 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
12084 u32
*digest
= (u32
*) hash_buf
->digest
;
12086 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12087 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12088 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12089 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12090 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12092 digest
[0] -= SHA1M_A
;
12093 digest
[1] -= SHA1M_B
;
12094 digest
[2] -= SHA1M_C
;
12095 digest
[3] -= SHA1M_D
;
12096 digest
[4] -= SHA1M_E
;
12098 return (PARSER_OK
);
12101 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12103 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
12105 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
12107 u32
*digest
= (u32
*) hash_buf
->digest
;
12111 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12112 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12113 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12114 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12117 return (PARSER_OK
);
12120 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12122 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12124 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12128 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12131 u32
*digest
= (u32
*) hash_buf
->digest
;
12133 salt_t
*salt
= hash_buf
->salt
;
12135 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12136 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12137 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12138 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12139 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12141 digest
[0] -= SHA1M_A
;
12142 digest
[1] -= SHA1M_B
;
12143 digest
[2] -= SHA1M_C
;
12144 digest
[3] -= SHA1M_D
;
12145 digest
[4] -= SHA1M_E
;
12147 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12149 uint salt_len
= input_len
- 40 - 1;
12151 char *salt_buf
= input_buf
+ 40 + 1;
12153 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12155 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12157 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12159 salt
->salt_len
= salt_len
;
12161 return (PARSER_OK
);
12164 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12166 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12168 u32
*digest
= (u32
*) hash_buf
->digest
;
12170 salt_t
*salt
= hash_buf
->salt
;
12172 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12174 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12175 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12176 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12177 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12178 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12180 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12182 uint salt_len
= input_len
- 40 - 1;
12184 char *salt_buf
= input_buf
+ 40 + 1;
12186 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12188 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12190 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12192 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12195 pstoken
->salt_len
= salt_len
/ 2;
12197 /* some fake salt for the sorting mechanisms */
12199 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12200 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12201 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12202 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12203 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12204 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12205 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12206 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12208 salt
->salt_len
= 32;
12210 /* we need to check if we can precompute some of the data --
12211 this is possible since the scheme is badly designed */
12213 pstoken
->pc_digest
[0] = SHA1M_A
;
12214 pstoken
->pc_digest
[1] = SHA1M_B
;
12215 pstoken
->pc_digest
[2] = SHA1M_C
;
12216 pstoken
->pc_digest
[3] = SHA1M_D
;
12217 pstoken
->pc_digest
[4] = SHA1M_E
;
12219 pstoken
->pc_offset
= 0;
12221 for (int i
= 0; i
< (int) pstoken
->salt_len
- 63; i
+= 64)
12225 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12226 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12227 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12228 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12229 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12230 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12231 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12232 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12233 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12234 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12235 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12236 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12237 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12238 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12239 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12240 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12242 sha1_64 (w
, pstoken
->pc_digest
);
12244 pstoken
->pc_offset
+= 16;
12247 return (PARSER_OK
);
12250 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12252 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12254 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12256 u32
*digest
= (u32
*) hash_buf
->digest
;
12258 u8 tmp_buf
[100] = { 0 };
12260 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12262 memcpy (digest
, tmp_buf
, 20);
12264 digest
[0] = byte_swap_32 (digest
[0]);
12265 digest
[1] = byte_swap_32 (digest
[1]);
12266 digest
[2] = byte_swap_32 (digest
[2]);
12267 digest
[3] = byte_swap_32 (digest
[3]);
12268 digest
[4] = byte_swap_32 (digest
[4]);
12270 digest
[0] -= SHA1M_A
;
12271 digest
[1] -= SHA1M_B
;
12272 digest
[2] -= SHA1M_C
;
12273 digest
[3] -= SHA1M_D
;
12274 digest
[4] -= SHA1M_E
;
12276 return (PARSER_OK
);
12279 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12281 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12283 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12285 u32
*digest
= (u32
*) hash_buf
->digest
;
12287 salt_t
*salt
= hash_buf
->salt
;
12289 u8 tmp_buf
[100] = { 0 };
12291 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12293 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12295 memcpy (digest
, tmp_buf
, 20);
12297 int salt_len
= tmp_len
- 20;
12299 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12301 salt
->salt_len
= salt_len
;
12303 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12305 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12307 char *ptr
= (char *) salt
->salt_buf
;
12309 ptr
[salt
->salt_len
] = 0x80;
12312 digest
[0] = byte_swap_32 (digest
[0]);
12313 digest
[1] = byte_swap_32 (digest
[1]);
12314 digest
[2] = byte_swap_32 (digest
[2]);
12315 digest
[3] = byte_swap_32 (digest
[3]);
12316 digest
[4] = byte_swap_32 (digest
[4]);
12318 digest
[0] -= SHA1M_A
;
12319 digest
[1] -= SHA1M_B
;
12320 digest
[2] -= SHA1M_C
;
12321 digest
[3] -= SHA1M_D
;
12322 digest
[4] -= SHA1M_E
;
12324 return (PARSER_OK
);
12327 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12329 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12331 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12333 u32
*digest
= (u32
*) hash_buf
->digest
;
12335 salt_t
*salt
= hash_buf
->salt
;
12337 char *salt_buf
= input_buf
+ 6;
12341 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12343 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12345 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12347 salt
->salt_len
= salt_len
;
12349 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12351 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12352 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12353 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12354 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12355 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12357 digest
[0] -= SHA1M_A
;
12358 digest
[1] -= SHA1M_B
;
12359 digest
[2] -= SHA1M_C
;
12360 digest
[3] -= SHA1M_D
;
12361 digest
[4] -= SHA1M_E
;
12363 return (PARSER_OK
);
12366 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12368 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12370 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12372 u32
*digest
= (u32
*) hash_buf
->digest
;
12374 salt_t
*salt
= hash_buf
->salt
;
12376 char *salt_buf
= input_buf
+ 6;
12380 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12382 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12384 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12386 salt
->salt_len
= salt_len
;
12388 char *hash_pos
= input_buf
+ 6 + 8;
12390 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12391 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12392 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12393 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12394 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12396 digest
[0] -= SHA1M_A
;
12397 digest
[1] -= SHA1M_B
;
12398 digest
[2] -= SHA1M_C
;
12399 digest
[3] -= SHA1M_D
;
12400 digest
[4] -= SHA1M_E
;
12402 return (PARSER_OK
);
12405 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12407 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12409 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12411 u64
*digest
= (u64
*) hash_buf
->digest
;
12413 salt_t
*salt
= hash_buf
->salt
;
12415 char *salt_buf
= input_buf
+ 6;
12419 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12421 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12423 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12425 salt
->salt_len
= salt_len
;
12427 char *hash_pos
= input_buf
+ 6 + 8;
12429 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12430 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12431 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12432 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12433 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12434 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12435 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12436 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12438 digest
[0] -= SHA512M_A
;
12439 digest
[1] -= SHA512M_B
;
12440 digest
[2] -= SHA512M_C
;
12441 digest
[3] -= SHA512M_D
;
12442 digest
[4] -= SHA512M_E
;
12443 digest
[5] -= SHA512M_F
;
12444 digest
[6] -= SHA512M_G
;
12445 digest
[7] -= SHA512M_H
;
12447 return (PARSER_OK
);
12450 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12452 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12454 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12458 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12461 u32
*digest
= (u32
*) hash_buf
->digest
;
12463 salt_t
*salt
= hash_buf
->salt
;
12465 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12466 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12470 digest
[0] = byte_swap_32 (digest
[0]);
12471 digest
[1] = byte_swap_32 (digest
[1]);
12473 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12475 uint salt_len
= input_len
- 16 - 1;
12477 char *salt_buf
= input_buf
+ 16 + 1;
12479 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12481 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12483 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12485 salt
->salt_len
= salt_len
;
12487 return (PARSER_OK
);
12490 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12492 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12494 u32
*digest
= (u32
*) hash_buf
->digest
;
12496 salt_t
*salt
= hash_buf
->salt
;
12498 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12499 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12500 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12501 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12502 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12504 digest
[0] -= SHA1M_A
;
12505 digest
[1] -= SHA1M_B
;
12506 digest
[2] -= SHA1M_C
;
12507 digest
[3] -= SHA1M_D
;
12508 digest
[4] -= SHA1M_E
;
12510 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12512 uint salt_len
= input_len
- 40 - 1;
12514 char *salt_buf
= input_buf
+ 40 + 1;
12516 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12518 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12520 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12522 salt
->salt_len
= salt_len
;
12524 return (PARSER_OK
);
12527 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12529 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12531 u32
*digest
= (u32
*) hash_buf
->digest
;
12533 salt_t
*salt
= hash_buf
->salt
;
12535 char *hash_pos
= input_buf
;
12537 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12538 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12539 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12540 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12541 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12542 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12543 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12544 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12545 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12546 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12547 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12548 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12549 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12550 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12551 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12552 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12554 char *salt_pos
= input_buf
+ 128;
12556 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12557 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12558 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12559 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12561 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12562 salt
->salt_len
= 16;
12564 return (PARSER_OK
);
12567 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12569 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12571 u32
*digest
= (u32
*) hash_buf
->digest
;
12573 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12574 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12575 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12576 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12577 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12578 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12579 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12580 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12582 digest
[0] -= SHA256M_A
;
12583 digest
[1] -= SHA256M_B
;
12584 digest
[2] -= SHA256M_C
;
12585 digest
[3] -= SHA256M_D
;
12586 digest
[4] -= SHA256M_E
;
12587 digest
[5] -= SHA256M_F
;
12588 digest
[6] -= SHA256M_G
;
12589 digest
[7] -= SHA256M_H
;
12591 return (PARSER_OK
);
12594 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12596 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12598 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12602 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12605 u32
*digest
= (u32
*) hash_buf
->digest
;
12607 salt_t
*salt
= hash_buf
->salt
;
12609 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12610 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12611 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12612 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12613 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12614 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12615 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12616 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12618 digest
[0] -= SHA256M_A
;
12619 digest
[1] -= SHA256M_B
;
12620 digest
[2] -= SHA256M_C
;
12621 digest
[3] -= SHA256M_D
;
12622 digest
[4] -= SHA256M_E
;
12623 digest
[5] -= SHA256M_F
;
12624 digest
[6] -= SHA256M_G
;
12625 digest
[7] -= SHA256M_H
;
12627 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12629 uint salt_len
= input_len
- 64 - 1;
12631 char *salt_buf
= input_buf
+ 64 + 1;
12633 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12635 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12637 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12639 salt
->salt_len
= salt_len
;
12641 return (PARSER_OK
);
12644 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12646 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12648 u64
*digest
= (u64
*) hash_buf
->digest
;
12650 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12651 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12652 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12653 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12654 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12655 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12659 digest
[0] -= SHA384M_A
;
12660 digest
[1] -= SHA384M_B
;
12661 digest
[2] -= SHA384M_C
;
12662 digest
[3] -= SHA384M_D
;
12663 digest
[4] -= SHA384M_E
;
12664 digest
[5] -= SHA384M_F
;
12668 return (PARSER_OK
);
12671 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12673 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12675 u64
*digest
= (u64
*) hash_buf
->digest
;
12677 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12678 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12679 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12680 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12681 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12682 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12683 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12684 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12686 digest
[0] -= SHA512M_A
;
12687 digest
[1] -= SHA512M_B
;
12688 digest
[2] -= SHA512M_C
;
12689 digest
[3] -= SHA512M_D
;
12690 digest
[4] -= SHA512M_E
;
12691 digest
[5] -= SHA512M_F
;
12692 digest
[6] -= SHA512M_G
;
12693 digest
[7] -= SHA512M_H
;
12695 return (PARSER_OK
);
12698 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12700 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12702 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12706 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12709 u64
*digest
= (u64
*) hash_buf
->digest
;
12711 salt_t
*salt
= hash_buf
->salt
;
12713 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12714 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12715 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12716 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12717 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12718 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12719 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12720 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12722 digest
[0] -= SHA512M_A
;
12723 digest
[1] -= SHA512M_B
;
12724 digest
[2] -= SHA512M_C
;
12725 digest
[3] -= SHA512M_D
;
12726 digest
[4] -= SHA512M_E
;
12727 digest
[5] -= SHA512M_F
;
12728 digest
[6] -= SHA512M_G
;
12729 digest
[7] -= SHA512M_H
;
12731 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12733 uint salt_len
= input_len
- 128 - 1;
12735 char *salt_buf
= input_buf
+ 128 + 1;
12737 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12739 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12741 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12743 salt
->salt_len
= salt_len
;
12745 return (PARSER_OK
);
12748 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12750 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12752 u64
*digest
= (u64
*) hash_buf
->digest
;
12754 salt_t
*salt
= hash_buf
->salt
;
12756 char *salt_pos
= input_buf
+ 3;
12758 uint iterations_len
= 0;
12760 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12764 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12766 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12767 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12771 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12775 iterations_len
+= 8;
12779 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12782 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12784 char *hash_pos
= strchr (salt_pos
, '$');
12786 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12788 uint salt_len
= hash_pos
- salt_pos
;
12790 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12792 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12794 salt
->salt_len
= salt_len
;
12798 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12800 return (PARSER_OK
);
12803 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12805 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12807 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12809 u64
*digest
= (u64
*) hash_buf
->digest
;
12811 salt_t
*salt
= hash_buf
->salt
;
12813 uint keccak_mdlen
= input_len
/ 2;
12815 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12817 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12819 digest
[i
] = byte_swap_64 (digest
[i
]);
12822 salt
->keccak_mdlen
= keccak_mdlen
;
12824 return (PARSER_OK
);
12827 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12829 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12831 u32
*digest
= (u32
*) hash_buf
->digest
;
12833 salt_t
*salt
= hash_buf
->salt
;
12835 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12838 * Parse that strange long line
12843 size_t in_len
[9] = { 0 };
12845 in_off
[0] = strtok (input_buf
, ":");
12847 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12849 in_len
[0] = strlen (in_off
[0]);
12853 for (i
= 1; i
< 9; i
++)
12855 in_off
[i
] = strtok (NULL
, ":");
12857 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12859 in_len
[i
] = strlen (in_off
[i
]);
12862 char *ptr
= (char *) ikepsk
->msg_buf
;
12864 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12865 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12866 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12867 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12868 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12869 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12873 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12875 ptr
= (char *) ikepsk
->nr_buf
;
12877 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12878 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12882 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12885 * Store to database
12890 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12891 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12892 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12893 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12895 digest
[0] = byte_swap_32 (digest
[0]);
12896 digest
[1] = byte_swap_32 (digest
[1]);
12897 digest
[2] = byte_swap_32 (digest
[2]);
12898 digest
[3] = byte_swap_32 (digest
[3]);
12900 salt
->salt_len
= 32;
12902 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12903 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12904 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12905 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12906 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12907 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12908 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12909 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12911 return (PARSER_OK
);
12914 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12916 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12918 u32
*digest
= (u32
*) hash_buf
->digest
;
12920 salt_t
*salt
= hash_buf
->salt
;
12922 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12925 * Parse that strange long line
12930 size_t in_len
[9] = { 0 };
12932 in_off
[0] = strtok (input_buf
, ":");
12934 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12936 in_len
[0] = strlen (in_off
[0]);
12940 for (i
= 1; i
< 9; i
++)
12942 in_off
[i
] = strtok (NULL
, ":");
12944 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12946 in_len
[i
] = strlen (in_off
[i
]);
12949 char *ptr
= (char *) ikepsk
->msg_buf
;
12951 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12952 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12953 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12954 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12955 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12956 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12960 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12962 ptr
= (char *) ikepsk
->nr_buf
;
12964 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12965 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12969 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12972 * Store to database
12977 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12978 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12979 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12980 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12981 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12983 salt
->salt_len
= 32;
12985 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12986 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12987 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12988 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12989 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12990 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12991 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12992 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12994 return (PARSER_OK
);
12997 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12999 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
13001 u32
*digest
= (u32
*) hash_buf
->digest
;
13003 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13004 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13005 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13006 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13007 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13009 digest
[0] = byte_swap_32 (digest
[0]);
13010 digest
[1] = byte_swap_32 (digest
[1]);
13011 digest
[2] = byte_swap_32 (digest
[2]);
13012 digest
[3] = byte_swap_32 (digest
[3]);
13013 digest
[4] = byte_swap_32 (digest
[4]);
13015 return (PARSER_OK
);
13018 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13020 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
13022 u32
*digest
= (u32
*) hash_buf
->digest
;
13024 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13025 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13026 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
13027 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
13028 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
13029 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
13030 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
13031 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
13032 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
13033 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
13034 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
13035 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
13036 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
13037 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
13038 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
13039 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
13041 return (PARSER_OK
);
13044 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13046 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
13048 u32
*digest
= (u32
*) hash_buf
->digest
;
13050 salt_t
*salt
= hash_buf
->salt
;
13052 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13053 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13054 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13055 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13056 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13058 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13060 uint salt_len
= input_len
- 40 - 1;
13062 char *salt_buf
= input_buf
+ 40 + 1;
13064 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13066 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13068 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13070 salt
->salt_len
= salt_len
;
13072 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
13074 return (PARSER_OK
);
13077 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13079 u32
*digest
= (u32
*) hash_buf
->digest
;
13081 salt_t
*salt
= hash_buf
->salt
;
13083 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13085 if (input_len
== 0)
13087 log_error ("TrueCrypt container not specified");
13092 FILE *fp
= fopen (input_buf
, "rb");
13096 log_error ("%s: %s", input_buf
, strerror (errno
));
13101 char buf
[512] = { 0 };
13103 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13107 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13109 memcpy (tc
->salt_buf
, buf
, 64);
13111 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13113 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13115 salt
->salt_len
= 4;
13117 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
13119 tc
->signature
= 0x45555254; // "TRUE"
13121 digest
[0] = tc
->data_buf
[0];
13123 return (PARSER_OK
);
13126 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13128 u32
*digest
= (u32
*) hash_buf
->digest
;
13130 salt_t
*salt
= hash_buf
->salt
;
13132 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13134 if (input_len
== 0)
13136 log_error ("TrueCrypt container not specified");
13141 FILE *fp
= fopen (input_buf
, "rb");
13145 log_error ("%s: %s", input_buf
, strerror (errno
));
13150 char buf
[512] = { 0 };
13152 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13156 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13158 memcpy (tc
->salt_buf
, buf
, 64);
13160 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13162 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13164 salt
->salt_len
= 4;
13166 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13168 tc
->signature
= 0x45555254; // "TRUE"
13170 digest
[0] = tc
->data_buf
[0];
13172 return (PARSER_OK
);
13175 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13177 u32
*digest
= (u32
*) hash_buf
->digest
;
13179 salt_t
*salt
= hash_buf
->salt
;
13181 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13183 if (input_len
== 0)
13185 log_error ("VeraCrypt container not specified");
13190 FILE *fp
= fopen (input_buf
, "rb");
13194 log_error ("%s: %s", input_buf
, strerror (errno
));
13199 char buf
[512] = { 0 };
13201 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13205 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13207 memcpy (tc
->salt_buf
, buf
, 64);
13209 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13211 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13213 salt
->salt_len
= 4;
13215 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13217 tc
->signature
= 0x41524556; // "VERA"
13219 digest
[0] = tc
->data_buf
[0];
13221 return (PARSER_OK
);
13224 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13226 u32
*digest
= (u32
*) hash_buf
->digest
;
13228 salt_t
*salt
= hash_buf
->salt
;
13230 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13232 if (input_len
== 0)
13234 log_error ("VeraCrypt container not specified");
13239 FILE *fp
= fopen (input_buf
, "rb");
13243 log_error ("%s: %s", input_buf
, strerror (errno
));
13248 char buf
[512] = { 0 };
13250 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13254 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13256 memcpy (tc
->salt_buf
, buf
, 64);
13258 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13260 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13262 salt
->salt_len
= 4;
13264 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13266 tc
->signature
= 0x41524556; // "VERA"
13268 digest
[0] = tc
->data_buf
[0];
13270 return (PARSER_OK
);
13273 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13275 u32
*digest
= (u32
*) hash_buf
->digest
;
13277 salt_t
*salt
= hash_buf
->salt
;
13279 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13281 if (input_len
== 0)
13283 log_error ("VeraCrypt container not specified");
13288 FILE *fp
= fopen (input_buf
, "rb");
13292 log_error ("%s: %s", input_buf
, strerror (errno
));
13297 char buf
[512] = { 0 };
13299 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13303 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13305 memcpy (tc
->salt_buf
, buf
, 64);
13307 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13309 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13311 salt
->salt_len
= 4;
13313 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13315 tc
->signature
= 0x41524556; // "VERA"
13317 digest
[0] = tc
->data_buf
[0];
13319 return (PARSER_OK
);
13322 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13324 u32
*digest
= (u32
*) hash_buf
->digest
;
13326 salt_t
*salt
= hash_buf
->salt
;
13328 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13330 if (input_len
== 0)
13332 log_error ("VeraCrypt container not specified");
13337 FILE *fp
= fopen (input_buf
, "rb");
13341 log_error ("%s: %s", input_buf
, strerror (errno
));
13346 char buf
[512] = { 0 };
13348 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13352 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13354 memcpy (tc
->salt_buf
, buf
, 64);
13356 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13358 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13360 salt
->salt_len
= 4;
13362 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13364 tc
->signature
= 0x41524556; // "VERA"
13366 digest
[0] = tc
->data_buf
[0];
13368 return (PARSER_OK
);
13371 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13373 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13375 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13377 u32
*digest
= (u32
*) hash_buf
->digest
;
13379 salt_t
*salt
= hash_buf
->salt
;
13381 char *salt_pos
= input_buf
+ 6;
13383 char *hash_pos
= strchr (salt_pos
, '$');
13385 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13387 uint salt_len
= hash_pos
- salt_pos
;
13389 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13391 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13393 salt
->salt_len
= salt_len
;
13395 salt
->salt_iter
= 1000;
13399 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13401 return (PARSER_OK
);
13404 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13406 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13408 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13410 u32
*digest
= (u32
*) hash_buf
->digest
;
13412 salt_t
*salt
= hash_buf
->salt
;
13414 char *iter_pos
= input_buf
+ 7;
13416 char *salt_pos
= strchr (iter_pos
, '$');
13418 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13422 char *hash_pos
= strchr (salt_pos
, '$');
13424 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13426 uint salt_len
= hash_pos
- salt_pos
;
13428 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13430 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13432 salt
->salt_len
= salt_len
;
13434 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13436 salt
->salt_sign
[0] = atoi (salt_iter
);
13438 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13442 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13444 digest
[0] = byte_swap_32 (digest
[0]);
13445 digest
[1] = byte_swap_32 (digest
[1]);
13446 digest
[2] = byte_swap_32 (digest
[2]);
13447 digest
[3] = byte_swap_32 (digest
[3]);
13448 digest
[4] = byte_swap_32 (digest
[4]);
13450 return (PARSER_OK
);
13453 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13455 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13457 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13459 u32
*digest
= (u32
*) hash_buf
->digest
;
13461 salt_t
*salt
= hash_buf
->salt
;
13463 char *iter_pos
= input_buf
+ 9;
13465 char *salt_pos
= strchr (iter_pos
, '$');
13467 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13471 char *hash_pos
= strchr (salt_pos
, '$');
13473 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13475 uint salt_len
= hash_pos
- salt_pos
;
13477 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13479 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13481 salt
->salt_len
= salt_len
;
13483 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13485 salt
->salt_sign
[0] = atoi (salt_iter
);
13487 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13491 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13493 digest
[0] = byte_swap_32 (digest
[0]);
13494 digest
[1] = byte_swap_32 (digest
[1]);
13495 digest
[2] = byte_swap_32 (digest
[2]);
13496 digest
[3] = byte_swap_32 (digest
[3]);
13497 digest
[4] = byte_swap_32 (digest
[4]);
13498 digest
[5] = byte_swap_32 (digest
[5]);
13499 digest
[6] = byte_swap_32 (digest
[6]);
13500 digest
[7] = byte_swap_32 (digest
[7]);
13502 return (PARSER_OK
);
13505 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13507 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13509 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13511 u64
*digest
= (u64
*) hash_buf
->digest
;
13513 salt_t
*salt
= hash_buf
->salt
;
13515 char *iter_pos
= input_buf
+ 9;
13517 char *salt_pos
= strchr (iter_pos
, '$');
13519 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13523 char *hash_pos
= strchr (salt_pos
, '$');
13525 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13527 uint salt_len
= hash_pos
- salt_pos
;
13529 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13531 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13533 salt
->salt_len
= salt_len
;
13535 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13537 salt
->salt_sign
[0] = atoi (salt_iter
);
13539 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13543 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13545 digest
[0] = byte_swap_64 (digest
[0]);
13546 digest
[1] = byte_swap_64 (digest
[1]);
13547 digest
[2] = byte_swap_64 (digest
[2]);
13548 digest
[3] = byte_swap_64 (digest
[3]);
13549 digest
[4] = byte_swap_64 (digest
[4]);
13550 digest
[5] = byte_swap_64 (digest
[5]);
13551 digest
[6] = byte_swap_64 (digest
[6]);
13552 digest
[7] = byte_swap_64 (digest
[7]);
13554 return (PARSER_OK
);
13557 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13559 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13561 u32
*digest
= (u32
*) hash_buf
->digest
;
13563 salt_t
*salt
= hash_buf
->salt
;
13565 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13571 char *iterations_pos
= input_buf
;
13573 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13575 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13577 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13579 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13583 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13585 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13587 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13589 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13591 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13593 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13598 * pbkdf2 iterations
13601 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13604 * handle salt encoding
13607 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13609 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13611 const char p0
= saltbuf_pos
[i
+ 0];
13612 const char p1
= saltbuf_pos
[i
+ 1];
13614 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13615 | hex_convert (p0
) << 4;
13618 salt
->salt_len
= saltbuf_len
/ 2;
13621 * handle cipher encoding
13624 uint
*tmp
= (uint
*) mymalloc (32);
13626 char *cipherbuf_ptr
= (char *) tmp
;
13628 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13630 const char p0
= cipherbuf_pos
[i
+ 0];
13631 const char p1
= cipherbuf_pos
[i
+ 1];
13633 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13634 | hex_convert (p0
) << 4;
13637 // iv is stored at salt_buf 4 (length 16)
13638 // data is stored at salt_buf 8 (length 16)
13640 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13641 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13642 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13643 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13645 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13646 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13647 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13648 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13652 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13654 const char p0
= cipherbuf_pos
[j
+ 0];
13655 const char p1
= cipherbuf_pos
[j
+ 1];
13657 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13658 | hex_convert (p0
) << 4;
13665 digest
[0] = 0x10101010;
13666 digest
[1] = 0x10101010;
13667 digest
[2] = 0x10101010;
13668 digest
[3] = 0x10101010;
13670 return (PARSER_OK
);
13673 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13675 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13677 u32
*digest
= (u32
*) hash_buf
->digest
;
13679 salt_t
*salt
= hash_buf
->salt
;
13681 char *hashbuf_pos
= input_buf
;
13683 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13685 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13687 uint hash_len
= iterations_pos
- hashbuf_pos
;
13689 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13693 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13695 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13697 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13701 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13703 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13705 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13707 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13709 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13711 salt
->salt_len
= salt_len
;
13713 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13715 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13716 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13717 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13718 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13720 return (PARSER_OK
);
13723 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13725 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13727 u32
*digest
= (u32
*) hash_buf
->digest
;
13729 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13730 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13731 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13732 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13733 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13734 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13735 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13736 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13738 digest
[0] = byte_swap_32 (digest
[0]);
13739 digest
[1] = byte_swap_32 (digest
[1]);
13740 digest
[2] = byte_swap_32 (digest
[2]);
13741 digest
[3] = byte_swap_32 (digest
[3]);
13742 digest
[4] = byte_swap_32 (digest
[4]);
13743 digest
[5] = byte_swap_32 (digest
[5]);
13744 digest
[6] = byte_swap_32 (digest
[6]);
13745 digest
[7] = byte_swap_32 (digest
[7]);
13747 return (PARSER_OK
);
13750 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13752 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13754 u32
*digest
= (u32
*) hash_buf
->digest
;
13756 salt_t
*salt
= hash_buf
->salt
;
13758 char *salt_pos
= input_buf
+ 3;
13760 uint iterations_len
= 0;
13762 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13766 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13768 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13769 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13773 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13777 iterations_len
+= 8;
13781 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13784 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13786 char *hash_pos
= strchr (salt_pos
, '$');
13788 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13790 uint salt_len
= hash_pos
- salt_pos
;
13792 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13794 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13796 salt
->salt_len
= salt_len
;
13800 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13802 return (PARSER_OK
);
13805 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13807 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13809 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13811 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13813 u64
*digest
= (u64
*) hash_buf
->digest
;
13815 salt_t
*salt
= hash_buf
->salt
;
13817 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13819 char *iter_pos
= input_buf
+ 4;
13821 char *salt_pos
= strchr (iter_pos
, '$');
13823 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13827 char *hash_pos
= strchr (salt_pos
, '$');
13829 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13831 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13835 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13836 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13837 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13838 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13839 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13840 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13841 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13842 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13844 uint salt_len
= hash_pos
- salt_pos
- 1;
13846 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13848 salt
->salt_len
= salt_len
/ 2;
13850 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13851 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13852 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13853 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13854 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13855 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13856 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13857 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13859 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13860 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13861 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13862 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13863 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13864 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13865 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13866 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13867 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13868 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13870 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13872 salt
->salt_iter
= atoi (iter_pos
) - 1;
13874 return (PARSER_OK
);
13877 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13879 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13881 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13883 u32
*digest
= (u32
*) hash_buf
->digest
;
13885 salt_t
*salt
= hash_buf
->salt
;
13887 char *salt_pos
= input_buf
+ 14;
13889 char *hash_pos
= strchr (salt_pos
, '*');
13891 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13895 uint salt_len
= hash_pos
- salt_pos
- 1;
13897 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13899 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13901 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13903 salt
->salt_len
= salt_len
;
13905 u8 tmp_buf
[100] = { 0 };
13907 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13909 memcpy (digest
, tmp_buf
, 32);
13911 digest
[0] = byte_swap_32 (digest
[0]);
13912 digest
[1] = byte_swap_32 (digest
[1]);
13913 digest
[2] = byte_swap_32 (digest
[2]);
13914 digest
[3] = byte_swap_32 (digest
[3]);
13915 digest
[4] = byte_swap_32 (digest
[4]);
13916 digest
[5] = byte_swap_32 (digest
[5]);
13917 digest
[6] = byte_swap_32 (digest
[6]);
13918 digest
[7] = byte_swap_32 (digest
[7]);
13920 digest
[0] -= SHA256M_A
;
13921 digest
[1] -= SHA256M_B
;
13922 digest
[2] -= SHA256M_C
;
13923 digest
[3] -= SHA256M_D
;
13924 digest
[4] -= SHA256M_E
;
13925 digest
[5] -= SHA256M_F
;
13926 digest
[6] -= SHA256M_G
;
13927 digest
[7] -= SHA256M_H
;
13929 return (PARSER_OK
);
13932 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13934 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13936 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13938 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13940 u64
*digest
= (u64
*) hash_buf
->digest
;
13942 salt_t
*salt
= hash_buf
->salt
;
13944 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13946 char *iter_pos
= input_buf
+ 19;
13948 char *salt_pos
= strchr (iter_pos
, '.');
13950 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13954 char *hash_pos
= strchr (salt_pos
, '.');
13956 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13958 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13962 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13963 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13964 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13965 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13966 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13967 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13968 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13969 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13971 uint salt_len
= hash_pos
- salt_pos
- 1;
13975 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13979 for (i
= 0; i
< salt_len
; i
++)
13981 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13984 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13985 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13987 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13989 salt
->salt_len
= salt_len
;
13991 salt
->salt_iter
= atoi (iter_pos
) - 1;
13993 return (PARSER_OK
);
13996 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13998 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
14000 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
14002 u64
*digest
= (u64
*) hash_buf
->digest
;
14004 salt_t
*salt
= hash_buf
->salt
;
14006 u8 tmp_buf
[120] = { 0 };
14008 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
14010 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
14012 memcpy (digest
, tmp_buf
, 64);
14014 digest
[0] = byte_swap_64 (digest
[0]);
14015 digest
[1] = byte_swap_64 (digest
[1]);
14016 digest
[2] = byte_swap_64 (digest
[2]);
14017 digest
[3] = byte_swap_64 (digest
[3]);
14018 digest
[4] = byte_swap_64 (digest
[4]);
14019 digest
[5] = byte_swap_64 (digest
[5]);
14020 digest
[6] = byte_swap_64 (digest
[6]);
14021 digest
[7] = byte_swap_64 (digest
[7]);
14023 digest
[0] -= SHA512M_A
;
14024 digest
[1] -= SHA512M_B
;
14025 digest
[2] -= SHA512M_C
;
14026 digest
[3] -= SHA512M_D
;
14027 digest
[4] -= SHA512M_E
;
14028 digest
[5] -= SHA512M_F
;
14029 digest
[6] -= SHA512M_G
;
14030 digest
[7] -= SHA512M_H
;
14032 int salt_len
= tmp_len
- 64;
14034 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
14036 salt
->salt_len
= salt_len
;
14038 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
14040 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
14042 char *ptr
= (char *) salt
->salt_buf
;
14044 ptr
[salt
->salt_len
] = 0x80;
14047 return (PARSER_OK
);
14050 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14052 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14054 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
14058 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
14061 u32
*digest
= (u32
*) hash_buf
->digest
;
14063 salt_t
*salt
= hash_buf
->salt
;
14065 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14066 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14067 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14068 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14070 digest
[0] = byte_swap_32 (digest
[0]);
14071 digest
[1] = byte_swap_32 (digest
[1]);
14072 digest
[2] = byte_swap_32 (digest
[2]);
14073 digest
[3] = byte_swap_32 (digest
[3]);
14075 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14077 uint salt_len
= input_len
- 32 - 1;
14079 char *salt_buf
= input_buf
+ 32 + 1;
14081 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14083 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14085 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14087 salt
->salt_len
= salt_len
;
14089 return (PARSER_OK
);
14092 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14094 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14096 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
14100 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
14103 u32
*digest
= (u32
*) hash_buf
->digest
;
14105 salt_t
*salt
= hash_buf
->salt
;
14107 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14108 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14109 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14110 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14111 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14113 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14115 uint salt_len
= input_len
- 40 - 1;
14117 char *salt_buf
= input_buf
+ 40 + 1;
14119 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14121 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14123 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14125 salt
->salt_len
= salt_len
;
14127 return (PARSER_OK
);
14130 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14132 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14134 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14138 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14141 u32
*digest
= (u32
*) hash_buf
->digest
;
14143 salt_t
*salt
= hash_buf
->salt
;
14145 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14146 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14147 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14148 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14149 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14150 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14151 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14152 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14154 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14156 uint salt_len
= input_len
- 64 - 1;
14158 char *salt_buf
= input_buf
+ 64 + 1;
14160 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14162 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14164 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14166 salt
->salt_len
= salt_len
;
14168 return (PARSER_OK
);
14171 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14173 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14175 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14179 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14182 u64
*digest
= (u64
*) hash_buf
->digest
;
14184 salt_t
*salt
= hash_buf
->salt
;
14186 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14187 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14188 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14189 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14190 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14191 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14192 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14193 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14195 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14197 uint salt_len
= input_len
- 128 - 1;
14199 char *salt_buf
= input_buf
+ 128 + 1;
14201 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14203 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14205 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14207 salt
->salt_len
= salt_len
;
14209 return (PARSER_OK
);
14212 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14214 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14216 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14218 u32
*digest
= (u32
*) hash_buf
->digest
;
14220 salt_t
*salt
= hash_buf
->salt
;
14222 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14228 char *user_pos
= input_buf
+ 10 + 1;
14230 char *realm_pos
= strchr (user_pos
, '$');
14232 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14234 uint user_len
= realm_pos
- user_pos
;
14236 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14240 char *salt_pos
= strchr (realm_pos
, '$');
14242 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14244 uint realm_len
= salt_pos
- realm_pos
;
14246 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14250 char *data_pos
= strchr (salt_pos
, '$');
14252 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14254 uint salt_len
= data_pos
- salt_pos
;
14256 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14260 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14262 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14268 memcpy (krb5pa
->user
, user_pos
, user_len
);
14269 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14270 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14272 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14274 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14276 const char p0
= data_pos
[i
+ 0];
14277 const char p1
= data_pos
[i
+ 1];
14279 *timestamp_ptr
++ = hex_convert (p1
) << 0
14280 | hex_convert (p0
) << 4;
14283 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14285 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14287 const char p0
= data_pos
[i
+ 0];
14288 const char p1
= data_pos
[i
+ 1];
14290 *checksum_ptr
++ = hex_convert (p1
) << 0
14291 | hex_convert (p0
) << 4;
14295 * copy some data to generic buffers to make sorting happy
14298 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14299 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14300 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14301 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14302 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14303 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14304 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14305 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14306 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14308 salt
->salt_len
= 36;
14310 digest
[0] = krb5pa
->checksum
[0];
14311 digest
[1] = krb5pa
->checksum
[1];
14312 digest
[2] = krb5pa
->checksum
[2];
14313 digest
[3] = krb5pa
->checksum
[3];
14315 return (PARSER_OK
);
14318 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14320 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14322 u32
*digest
= (u32
*) hash_buf
->digest
;
14324 salt_t
*salt
= hash_buf
->salt
;
14330 char *salt_pos
= input_buf
;
14332 char *hash_pos
= strchr (salt_pos
, '$');
14334 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14336 uint salt_len
= hash_pos
- salt_pos
;
14338 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14342 uint hash_len
= input_len
- 1 - salt_len
;
14344 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14352 for (uint i
= 0; i
< salt_len
; i
++)
14354 if (salt_pos
[i
] == ' ') continue;
14359 // SAP user names cannot be longer than 12 characters
14360 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14362 // SAP user name cannot start with ! or ?
14363 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14369 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14371 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14373 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14375 salt
->salt_len
= salt_len
;
14377 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14378 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14382 digest
[0] = byte_swap_32 (digest
[0]);
14383 digest
[1] = byte_swap_32 (digest
[1]);
14385 return (PARSER_OK
);
14388 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14390 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14392 u32
*digest
= (u32
*) hash_buf
->digest
;
14394 salt_t
*salt
= hash_buf
->salt
;
14400 char *salt_pos
= input_buf
;
14402 char *hash_pos
= strchr (salt_pos
, '$');
14404 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14406 uint salt_len
= hash_pos
- salt_pos
;
14408 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14412 uint hash_len
= input_len
- 1 - salt_len
;
14414 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14422 for (uint i
= 0; i
< salt_len
; i
++)
14424 if (salt_pos
[i
] == ' ') continue;
14429 // SAP user names cannot be longer than 12 characters
14430 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14431 // so far nobody complained so we stay with this because it helps in optimization
14432 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14434 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14436 // SAP user name cannot start with ! or ?
14437 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14443 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14445 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14447 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14449 salt
->salt_len
= salt_len
;
14451 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14452 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14453 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14454 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14455 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14457 return (PARSER_OK
);
14460 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14462 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14464 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14466 u64
*digest
= (u64
*) hash_buf
->digest
;
14468 salt_t
*salt
= hash_buf
->salt
;
14470 char *iter_pos
= input_buf
+ 3;
14472 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14474 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14476 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14478 salt
->salt_iter
= salt_iter
;
14480 char *salt_pos
= iter_pos
+ 1;
14484 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14486 salt
->salt_len
= salt_len
;
14488 char *hash_pos
= salt_pos
+ salt_len
;
14490 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14494 char *tmp
= (char *) salt
->salt_buf_pc
;
14496 tmp
[0] = hash_pos
[42];
14500 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14501 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14502 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14503 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14509 return (PARSER_OK
);
14512 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14514 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14516 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14518 u32
*digest
= (u32
*) hash_buf
->digest
;
14520 salt_t
*salt
= hash_buf
->salt
;
14522 char *salt_buf
= input_buf
+ 6;
14524 uint salt_len
= 16;
14526 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14528 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14530 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14532 salt
->salt_len
= salt_len
;
14534 char *hash_pos
= input_buf
+ 6 + 16;
14536 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14537 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14538 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14539 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14540 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14541 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14542 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14543 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14545 return (PARSER_OK
);
14548 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14550 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14552 u32
*digest
= (u32
*) hash_buf
->digest
;
14554 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14555 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14559 return (PARSER_OK
);
14562 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14564 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14566 u32
*digest
= (u32
*) hash_buf
->digest
;
14568 salt_t
*salt
= hash_buf
->salt
;
14570 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14572 char *saltbuf_pos
= input_buf
;
14574 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14576 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14578 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14580 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14581 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14583 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14587 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14589 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14591 char *salt_ptr
= (char *) saltbuf_pos
;
14592 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14597 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14599 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14602 rakp_ptr
[j
] = 0x80;
14604 rakp
->salt_len
= j
;
14606 for (i
= 0; i
< 64; i
++)
14608 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14611 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14612 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14613 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14614 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14615 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14616 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14617 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14618 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14620 salt
->salt_len
= 32; // muss min. 32 haben
14622 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14623 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14624 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14625 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14626 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14628 return (PARSER_OK
);
14631 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14633 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14635 u32
*digest
= (u32
*) hash_buf
->digest
;
14637 salt_t
*salt
= hash_buf
->salt
;
14639 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14641 char *salt_pos
= input_buf
+ 1;
14643 memcpy (salt
->salt_buf
, salt_pos
, 8);
14645 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14646 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14648 salt
->salt_len
= 8;
14650 char *hash_pos
= salt_pos
+ 8;
14652 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14653 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14654 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14655 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14656 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14658 digest
[0] -= SHA1M_A
;
14659 digest
[1] -= SHA1M_B
;
14660 digest
[2] -= SHA1M_C
;
14661 digest
[3] -= SHA1M_D
;
14662 digest
[4] -= SHA1M_E
;
14664 return (PARSER_OK
);
14667 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14669 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14671 u32
*digest
= (u32
*) hash_buf
->digest
;
14673 salt_t
*salt
= hash_buf
->salt
;
14675 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14676 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14677 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14678 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14680 digest
[0] = byte_swap_32 (digest
[0]);
14681 digest
[1] = byte_swap_32 (digest
[1]);
14682 digest
[2] = byte_swap_32 (digest
[2]);
14683 digest
[3] = byte_swap_32 (digest
[3]);
14685 digest
[0] -= MD5M_A
;
14686 digest
[1] -= MD5M_B
;
14687 digest
[2] -= MD5M_C
;
14688 digest
[3] -= MD5M_D
;
14690 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14692 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14694 u32
*salt_buf
= salt
->salt_buf
;
14696 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14697 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14698 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14699 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14701 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14702 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14703 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14704 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14706 salt
->salt_len
= 16 + 1;
14708 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14710 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14712 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14714 return (PARSER_OK
);
14717 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14719 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14721 u32
*digest
= (u32
*) hash_buf
->digest
;
14723 salt_t
*salt
= hash_buf
->salt
;
14725 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14731 char *hashbuf_pos
= input_buf
;
14733 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14735 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14737 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14739 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14743 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14745 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14747 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14749 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14753 char *databuf_pos
= strchr (iteration_pos
, ':');
14755 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14757 const uint iteration_len
= databuf_pos
- iteration_pos
;
14759 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14760 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14762 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14764 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14765 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14771 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14772 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14773 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14774 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14775 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14776 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14777 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14778 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14782 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14784 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14786 const char p0
= saltbuf_pos
[i
+ 0];
14787 const char p1
= saltbuf_pos
[i
+ 1];
14789 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14790 | hex_convert (p0
) << 4;
14793 salt
->salt_buf
[4] = 0x01000000;
14794 salt
->salt_buf
[5] = 0x80;
14796 salt
->salt_len
= saltbuf_len
/ 2;
14800 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14804 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14806 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14808 const char p0
= databuf_pos
[i
+ 0];
14809 const char p1
= databuf_pos
[i
+ 1];
14811 *databuf_ptr
++ = hex_convert (p1
) << 0
14812 | hex_convert (p0
) << 4;
14815 *databuf_ptr
++ = 0x80;
14817 for (uint i
= 0; i
< 512; i
++)
14819 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14822 cloudkey
->data_len
= databuf_len
/ 2;
14824 return (PARSER_OK
);
14827 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14829 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14831 u32
*digest
= (u32
*) hash_buf
->digest
;
14833 salt_t
*salt
= hash_buf
->salt
;
14839 char *hashbuf_pos
= input_buf
;
14841 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14843 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14845 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14847 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14851 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14853 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14855 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14857 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14859 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14863 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14865 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14867 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14869 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14871 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14875 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14877 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14878 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14880 // ok, the plan for this algorithm is the following:
14881 // we have 2 salts here, the domain-name and a random salt
14882 // while both are used in the initial transformation,
14883 // only the random salt is used in the following iterations
14884 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14885 // and one that includes only the real salt (stored into salt_buf[]).
14886 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14888 u8 tmp_buf
[100] = { 0 };
14890 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14892 memcpy (digest
, tmp_buf
, 20);
14894 digest
[0] = byte_swap_32 (digest
[0]);
14895 digest
[1] = byte_swap_32 (digest
[1]);
14896 digest
[2] = byte_swap_32 (digest
[2]);
14897 digest
[3] = byte_swap_32 (digest
[3]);
14898 digest
[4] = byte_swap_32 (digest
[4]);
14902 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14904 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14906 char *len_ptr
= NULL
;
14908 for (uint i
= 0; i
< domainbuf_len
; i
++)
14910 if (salt_buf_pc_ptr
[i
] == '.')
14912 len_ptr
= &salt_buf_pc_ptr
[i
];
14922 salt
->salt_buf_pc
[7] = domainbuf_len
;
14926 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14928 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14930 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14932 salt
->salt_len
= salt_len
;
14936 salt
->salt_iter
= atoi (iteration_pos
);
14938 return (PARSER_OK
);
14941 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14943 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14945 u32
*digest
= (u32
*) hash_buf
->digest
;
14947 salt_t
*salt
= hash_buf
->salt
;
14949 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14950 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14951 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14952 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14953 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14955 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14957 uint salt_len
= input_len
- 40 - 1;
14959 char *salt_buf
= input_buf
+ 40 + 1;
14961 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14963 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14965 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14967 salt
->salt_len
= salt_len
;
14969 return (PARSER_OK
);
14972 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14974 const u8 ascii_to_ebcdic
[] =
14976 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14977 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14978 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14979 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14980 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14981 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14982 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14983 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14984 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14985 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14986 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14987 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14988 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14989 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14990 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14991 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14994 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14996 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14998 u32
*digest
= (u32
*) hash_buf
->digest
;
15000 salt_t
*salt
= hash_buf
->salt
;
15002 char *salt_pos
= input_buf
+ 6 + 1;
15004 char *digest_pos
= strchr (salt_pos
, '*');
15006 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15008 uint salt_len
= digest_pos
- salt_pos
;
15010 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
15012 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
15014 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
15018 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15019 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
15021 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
15023 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15025 salt
->salt_len
= salt_len
;
15027 for (uint i
= 0; i
< salt_len
; i
++)
15029 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
15031 for (uint i
= salt_len
; i
< 8; i
++)
15033 salt_buf_pc_ptr
[i
] = 0x40;
15038 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
15040 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
15041 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
15043 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
15044 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
15046 digest
[0] = byte_swap_32 (digest
[0]);
15047 digest
[1] = byte_swap_32 (digest
[1]);
15049 IP (digest
[0], digest
[1], tt
);
15051 digest
[0] = rotr32 (digest
[0], 29);
15052 digest
[1] = rotr32 (digest
[1], 29);
15056 return (PARSER_OK
);
15059 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15061 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
15063 u32
*digest
= (u32
*) hash_buf
->digest
;
15065 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15066 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15067 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15068 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15070 digest
[0] = byte_swap_32 (digest
[0]);
15071 digest
[1] = byte_swap_32 (digest
[1]);
15072 digest
[2] = byte_swap_32 (digest
[2]);
15073 digest
[3] = byte_swap_32 (digest
[3]);
15075 return (PARSER_OK
);
15078 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15080 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
15082 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15084 u32
*digest
= (u32
*) hash_buf
->digest
;
15086 salt_t
*salt
= hash_buf
->salt
;
15088 u8 tmp_buf
[120] = { 0 };
15090 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15092 tmp_buf
[3] += -4; // dont ask!
15094 memcpy (salt
->salt_buf
, tmp_buf
, 5);
15096 salt
->salt_len
= 5;
15098 memcpy (digest
, tmp_buf
+ 5, 9);
15100 // yes, only 9 byte are needed to crack, but 10 to display
15102 salt
->salt_buf_pc
[7] = input_buf
[20];
15104 return (PARSER_OK
);
15107 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15109 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
15111 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15113 u32
*digest
= (u32
*) hash_buf
->digest
;
15115 salt_t
*salt
= hash_buf
->salt
;
15117 u8 tmp_buf
[120] = { 0 };
15119 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15121 tmp_buf
[3] += -4; // dont ask!
15125 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15127 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)
15131 char tmp_iter_buf
[11] = { 0 };
15133 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15135 tmp_iter_buf
[10] = 0;
15137 salt
->salt_iter
= atoi (tmp_iter_buf
);
15139 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15141 return (PARSER_SALT_ITERATION
);
15144 salt
->salt_iter
--; // first round in init
15146 // 2 additional bytes for display only
15148 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15149 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15153 memcpy (digest
, tmp_buf
+ 28, 8);
15155 digest
[0] = byte_swap_32 (digest
[0]);
15156 digest
[1] = byte_swap_32 (digest
[1]);
15160 return (PARSER_OK
);
15163 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15165 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15167 u32
*digest
= (u32
*) hash_buf
->digest
;
15169 salt_t
*salt
= hash_buf
->salt
;
15171 char *salt_buf_pos
= input_buf
;
15173 char *hash_buf_pos
= salt_buf_pos
+ 6;
15175 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15176 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15177 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15178 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15179 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15180 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15181 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15182 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15184 digest
[0] -= SHA256M_A
;
15185 digest
[1] -= SHA256M_B
;
15186 digest
[2] -= SHA256M_C
;
15187 digest
[3] -= SHA256M_D
;
15188 digest
[4] -= SHA256M_E
;
15189 digest
[5] -= SHA256M_F
;
15190 digest
[6] -= SHA256M_G
;
15191 digest
[7] -= SHA256M_H
;
15193 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15195 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15197 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15199 salt
->salt_len
= salt_len
;
15201 return (PARSER_OK
);
15204 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15206 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15208 u32
*digest
= (u32
*) hash_buf
->digest
;
15210 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15212 salt_t
*salt
= hash_buf
->salt
;
15214 char *salt_buf
= input_buf
+ 6;
15216 char *digest_buf
= strchr (salt_buf
, '$');
15218 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15220 uint salt_len
= digest_buf
- salt_buf
;
15222 digest_buf
++; // skip the '$' symbol
15224 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15226 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15228 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15230 salt
->salt_len
= salt_len
;
15232 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15233 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15234 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15235 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15237 digest
[0] = byte_swap_32 (digest
[0]);
15238 digest
[1] = byte_swap_32 (digest
[1]);
15239 digest
[2] = byte_swap_32 (digest
[2]);
15240 digest
[3] = byte_swap_32 (digest
[3]);
15242 digest
[0] -= MD5M_A
;
15243 digest
[1] -= MD5M_B
;
15244 digest
[2] -= MD5M_C
;
15245 digest
[3] -= MD5M_D
;
15247 return (PARSER_OK
);
15250 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15252 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15254 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15256 u32
*digest
= (u32
*) hash_buf
->digest
;
15258 salt_t
*salt
= hash_buf
->salt
;
15260 char *salt_buf
= input_buf
+ 3;
15262 char *digest_buf
= strchr (salt_buf
, '$');
15264 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15266 uint salt_len
= digest_buf
- salt_buf
;
15268 digest_buf
++; // skip the '$' symbol
15270 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15272 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15274 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15276 salt_buf_ptr
[salt_len
] = 0x2d;
15278 salt
->salt_len
= salt_len
+ 1;
15280 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15281 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15282 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15283 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15285 digest
[0] = byte_swap_32 (digest
[0]);
15286 digest
[1] = byte_swap_32 (digest
[1]);
15287 digest
[2] = byte_swap_32 (digest
[2]);
15288 digest
[3] = byte_swap_32 (digest
[3]);
15290 digest
[0] -= MD5M_A
;
15291 digest
[1] -= MD5M_B
;
15292 digest
[2] -= MD5M_C
;
15293 digest
[3] -= MD5M_D
;
15295 return (PARSER_OK
);
15298 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15300 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15302 u32
*digest
= (u32
*) hash_buf
->digest
;
15304 salt_t
*salt
= hash_buf
->salt
;
15306 u8 tmp_buf
[100] = { 0 };
15308 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15310 memcpy (digest
, tmp_buf
, 20);
15312 digest
[0] = byte_swap_32 (digest
[0]);
15313 digest
[1] = byte_swap_32 (digest
[1]);
15314 digest
[2] = byte_swap_32 (digest
[2]);
15315 digest
[3] = byte_swap_32 (digest
[3]);
15316 digest
[4] = byte_swap_32 (digest
[4]);
15318 digest
[0] -= SHA1M_A
;
15319 digest
[1] -= SHA1M_B
;
15320 digest
[2] -= SHA1M_C
;
15321 digest
[3] -= SHA1M_D
;
15322 digest
[4] -= SHA1M_E
;
15324 salt
->salt_buf
[0] = 0x80;
15326 salt
->salt_len
= 0;
15328 return (PARSER_OK
);
15331 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15333 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15335 u32
*digest
= (u32
*) hash_buf
->digest
;
15337 salt_t
*salt
= hash_buf
->salt
;
15339 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15340 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15341 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15342 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15344 digest
[0] = byte_swap_32 (digest
[0]);
15345 digest
[1] = byte_swap_32 (digest
[1]);
15346 digest
[2] = byte_swap_32 (digest
[2]);
15347 digest
[3] = byte_swap_32 (digest
[3]);
15349 digest
[0] -= MD5M_A
;
15350 digest
[1] -= MD5M_B
;
15351 digest
[2] -= MD5M_C
;
15352 digest
[3] -= MD5M_D
;
15354 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15356 uint salt_len
= input_len
- 32 - 1;
15358 char *salt_buf
= input_buf
+ 32 + 1;
15360 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15362 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15364 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15367 * add static "salt" part
15370 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15374 salt
->salt_len
= salt_len
;
15376 return (PARSER_OK
);
15379 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15381 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15383 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15385 u32
*digest
= (u32
*) hash_buf
->digest
;
15387 salt_t
*salt
= hash_buf
->salt
;
15389 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15395 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15397 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15399 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15401 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15403 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15407 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15409 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15411 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15413 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15417 char *keybuf_pos
= strchr (keylen_pos
, '$');
15419 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15421 uint keylen_len
= keybuf_pos
- keylen_pos
;
15423 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15427 char *databuf_pos
= strchr (keybuf_pos
, '$');
15429 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15431 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15433 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15437 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15439 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15445 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15446 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15447 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15448 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15450 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15451 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15452 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15453 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15455 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15456 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15457 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15458 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15460 salt
->salt_len
= 16;
15461 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15463 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15465 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15468 return (PARSER_OK
);
15471 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15473 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15475 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15477 u32
*digest
= (u32
*) hash_buf
->digest
;
15479 salt_t
*salt
= hash_buf
->salt
;
15485 // first is the N salt parameter
15487 char *N_pos
= input_buf
+ 6;
15489 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15493 salt
->scrypt_N
= atoi (N_pos
);
15497 char *r_pos
= strchr (N_pos
, ':');
15499 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15503 salt
->scrypt_r
= atoi (r_pos
);
15507 char *p_pos
= strchr (r_pos
, ':');
15509 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15513 salt
->scrypt_p
= atoi (p_pos
);
15517 char *saltbuf_pos
= strchr (p_pos
, ':');
15519 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15523 char *hash_pos
= strchr (saltbuf_pos
, ':');
15525 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15531 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15533 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15535 u8 tmp_buf
[33] = { 0 };
15537 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15539 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15541 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15543 salt
->salt_len
= tmp_len
;
15544 salt
->salt_iter
= 1;
15546 // digest - base64 decode
15548 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15550 tmp_len
= input_len
- (hash_pos
- input_buf
);
15552 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15554 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15556 memcpy (digest
, tmp_buf
, 32);
15558 return (PARSER_OK
);
15561 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15563 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15565 u32
*digest
= (u32
*) hash_buf
->digest
;
15567 salt_t
*salt
= hash_buf
->salt
;
15573 char decrypted
[76] = { 0 }; // iv + hash
15575 juniper_decrypt_hash (input_buf
, decrypted
);
15577 char *md5crypt_hash
= decrypted
+ 12;
15579 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15581 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15583 char *salt_pos
= md5crypt_hash
+ 3;
15585 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15587 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15589 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15593 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15595 return (PARSER_OK
);
15598 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15600 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15602 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15604 u32
*digest
= (u32
*) hash_buf
->digest
;
15606 salt_t
*salt
= hash_buf
->salt
;
15608 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15614 // first is *raw* salt
15616 char *salt_pos
= input_buf
+ 3;
15618 char *hash_pos
= strchr (salt_pos
, '$');
15620 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15622 uint salt_len
= hash_pos
- salt_pos
;
15624 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15628 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15630 memcpy (salt_buf_ptr
, salt_pos
, 14);
15632 salt_buf_ptr
[17] = 0x01;
15633 salt_buf_ptr
[18] = 0x80;
15635 // add some stuff to normal salt to make sorted happy
15637 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15638 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15639 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15640 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15642 salt
->salt_len
= salt_len
;
15643 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15645 // base64 decode hash
15647 u8 tmp_buf
[100] = { 0 };
15649 uint hash_len
= input_len
- 3 - salt_len
- 1;
15651 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15653 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15655 memcpy (digest
, tmp_buf
, 32);
15657 digest
[0] = byte_swap_32 (digest
[0]);
15658 digest
[1] = byte_swap_32 (digest
[1]);
15659 digest
[2] = byte_swap_32 (digest
[2]);
15660 digest
[3] = byte_swap_32 (digest
[3]);
15661 digest
[4] = byte_swap_32 (digest
[4]);
15662 digest
[5] = byte_swap_32 (digest
[5]);
15663 digest
[6] = byte_swap_32 (digest
[6]);
15664 digest
[7] = byte_swap_32 (digest
[7]);
15666 return (PARSER_OK
);
15669 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15671 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15673 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15675 u32
*digest
= (u32
*) hash_buf
->digest
;
15677 salt_t
*salt
= hash_buf
->salt
;
15683 // first is *raw* salt
15685 char *salt_pos
= input_buf
+ 3;
15687 char *hash_pos
= strchr (salt_pos
, '$');
15689 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15691 uint salt_len
= hash_pos
- salt_pos
;
15693 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15695 salt
->salt_len
= salt_len
;
15698 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15700 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15701 salt_buf_ptr
[salt_len
] = 0;
15703 // base64 decode hash
15705 u8 tmp_buf
[100] = { 0 };
15707 uint hash_len
= input_len
- 3 - salt_len
- 1;
15709 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15711 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15713 memcpy (digest
, tmp_buf
, 32);
15716 salt
->scrypt_N
= 16384;
15717 salt
->scrypt_r
= 1;
15718 salt
->scrypt_p
= 1;
15719 salt
->salt_iter
= 1;
15721 return (PARSER_OK
);
15724 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15726 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15728 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15730 u32
*digest
= (u32
*) hash_buf
->digest
;
15732 salt_t
*salt
= hash_buf
->salt
;
15734 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15740 char *version_pos
= input_buf
+ 8 + 1;
15742 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15744 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15746 u32 version_len
= verifierHashSize_pos
- version_pos
;
15748 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15750 verifierHashSize_pos
++;
15752 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15754 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15756 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15758 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15762 char *saltSize_pos
= strchr (keySize_pos
, '*');
15764 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15766 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15768 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15772 char *osalt_pos
= strchr (saltSize_pos
, '*');
15774 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15776 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15778 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15782 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15784 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15786 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15788 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15790 encryptedVerifier_pos
++;
15792 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15794 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15796 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15798 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15800 encryptedVerifierHash_pos
++;
15802 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;
15804 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15806 const uint version
= atoi (version_pos
);
15808 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15810 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15812 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15814 const uint keySize
= atoi (keySize_pos
);
15816 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15818 office2007
->keySize
= keySize
;
15820 const uint saltSize
= atoi (saltSize_pos
);
15822 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15828 salt
->salt_len
= 16;
15829 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15831 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15832 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15833 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15834 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15840 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15841 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15842 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15843 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15845 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15846 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15847 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15848 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15849 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15855 digest
[0] = office2007
->encryptedVerifierHash
[0];
15856 digest
[1] = office2007
->encryptedVerifierHash
[1];
15857 digest
[2] = office2007
->encryptedVerifierHash
[2];
15858 digest
[3] = office2007
->encryptedVerifierHash
[3];
15860 return (PARSER_OK
);
15863 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15865 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15867 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15869 u32
*digest
= (u32
*) hash_buf
->digest
;
15871 salt_t
*salt
= hash_buf
->salt
;
15873 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15879 char *version_pos
= input_buf
+ 8 + 1;
15881 char *spinCount_pos
= strchr (version_pos
, '*');
15883 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15885 u32 version_len
= spinCount_pos
- version_pos
;
15887 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15891 char *keySize_pos
= strchr (spinCount_pos
, '*');
15893 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15895 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15897 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15901 char *saltSize_pos
= strchr (keySize_pos
, '*');
15903 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15905 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15907 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15911 char *osalt_pos
= strchr (saltSize_pos
, '*');
15913 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15915 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15917 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15921 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15923 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15925 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15927 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15929 encryptedVerifier_pos
++;
15931 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15933 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15935 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15937 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15939 encryptedVerifierHash_pos
++;
15941 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;
15943 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15945 const uint version
= atoi (version_pos
);
15947 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15949 const uint spinCount
= atoi (spinCount_pos
);
15951 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15953 const uint keySize
= atoi (keySize_pos
);
15955 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15957 const uint saltSize
= atoi (saltSize_pos
);
15959 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15965 salt
->salt_len
= 16;
15966 salt
->salt_iter
= spinCount
;
15968 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15969 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15970 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15971 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15977 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15978 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15979 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15980 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15982 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15983 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15984 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15985 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15986 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15987 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15988 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15989 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15995 digest
[0] = office2010
->encryptedVerifierHash
[0];
15996 digest
[1] = office2010
->encryptedVerifierHash
[1];
15997 digest
[2] = office2010
->encryptedVerifierHash
[2];
15998 digest
[3] = office2010
->encryptedVerifierHash
[3];
16000 return (PARSER_OK
);
16003 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16005 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
16007 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
16009 u32
*digest
= (u32
*) hash_buf
->digest
;
16011 salt_t
*salt
= hash_buf
->salt
;
16013 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
16019 char *version_pos
= input_buf
+ 8 + 1;
16021 char *spinCount_pos
= strchr (version_pos
, '*');
16023 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16025 u32 version_len
= spinCount_pos
- version_pos
;
16027 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
16031 char *keySize_pos
= strchr (spinCount_pos
, '*');
16033 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16035 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
16037 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
16041 char *saltSize_pos
= strchr (keySize_pos
, '*');
16043 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16045 u32 keySize_len
= saltSize_pos
- keySize_pos
;
16047 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
16051 char *osalt_pos
= strchr (saltSize_pos
, '*');
16053 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16055 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
16057 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
16061 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16063 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16065 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16067 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16069 encryptedVerifier_pos
++;
16071 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16073 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16075 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16077 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16079 encryptedVerifierHash_pos
++;
16081 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;
16083 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
16085 const uint version
= atoi (version_pos
);
16087 if (version
!= 2013) return (PARSER_SALT_VALUE
);
16089 const uint spinCount
= atoi (spinCount_pos
);
16091 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
16093 const uint keySize
= atoi (keySize_pos
);
16095 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
16097 const uint saltSize
= atoi (saltSize_pos
);
16099 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
16105 salt
->salt_len
= 16;
16106 salt
->salt_iter
= spinCount
;
16108 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16109 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16110 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16111 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16117 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16118 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16119 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16120 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16122 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16123 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16124 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16125 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16126 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16127 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16128 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16129 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16135 digest
[0] = office2013
->encryptedVerifierHash
[0];
16136 digest
[1] = office2013
->encryptedVerifierHash
[1];
16137 digest
[2] = office2013
->encryptedVerifierHash
[2];
16138 digest
[3] = office2013
->encryptedVerifierHash
[3];
16140 return (PARSER_OK
);
16143 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16145 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16147 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16149 u32
*digest
= (u32
*) hash_buf
->digest
;
16151 salt_t
*salt
= hash_buf
->salt
;
16153 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16159 char *version_pos
= input_buf
+ 11;
16161 char *osalt_pos
= strchr (version_pos
, '*');
16163 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16165 u32 version_len
= osalt_pos
- version_pos
;
16167 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16171 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16173 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16175 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16177 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16179 encryptedVerifier_pos
++;
16181 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16183 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16185 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16187 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16189 encryptedVerifierHash_pos
++;
16191 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16193 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16195 const uint version
= *version_pos
- 0x30;
16197 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16203 oldoffice01
->version
= version
;
16205 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16206 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16207 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16208 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16210 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16211 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16212 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16213 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16215 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16216 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16217 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16218 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16220 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16221 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16222 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16223 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16229 salt
->salt_len
= 16;
16231 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16232 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16233 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16234 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16236 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16237 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16238 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16239 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16241 // this is a workaround as office produces multiple documents with the same salt
16243 salt
->salt_len
+= 32;
16245 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16246 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16247 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16248 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16249 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16250 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16251 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16252 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16258 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16259 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16260 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16261 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16263 return (PARSER_OK
);
16266 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16268 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16271 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16273 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16275 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16277 u32
*digest
= (u32
*) hash_buf
->digest
;
16279 salt_t
*salt
= hash_buf
->salt
;
16281 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16287 char *version_pos
= input_buf
+ 11;
16289 char *osalt_pos
= strchr (version_pos
, '*');
16291 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16293 u32 version_len
= osalt_pos
- version_pos
;
16295 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16299 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16301 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16303 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16305 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16307 encryptedVerifier_pos
++;
16309 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16311 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16313 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16315 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16317 encryptedVerifierHash_pos
++;
16319 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16321 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16323 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16325 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16329 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16331 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16333 const uint version
= *version_pos
- 0x30;
16335 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16341 oldoffice01
->version
= version
;
16343 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16344 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16345 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16346 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16348 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16349 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16350 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16351 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16353 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16354 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16355 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16356 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16358 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16359 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16360 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16361 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16363 oldoffice01
->rc4key
[1] = 0;
16364 oldoffice01
->rc4key
[0] = 0;
16366 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16367 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16368 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16369 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16370 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16371 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16372 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16373 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16374 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16375 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16377 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16378 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16384 salt
->salt_len
= 16;
16386 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16387 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16388 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16389 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16391 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16392 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16393 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16394 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16396 // this is a workaround as office produces multiple documents with the same salt
16398 salt
->salt_len
+= 32;
16400 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16401 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16402 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16403 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16404 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16405 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16406 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16407 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16413 digest
[0] = oldoffice01
->rc4key
[0];
16414 digest
[1] = oldoffice01
->rc4key
[1];
16418 return (PARSER_OK
);
16421 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16423 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16425 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16427 u32
*digest
= (u32
*) hash_buf
->digest
;
16429 salt_t
*salt
= hash_buf
->salt
;
16431 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16437 char *version_pos
= input_buf
+ 11;
16439 char *osalt_pos
= strchr (version_pos
, '*');
16441 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16443 u32 version_len
= osalt_pos
- version_pos
;
16445 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16449 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16451 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16453 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16455 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16457 encryptedVerifier_pos
++;
16459 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16461 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16463 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16465 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16467 encryptedVerifierHash_pos
++;
16469 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16471 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16473 const uint version
= *version_pos
- 0x30;
16475 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16481 oldoffice34
->version
= version
;
16483 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16484 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16485 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16486 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16488 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16489 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16490 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16491 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16493 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16494 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16495 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16496 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16497 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16499 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16500 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16501 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16502 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16503 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16509 salt
->salt_len
= 16;
16511 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16512 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16513 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16514 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16516 // this is a workaround as office produces multiple documents with the same salt
16518 salt
->salt_len
+= 32;
16520 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16521 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16522 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16523 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16524 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16525 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16526 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16527 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16533 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16534 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16535 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16536 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16538 return (PARSER_OK
);
16541 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16543 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16545 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16548 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16550 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16552 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16554 u32
*digest
= (u32
*) hash_buf
->digest
;
16556 salt_t
*salt
= hash_buf
->salt
;
16558 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16564 char *version_pos
= input_buf
+ 11;
16566 char *osalt_pos
= strchr (version_pos
, '*');
16568 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16570 u32 version_len
= osalt_pos
- version_pos
;
16572 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16576 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16578 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16580 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16582 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16584 encryptedVerifier_pos
++;
16586 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16588 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16590 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16592 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16594 encryptedVerifierHash_pos
++;
16596 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16598 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16600 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16602 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16606 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16608 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16610 const uint version
= *version_pos
- 0x30;
16612 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16618 oldoffice34
->version
= version
;
16620 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16621 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16622 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16623 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16625 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16626 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16627 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16628 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16630 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16631 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16632 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16633 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16634 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16636 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16637 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16638 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16639 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16640 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16642 oldoffice34
->rc4key
[1] = 0;
16643 oldoffice34
->rc4key
[0] = 0;
16645 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16646 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16647 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16648 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16649 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16650 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16651 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16652 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16653 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16654 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16656 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16657 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16663 salt
->salt_len
= 16;
16665 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16666 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16667 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16668 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16670 // this is a workaround as office produces multiple documents with the same salt
16672 salt
->salt_len
+= 32;
16674 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16675 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16676 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16677 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16678 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16679 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16680 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16681 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16687 digest
[0] = oldoffice34
->rc4key
[0];
16688 digest
[1] = oldoffice34
->rc4key
[1];
16692 return (PARSER_OK
);
16695 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16697 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16699 u32
*digest
= (u32
*) hash_buf
->digest
;
16701 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16702 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16703 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16704 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16706 digest
[0] = byte_swap_32 (digest
[0]);
16707 digest
[1] = byte_swap_32 (digest
[1]);
16708 digest
[2] = byte_swap_32 (digest
[2]);
16709 digest
[3] = byte_swap_32 (digest
[3]);
16711 return (PARSER_OK
);
16714 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16716 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16718 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16720 u32
*digest
= (u32
*) hash_buf
->digest
;
16722 salt_t
*salt
= hash_buf
->salt
;
16724 char *signature_pos
= input_buf
;
16726 char *salt_pos
= strchr (signature_pos
, '$');
16728 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16730 u32 signature_len
= salt_pos
- signature_pos
;
16732 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16736 char *hash_pos
= strchr (salt_pos
, '$');
16738 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16740 u32 salt_len
= hash_pos
- salt_pos
;
16742 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16746 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16748 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16750 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16751 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16752 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16753 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16754 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16756 digest
[0] -= SHA1M_A
;
16757 digest
[1] -= SHA1M_B
;
16758 digest
[2] -= SHA1M_C
;
16759 digest
[3] -= SHA1M_D
;
16760 digest
[4] -= SHA1M_E
;
16762 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16764 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16766 salt
->salt_len
= salt_len
;
16768 return (PARSER_OK
);
16771 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16773 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16775 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16777 u32
*digest
= (u32
*) hash_buf
->digest
;
16779 salt_t
*salt
= hash_buf
->salt
;
16781 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16787 char *iter_pos
= input_buf
+ 14;
16789 const int iter
= atoi (iter_pos
);
16791 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16793 salt
->salt_iter
= iter
- 1;
16795 char *salt_pos
= strchr (iter_pos
, '$');
16797 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16801 char *hash_pos
= strchr (salt_pos
, '$');
16803 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16805 const uint salt_len
= hash_pos
- salt_pos
;
16809 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16811 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16813 salt
->salt_len
= salt_len
;
16815 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16816 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16818 // add some stuff to normal salt to make sorted happy
16820 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16821 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16822 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16823 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16824 salt
->salt_buf
[4] = salt
->salt_iter
;
16826 // base64 decode hash
16828 u8 tmp_buf
[100] = { 0 };
16830 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16832 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16834 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16836 memcpy (digest
, tmp_buf
, 32);
16838 digest
[0] = byte_swap_32 (digest
[0]);
16839 digest
[1] = byte_swap_32 (digest
[1]);
16840 digest
[2] = byte_swap_32 (digest
[2]);
16841 digest
[3] = byte_swap_32 (digest
[3]);
16842 digest
[4] = byte_swap_32 (digest
[4]);
16843 digest
[5] = byte_swap_32 (digest
[5]);
16844 digest
[6] = byte_swap_32 (digest
[6]);
16845 digest
[7] = byte_swap_32 (digest
[7]);
16847 return (PARSER_OK
);
16850 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16852 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16854 u32
*digest
= (u32
*) hash_buf
->digest
;
16856 salt_t
*salt
= hash_buf
->salt
;
16858 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16859 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16863 digest
[0] = byte_swap_32 (digest
[0]);
16864 digest
[1] = byte_swap_32 (digest
[1]);
16866 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16867 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16868 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16870 char iter_c
= input_buf
[17];
16871 char iter_d
= input_buf
[19];
16873 // atm only defaults, let's see if there's more request
16874 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16875 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16877 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16879 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16880 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16881 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16882 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16884 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16885 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16886 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16887 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16889 salt
->salt_len
= 16;
16891 return (PARSER_OK
);
16894 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16896 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16898 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16900 u32
*digest
= (u32
*) hash_buf
->digest
;
16902 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16904 salt_t
*salt
= hash_buf
->salt
;
16906 char *salt_pos
= input_buf
+ 10;
16908 char *hash_pos
= strchr (salt_pos
, '$');
16910 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16912 uint salt_len
= hash_pos
- salt_pos
;
16916 uint hash_len
= input_len
- 10 - salt_len
- 1;
16918 // base64 decode salt
16920 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16922 u8 tmp_buf
[100] = { 0 };
16924 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16926 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16928 tmp_buf
[salt_len
] = 0x80;
16930 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16932 salt
->salt_len
= salt_len
;
16934 // base64 decode hash
16936 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16938 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16940 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16942 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16944 uint user_len
= hash_len
- 32;
16946 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16948 user_len
--; // skip the trailing space
16950 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16951 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16952 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16953 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16955 digest
[0] = byte_swap_32 (digest
[0]);
16956 digest
[1] = byte_swap_32 (digest
[1]);
16957 digest
[2] = byte_swap_32 (digest
[2]);
16958 digest
[3] = byte_swap_32 (digest
[3]);
16960 // store username for host only (output hash if cracked)
16962 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16963 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16965 return (PARSER_OK
);
16968 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16970 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16972 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16974 u32
*digest
= (u32
*) hash_buf
->digest
;
16976 salt_t
*salt
= hash_buf
->salt
;
16978 char *iter_pos
= input_buf
+ 10;
16980 u32 iter
= atoi (iter_pos
);
16984 return (PARSER_SALT_ITERATION
);
16987 iter
--; // first iteration is special
16989 salt
->salt_iter
= iter
;
16991 char *base64_pos
= strchr (iter_pos
, '}');
16993 if (base64_pos
== NULL
)
16995 return (PARSER_SIGNATURE_UNMATCHED
);
17000 // base64 decode salt
17002 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
17004 u8 tmp_buf
[100] = { 0 };
17006 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
17008 if (decoded_len
< 24)
17010 return (PARSER_SALT_LENGTH
);
17015 uint salt_len
= decoded_len
- 20;
17017 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
17018 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
17020 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
17022 salt
->salt_len
= salt_len
;
17026 u32
*digest_ptr
= (u32
*) tmp_buf
;
17028 digest
[0] = byte_swap_32 (digest_ptr
[0]);
17029 digest
[1] = byte_swap_32 (digest_ptr
[1]);
17030 digest
[2] = byte_swap_32 (digest_ptr
[2]);
17031 digest
[3] = byte_swap_32 (digest_ptr
[3]);
17032 digest
[4] = byte_swap_32 (digest_ptr
[4]);
17034 return (PARSER_OK
);
17037 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17039 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
17041 u32
*digest
= (u32
*) hash_buf
->digest
;
17043 salt_t
*salt
= hash_buf
->salt
;
17045 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17046 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17047 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17048 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17049 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
17051 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17053 uint salt_len
= input_len
- 40 - 1;
17055 char *salt_buf
= input_buf
+ 40 + 1;
17057 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17059 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17061 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
17063 salt
->salt_len
= salt_len
;
17065 return (PARSER_OK
);
17068 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17070 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
17072 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17074 u32
*digest
= (u32
*) hash_buf
->digest
;
17076 salt_t
*salt
= hash_buf
->salt
;
17078 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17084 char *V_pos
= input_buf
+ 5;
17086 char *R_pos
= strchr (V_pos
, '*');
17088 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17090 u32 V_len
= R_pos
- V_pos
;
17094 char *bits_pos
= strchr (R_pos
, '*');
17096 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17098 u32 R_len
= bits_pos
- R_pos
;
17102 char *P_pos
= strchr (bits_pos
, '*');
17104 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17106 u32 bits_len
= P_pos
- bits_pos
;
17110 char *enc_md_pos
= strchr (P_pos
, '*');
17112 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17114 u32 P_len
= enc_md_pos
- P_pos
;
17118 char *id_len_pos
= strchr (enc_md_pos
, '*');
17120 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17122 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17126 char *id_buf_pos
= strchr (id_len_pos
, '*');
17128 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17130 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17134 char *u_len_pos
= strchr (id_buf_pos
, '*');
17136 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17138 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17140 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17144 char *u_buf_pos
= strchr (u_len_pos
, '*');
17146 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17148 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17152 char *o_len_pos
= strchr (u_buf_pos
, '*');
17154 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17156 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17158 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17162 char *o_buf_pos
= strchr (o_len_pos
, '*');
17164 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17166 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17170 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;
17172 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17176 const int V
= atoi (V_pos
);
17177 const int R
= atoi (R_pos
);
17178 const int P
= atoi (P_pos
);
17180 if (V
!= 1) return (PARSER_SALT_VALUE
);
17181 if (R
!= 2) return (PARSER_SALT_VALUE
);
17183 const int enc_md
= atoi (enc_md_pos
);
17185 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17187 const int id_len
= atoi (id_len_pos
);
17188 const int u_len
= atoi (u_len_pos
);
17189 const int o_len
= atoi (o_len_pos
);
17191 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17192 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17193 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17195 const int bits
= atoi (bits_pos
);
17197 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17199 // copy data to esalt
17205 pdf
->enc_md
= enc_md
;
17207 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17208 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17209 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17210 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17211 pdf
->id_len
= id_len
;
17213 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17214 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17215 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17216 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17217 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17218 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17219 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17220 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17221 pdf
->u_len
= u_len
;
17223 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17224 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17225 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17226 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17227 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17228 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17229 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17230 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17231 pdf
->o_len
= o_len
;
17233 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17234 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17235 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17236 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17238 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17239 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17240 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17241 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17242 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17243 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17244 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17245 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17247 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17248 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17249 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17250 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17251 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17252 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17253 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17254 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17256 // we use ID for salt, maybe needs to change, we will see...
17258 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17259 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17260 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17261 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17262 salt
->salt_len
= pdf
->id_len
;
17264 digest
[0] = pdf
->u_buf
[0];
17265 digest
[1] = pdf
->u_buf
[1];
17266 digest
[2] = pdf
->u_buf
[2];
17267 digest
[3] = pdf
->u_buf
[3];
17269 return (PARSER_OK
);
17272 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17274 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17277 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17279 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17281 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17283 u32
*digest
= (u32
*) hash_buf
->digest
;
17285 salt_t
*salt
= hash_buf
->salt
;
17287 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17293 char *V_pos
= input_buf
+ 5;
17295 char *R_pos
= strchr (V_pos
, '*');
17297 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17299 u32 V_len
= R_pos
- V_pos
;
17303 char *bits_pos
= strchr (R_pos
, '*');
17305 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17307 u32 R_len
= bits_pos
- R_pos
;
17311 char *P_pos
= strchr (bits_pos
, '*');
17313 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17315 u32 bits_len
= P_pos
- bits_pos
;
17319 char *enc_md_pos
= strchr (P_pos
, '*');
17321 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17323 u32 P_len
= enc_md_pos
- P_pos
;
17327 char *id_len_pos
= strchr (enc_md_pos
, '*');
17329 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17331 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17335 char *id_buf_pos
= strchr (id_len_pos
, '*');
17337 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17339 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17343 char *u_len_pos
= strchr (id_buf_pos
, '*');
17345 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17347 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17349 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17353 char *u_buf_pos
= strchr (u_len_pos
, '*');
17355 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17357 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17361 char *o_len_pos
= strchr (u_buf_pos
, '*');
17363 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17365 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17367 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17371 char *o_buf_pos
= strchr (o_len_pos
, '*');
17373 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17375 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17379 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17381 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17383 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17385 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17389 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;
17391 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17395 const int V
= atoi (V_pos
);
17396 const int R
= atoi (R_pos
);
17397 const int P
= atoi (P_pos
);
17399 if (V
!= 1) return (PARSER_SALT_VALUE
);
17400 if (R
!= 2) return (PARSER_SALT_VALUE
);
17402 const int enc_md
= atoi (enc_md_pos
);
17404 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17406 const int id_len
= atoi (id_len_pos
);
17407 const int u_len
= atoi (u_len_pos
);
17408 const int o_len
= atoi (o_len_pos
);
17410 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17411 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17412 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17414 const int bits
= atoi (bits_pos
);
17416 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17418 // copy data to esalt
17424 pdf
->enc_md
= enc_md
;
17426 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17427 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17428 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17429 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17430 pdf
->id_len
= id_len
;
17432 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17433 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17434 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17435 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17436 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17437 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17438 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17439 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17440 pdf
->u_len
= u_len
;
17442 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17443 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17444 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17445 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17446 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17447 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17448 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17449 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17450 pdf
->o_len
= o_len
;
17452 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17453 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17454 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17455 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17457 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17458 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17459 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17460 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17461 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17462 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17463 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17464 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17466 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17467 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17468 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17469 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17470 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17471 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17472 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17473 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17475 pdf
->rc4key
[1] = 0;
17476 pdf
->rc4key
[0] = 0;
17478 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17479 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17480 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17481 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17482 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17483 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17484 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17485 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17486 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17487 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17489 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17490 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17492 // we use ID for salt, maybe needs to change, we will see...
17494 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17495 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17496 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17497 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17498 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17499 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17500 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17501 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17502 salt
->salt_len
= pdf
->id_len
+ 16;
17504 digest
[0] = pdf
->rc4key
[0];
17505 digest
[1] = pdf
->rc4key
[1];
17509 return (PARSER_OK
);
17512 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17514 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17516 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17518 u32
*digest
= (u32
*) hash_buf
->digest
;
17520 salt_t
*salt
= hash_buf
->salt
;
17522 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17528 char *V_pos
= input_buf
+ 5;
17530 char *R_pos
= strchr (V_pos
, '*');
17532 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17534 u32 V_len
= R_pos
- V_pos
;
17538 char *bits_pos
= strchr (R_pos
, '*');
17540 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17542 u32 R_len
= bits_pos
- R_pos
;
17546 char *P_pos
= strchr (bits_pos
, '*');
17548 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17550 u32 bits_len
= P_pos
- bits_pos
;
17554 char *enc_md_pos
= strchr (P_pos
, '*');
17556 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17558 u32 P_len
= enc_md_pos
- P_pos
;
17562 char *id_len_pos
= strchr (enc_md_pos
, '*');
17564 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17566 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17570 char *id_buf_pos
= strchr (id_len_pos
, '*');
17572 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17574 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17578 char *u_len_pos
= strchr (id_buf_pos
, '*');
17580 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17582 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17584 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17588 char *u_buf_pos
= strchr (u_len_pos
, '*');
17590 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17592 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17596 char *o_len_pos
= strchr (u_buf_pos
, '*');
17598 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17600 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17602 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17606 char *o_buf_pos
= strchr (o_len_pos
, '*');
17608 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17610 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17614 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;
17616 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17620 const int V
= atoi (V_pos
);
17621 const int R
= atoi (R_pos
);
17622 const int P
= atoi (P_pos
);
17626 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17627 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17629 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17631 const int id_len
= atoi (id_len_pos
);
17632 const int u_len
= atoi (u_len_pos
);
17633 const int o_len
= atoi (o_len_pos
);
17635 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17637 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17638 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17640 const int bits
= atoi (bits_pos
);
17642 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17648 enc_md
= atoi (enc_md_pos
);
17651 // copy data to esalt
17657 pdf
->enc_md
= enc_md
;
17659 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17660 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17661 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17662 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17666 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17667 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17668 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17669 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17672 pdf
->id_len
= id_len
;
17674 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17675 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17676 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17677 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17678 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17679 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17680 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17681 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17682 pdf
->u_len
= u_len
;
17684 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17685 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17686 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17687 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17688 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17689 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17690 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17691 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17692 pdf
->o_len
= o_len
;
17694 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17695 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17696 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17697 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17701 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17702 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17703 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17704 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17707 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17708 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17709 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17710 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17711 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17712 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17713 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17714 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17716 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17717 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17718 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17719 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17720 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17721 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17722 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17723 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17725 // precompute rc4 data for later use
17741 uint salt_pc_block
[32] = { 0 };
17743 char *salt_pc_ptr
= (char *) salt_pc_block
;
17745 memcpy (salt_pc_ptr
, padding
, 32);
17746 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17748 uint salt_pc_digest
[4] = { 0 };
17750 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17752 pdf
->rc4data
[0] = salt_pc_digest
[0];
17753 pdf
->rc4data
[1] = salt_pc_digest
[1];
17755 // we use ID for salt, maybe needs to change, we will see...
17757 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17758 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17759 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17760 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17761 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17762 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17763 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17764 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17765 salt
->salt_len
= pdf
->id_len
+ 16;
17767 salt
->salt_iter
= ROUNDS_PDF14
;
17769 digest
[0] = pdf
->u_buf
[0];
17770 digest
[1] = pdf
->u_buf
[1];
17774 return (PARSER_OK
);
17777 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17779 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17781 if (ret
!= PARSER_OK
)
17786 u32
*digest
= (u32
*) hash_buf
->digest
;
17788 salt_t
*salt
= hash_buf
->salt
;
17790 digest
[0] -= SHA256M_A
;
17791 digest
[1] -= SHA256M_B
;
17792 digest
[2] -= SHA256M_C
;
17793 digest
[3] -= SHA256M_D
;
17794 digest
[4] -= SHA256M_E
;
17795 digest
[5] -= SHA256M_F
;
17796 digest
[6] -= SHA256M_G
;
17797 digest
[7] -= SHA256M_H
;
17799 salt
->salt_buf
[2] = 0x80;
17801 return (PARSER_OK
);
17804 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17806 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17808 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17810 u32
*digest
= (u32
*) hash_buf
->digest
;
17812 salt_t
*salt
= hash_buf
->salt
;
17814 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17820 char *V_pos
= input_buf
+ 5;
17822 char *R_pos
= strchr (V_pos
, '*');
17824 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17826 u32 V_len
= R_pos
- V_pos
;
17830 char *bits_pos
= strchr (R_pos
, '*');
17832 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17834 u32 R_len
= bits_pos
- R_pos
;
17838 char *P_pos
= strchr (bits_pos
, '*');
17840 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17842 u32 bits_len
= P_pos
- bits_pos
;
17846 char *enc_md_pos
= strchr (P_pos
, '*');
17848 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17850 u32 P_len
= enc_md_pos
- P_pos
;
17854 char *id_len_pos
= strchr (enc_md_pos
, '*');
17856 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17858 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17862 char *id_buf_pos
= strchr (id_len_pos
, '*');
17864 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17866 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17870 char *u_len_pos
= strchr (id_buf_pos
, '*');
17872 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17874 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17878 char *u_buf_pos
= strchr (u_len_pos
, '*');
17880 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17882 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17886 char *o_len_pos
= strchr (u_buf_pos
, '*');
17888 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17890 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17894 char *o_buf_pos
= strchr (o_len_pos
, '*');
17896 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17898 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17902 char *last
= strchr (o_buf_pos
, '*');
17904 if (last
== NULL
) last
= input_buf
+ input_len
;
17906 u32 o_buf_len
= last
- o_buf_pos
;
17910 const int V
= atoi (V_pos
);
17911 const int R
= atoi (R_pos
);
17915 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17916 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17918 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17920 const int bits
= atoi (bits_pos
);
17922 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17924 int enc_md
= atoi (enc_md_pos
);
17926 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17928 const uint id_len
= atoi (id_len_pos
);
17929 const uint u_len
= atoi (u_len_pos
);
17930 const uint o_len
= atoi (o_len_pos
);
17932 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17933 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17934 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17935 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17936 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17937 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17938 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17939 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17941 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17942 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17943 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17945 // copy data to esalt
17947 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17949 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17951 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17954 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17955 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17957 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17958 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17960 salt
->salt_len
= 8;
17961 salt
->salt_iter
= ROUNDS_PDF17L8
;
17963 digest
[0] = pdf
->u_buf
[0];
17964 digest
[1] = pdf
->u_buf
[1];
17965 digest
[2] = pdf
->u_buf
[2];
17966 digest
[3] = pdf
->u_buf
[3];
17967 digest
[4] = pdf
->u_buf
[4];
17968 digest
[5] = pdf
->u_buf
[5];
17969 digest
[6] = pdf
->u_buf
[6];
17970 digest
[7] = pdf
->u_buf
[7];
17972 return (PARSER_OK
);
17975 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17977 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17979 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17981 u32
*digest
= (u32
*) hash_buf
->digest
;
17983 salt_t
*salt
= hash_buf
->salt
;
17985 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17993 char *iter_pos
= input_buf
+ 7;
17995 u32 iter
= atoi (iter_pos
);
17997 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17998 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18000 // first is *raw* salt
18002 char *salt_pos
= strchr (iter_pos
, ':');
18004 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18008 char *hash_pos
= strchr (salt_pos
, ':');
18010 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18012 u32 salt_len
= hash_pos
- salt_pos
;
18014 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18018 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18020 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18024 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
18026 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18028 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18030 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18031 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18033 salt
->salt_len
= salt_len
;
18034 salt
->salt_iter
= iter
- 1;
18038 u8 tmp_buf
[100] = { 0 };
18040 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18042 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18044 memcpy (digest
, tmp_buf
, 16);
18046 digest
[0] = byte_swap_32 (digest
[0]);
18047 digest
[1] = byte_swap_32 (digest
[1]);
18048 digest
[2] = byte_swap_32 (digest
[2]);
18049 digest
[3] = byte_swap_32 (digest
[3]);
18051 // add some stuff to normal salt to make sorted happy
18053 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
18054 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
18055 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
18056 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
18057 salt
->salt_buf
[4] = salt
->salt_iter
;
18059 return (PARSER_OK
);
18062 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18064 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
18066 u32
*digest
= (u32
*) hash_buf
->digest
;
18068 salt_t
*salt
= hash_buf
->salt
;
18070 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18071 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18072 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18073 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18075 digest
[0] = byte_swap_32 (digest
[0]);
18076 digest
[1] = byte_swap_32 (digest
[1]);
18077 digest
[2] = byte_swap_32 (digest
[2]);
18078 digest
[3] = byte_swap_32 (digest
[3]);
18080 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18082 uint salt_len
= input_len
- 32 - 1;
18084 char *salt_buf
= input_buf
+ 32 + 1;
18086 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18088 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18090 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18092 salt
->salt_len
= salt_len
;
18094 return (PARSER_OK
);
18097 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18099 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
18101 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18103 u32
*digest
= (u32
*) hash_buf
->digest
;
18105 salt_t
*salt
= hash_buf
->salt
;
18107 char *user_pos
= input_buf
+ 10;
18109 char *salt_pos
= strchr (user_pos
, '*');
18111 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18115 char *hash_pos
= strchr (salt_pos
, '*');
18119 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18121 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18123 uint user_len
= salt_pos
- user_pos
- 1;
18125 uint salt_len
= hash_pos
- salt_pos
- 1;
18127 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18133 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18134 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18135 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18136 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18138 digest
[0] = byte_swap_32 (digest
[0]);
18139 digest
[1] = byte_swap_32 (digest
[1]);
18140 digest
[2] = byte_swap_32 (digest
[2]);
18141 digest
[3] = byte_swap_32 (digest
[3]);
18143 digest
[0] -= MD5M_A
;
18144 digest
[1] -= MD5M_B
;
18145 digest
[2] -= MD5M_C
;
18146 digest
[3] -= MD5M_D
;
18152 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18154 // first 4 bytes are the "challenge"
18156 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18157 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18158 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18159 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18161 // append the user name
18163 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18165 salt
->salt_len
= 4 + user_len
;
18167 return (PARSER_OK
);
18170 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18172 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18174 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18176 u32
*digest
= (u32
*) hash_buf
->digest
;
18178 salt_t
*salt
= hash_buf
->salt
;
18180 char *salt_pos
= input_buf
+ 9;
18182 char *hash_pos
= strchr (salt_pos
, '*');
18184 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18188 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18190 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18192 uint salt_len
= hash_pos
- salt_pos
- 1;
18194 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18200 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18201 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18202 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18203 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18204 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18210 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18212 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18214 salt
->salt_len
= salt_len
;
18216 return (PARSER_OK
);
18219 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18221 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18223 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18225 u32
*digest
= (u32
*) hash_buf
->digest
;
18227 salt_t
*salt
= hash_buf
->salt
;
18229 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18235 char *cry_master_len_pos
= input_buf
+ 9;
18237 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18239 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18241 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18243 cry_master_buf_pos
++;
18245 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18247 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18249 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18251 cry_salt_len_pos
++;
18253 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18255 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18257 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18259 cry_salt_buf_pos
++;
18261 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18263 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18265 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18269 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18271 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18273 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18277 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18279 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18281 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18285 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18287 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18289 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18291 public_key_len_pos
++;
18293 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18295 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18297 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18299 public_key_buf_pos
++;
18301 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;
18303 const uint cry_master_len
= atoi (cry_master_len_pos
);
18304 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18305 const uint ckey_len
= atoi (ckey_len_pos
);
18306 const uint public_key_len
= atoi (public_key_len_pos
);
18308 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18309 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18310 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18311 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18313 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18315 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18317 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18320 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18322 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18324 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18327 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18329 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18331 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18334 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18335 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18336 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18339 * store digest (should be unique enought, hopefully)
18342 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18343 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18344 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18345 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18351 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18353 const uint cry_rounds
= atoi (cry_rounds_pos
);
18355 salt
->salt_iter
= cry_rounds
- 1;
18357 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18359 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18361 salt
->salt_len
= salt_len
;
18363 return (PARSER_OK
);
18366 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18368 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18370 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18372 u32
*digest
= (u32
*) hash_buf
->digest
;
18374 salt_t
*salt
= hash_buf
->salt
;
18376 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18378 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18380 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18382 memcpy (temp_input_buf
, input_buf
, input_len
);
18386 char *URI_server_pos
= temp_input_buf
+ 6;
18388 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18390 if (URI_client_pos
== NULL
)
18392 myfree (temp_input_buf
);
18394 return (PARSER_SEPARATOR_UNMATCHED
);
18397 URI_client_pos
[0] = 0;
18400 uint URI_server_len
= strlen (URI_server_pos
);
18402 if (URI_server_len
> 512)
18404 myfree (temp_input_buf
);
18406 return (PARSER_SALT_LENGTH
);
18411 char *user_pos
= strchr (URI_client_pos
, '*');
18413 if (user_pos
== NULL
)
18415 myfree (temp_input_buf
);
18417 return (PARSER_SEPARATOR_UNMATCHED
);
18423 uint URI_client_len
= strlen (URI_client_pos
);
18425 if (URI_client_len
> 512)
18427 myfree (temp_input_buf
);
18429 return (PARSER_SALT_LENGTH
);
18434 char *realm_pos
= strchr (user_pos
, '*');
18436 if (realm_pos
== NULL
)
18438 myfree (temp_input_buf
);
18440 return (PARSER_SEPARATOR_UNMATCHED
);
18446 uint user_len
= strlen (user_pos
);
18448 if (user_len
> 116)
18450 myfree (temp_input_buf
);
18452 return (PARSER_SALT_LENGTH
);
18457 char *method_pos
= strchr (realm_pos
, '*');
18459 if (method_pos
== NULL
)
18461 myfree (temp_input_buf
);
18463 return (PARSER_SEPARATOR_UNMATCHED
);
18469 uint realm_len
= strlen (realm_pos
);
18471 if (realm_len
> 116)
18473 myfree (temp_input_buf
);
18475 return (PARSER_SALT_LENGTH
);
18480 char *URI_prefix_pos
= strchr (method_pos
, '*');
18482 if (URI_prefix_pos
== NULL
)
18484 myfree (temp_input_buf
);
18486 return (PARSER_SEPARATOR_UNMATCHED
);
18489 URI_prefix_pos
[0] = 0;
18492 uint method_len
= strlen (method_pos
);
18494 if (method_len
> 246)
18496 myfree (temp_input_buf
);
18498 return (PARSER_SALT_LENGTH
);
18503 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18505 if (URI_resource_pos
== NULL
)
18507 myfree (temp_input_buf
);
18509 return (PARSER_SEPARATOR_UNMATCHED
);
18512 URI_resource_pos
[0] = 0;
18513 URI_resource_pos
++;
18515 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18517 if (URI_prefix_len
> 245)
18519 myfree (temp_input_buf
);
18521 return (PARSER_SALT_LENGTH
);
18526 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18528 if (URI_suffix_pos
== NULL
)
18530 myfree (temp_input_buf
);
18532 return (PARSER_SEPARATOR_UNMATCHED
);
18535 URI_suffix_pos
[0] = 0;
18538 uint URI_resource_len
= strlen (URI_resource_pos
);
18540 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18542 myfree (temp_input_buf
);
18544 return (PARSER_SALT_LENGTH
);
18549 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18551 if (nonce_pos
== NULL
)
18553 myfree (temp_input_buf
);
18555 return (PARSER_SEPARATOR_UNMATCHED
);
18561 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18563 if (URI_suffix_len
> 245)
18565 myfree (temp_input_buf
);
18567 return (PARSER_SALT_LENGTH
);
18572 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18574 if (nonce_client_pos
== NULL
)
18576 myfree (temp_input_buf
);
18578 return (PARSER_SEPARATOR_UNMATCHED
);
18581 nonce_client_pos
[0] = 0;
18582 nonce_client_pos
++;
18584 uint nonce_len
= strlen (nonce_pos
);
18586 if (nonce_len
< 1 || nonce_len
> 50)
18588 myfree (temp_input_buf
);
18590 return (PARSER_SALT_LENGTH
);
18595 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18597 if (nonce_count_pos
== NULL
)
18599 myfree (temp_input_buf
);
18601 return (PARSER_SEPARATOR_UNMATCHED
);
18604 nonce_count_pos
[0] = 0;
18607 uint nonce_client_len
= strlen (nonce_client_pos
);
18609 if (nonce_client_len
> 50)
18611 myfree (temp_input_buf
);
18613 return (PARSER_SALT_LENGTH
);
18618 char *qop_pos
= strchr (nonce_count_pos
, '*');
18620 if (qop_pos
== NULL
)
18622 myfree (temp_input_buf
);
18624 return (PARSER_SEPARATOR_UNMATCHED
);
18630 uint nonce_count_len
= strlen (nonce_count_pos
);
18632 if (nonce_count_len
> 50)
18634 myfree (temp_input_buf
);
18636 return (PARSER_SALT_LENGTH
);
18641 char *directive_pos
= strchr (qop_pos
, '*');
18643 if (directive_pos
== NULL
)
18645 myfree (temp_input_buf
);
18647 return (PARSER_SEPARATOR_UNMATCHED
);
18650 directive_pos
[0] = 0;
18653 uint qop_len
= strlen (qop_pos
);
18657 myfree (temp_input_buf
);
18659 return (PARSER_SALT_LENGTH
);
18664 char *digest_pos
= strchr (directive_pos
, '*');
18666 if (digest_pos
== NULL
)
18668 myfree (temp_input_buf
);
18670 return (PARSER_SEPARATOR_UNMATCHED
);
18676 uint directive_len
= strlen (directive_pos
);
18678 if (directive_len
!= 3)
18680 myfree (temp_input_buf
);
18682 return (PARSER_SALT_LENGTH
);
18685 if (memcmp (directive_pos
, "MD5", 3))
18687 log_info ("ERROR: Only the MD5 directive is currently supported\n");
18689 myfree (temp_input_buf
);
18691 return (PARSER_SIP_AUTH_DIRECTIVE
);
18695 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18700 uint md5_max_len
= 4 * 64;
18702 uint md5_remaining_len
= md5_max_len
;
18704 uint tmp_md5_buf
[64] = { 0 };
18706 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18708 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18710 md5_len
+= method_len
+ 1;
18711 tmp_md5_ptr
+= method_len
+ 1;
18713 if (URI_prefix_len
> 0)
18715 md5_remaining_len
= md5_max_len
- md5_len
;
18717 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18719 md5_len
+= URI_prefix_len
+ 1;
18720 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18723 md5_remaining_len
= md5_max_len
- md5_len
;
18725 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18727 md5_len
+= URI_resource_len
;
18728 tmp_md5_ptr
+= URI_resource_len
;
18730 if (URI_suffix_len
> 0)
18732 md5_remaining_len
= md5_max_len
- md5_len
;
18734 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18736 md5_len
+= 1 + URI_suffix_len
;
18739 uint tmp_digest
[4] = { 0 };
18741 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18743 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18744 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18745 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18746 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18752 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18754 uint esalt_len
= 0;
18756 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18758 // there are 2 possibilities for the esalt:
18760 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18762 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18764 if (esalt_len
> max_esalt_len
)
18766 myfree (temp_input_buf
);
18768 return (PARSER_SALT_LENGTH
);
18771 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18783 esalt_len
= 1 + nonce_len
+ 1 + 32;
18785 if (esalt_len
> max_esalt_len
)
18787 myfree (temp_input_buf
);
18789 return (PARSER_SALT_LENGTH
);
18792 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18800 // add 0x80 to esalt
18802 esalt_buf_ptr
[esalt_len
] = 0x80;
18804 sip
->esalt_len
= esalt_len
;
18810 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18812 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18814 uint max_salt_len
= 119;
18816 if (salt_len
> max_salt_len
)
18818 myfree (temp_input_buf
);
18820 return (PARSER_SALT_LENGTH
);
18823 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18825 sip
->salt_len
= salt_len
;
18828 * fake salt (for sorting)
18831 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18835 uint fake_salt_len
= salt_len
;
18837 if (fake_salt_len
> max_salt_len
)
18839 fake_salt_len
= max_salt_len
;
18842 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18844 salt
->salt_len
= fake_salt_len
;
18850 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18851 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18852 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18853 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18855 digest
[0] = byte_swap_32 (digest
[0]);
18856 digest
[1] = byte_swap_32 (digest
[1]);
18857 digest
[2] = byte_swap_32 (digest
[2]);
18858 digest
[3] = byte_swap_32 (digest
[3]);
18860 myfree (temp_input_buf
);
18862 return (PARSER_OK
);
18865 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18867 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18869 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18871 u32
*digest
= (u32
*) hash_buf
->digest
;
18873 salt_t
*salt
= hash_buf
->salt
;
18877 char *digest_pos
= input_buf
;
18879 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18886 char *salt_buf
= input_buf
+ 8 + 1;
18890 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18892 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18894 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18896 salt
->salt_len
= salt_len
;
18898 return (PARSER_OK
);
18901 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18903 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18905 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18907 u32
*digest
= (u32
*) hash_buf
->digest
;
18909 salt_t
*salt
= hash_buf
->salt
;
18911 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18917 char *p_buf_pos
= input_buf
+ 4;
18919 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18921 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18923 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18925 NumCyclesPower_pos
++;
18927 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18929 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18931 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18935 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18937 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18939 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18943 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18945 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18947 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18951 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18953 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18955 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18959 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18961 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18963 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18967 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18969 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18971 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18975 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18977 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18979 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18983 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18985 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18987 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18991 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;
18993 const uint iter
= atoi (NumCyclesPower_pos
);
18994 const uint crc
= atoi (crc_buf_pos
);
18995 const uint p_buf
= atoi (p_buf_pos
);
18996 const uint salt_len
= atoi (salt_len_pos
);
18997 const uint iv_len
= atoi (iv_len_pos
);
18998 const uint unpack_size
= atoi (unpack_size_pos
);
18999 const uint data_len
= atoi (data_len_pos
);
19005 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
19006 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
19008 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
19010 if (data_len
> 384) return (PARSER_SALT_VALUE
);
19012 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
19018 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
19019 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
19020 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
19021 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
19023 seven_zip
->iv_len
= iv_len
;
19025 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
19027 seven_zip
->salt_len
= 0;
19029 seven_zip
->crc
= crc
;
19031 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
19033 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
19035 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
19038 seven_zip
->data_len
= data_len
;
19040 seven_zip
->unpack_size
= unpack_size
;
19044 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
19045 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
19046 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
19047 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
19049 salt
->salt_len
= 16;
19051 salt
->salt_sign
[0] = iter
;
19053 salt
->salt_iter
= 1 << iter
;
19064 return (PARSER_OK
);
19067 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19069 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
19071 u32
*digest
= (u32
*) hash_buf
->digest
;
19073 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19074 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19075 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19076 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19077 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19078 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19079 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19080 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19082 digest
[0] = byte_swap_32 (digest
[0]);
19083 digest
[1] = byte_swap_32 (digest
[1]);
19084 digest
[2] = byte_swap_32 (digest
[2]);
19085 digest
[3] = byte_swap_32 (digest
[3]);
19086 digest
[4] = byte_swap_32 (digest
[4]);
19087 digest
[5] = byte_swap_32 (digest
[5]);
19088 digest
[6] = byte_swap_32 (digest
[6]);
19089 digest
[7] = byte_swap_32 (digest
[7]);
19091 return (PARSER_OK
);
19094 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19096 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
19098 u32
*digest
= (u32
*) hash_buf
->digest
;
19100 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19101 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19102 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
19103 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
19104 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
19105 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
19106 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
19107 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
19108 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
19109 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
19110 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
19111 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
19112 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
19113 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
19114 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
19115 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
19117 digest
[ 0] = byte_swap_32 (digest
[ 0]);
19118 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19119 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19120 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19121 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19122 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19123 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19124 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19125 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19126 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19127 digest
[10] = byte_swap_32 (digest
[10]);
19128 digest
[11] = byte_swap_32 (digest
[11]);
19129 digest
[12] = byte_swap_32 (digest
[12]);
19130 digest
[13] = byte_swap_32 (digest
[13]);
19131 digest
[14] = byte_swap_32 (digest
[14]);
19132 digest
[15] = byte_swap_32 (digest
[15]);
19134 return (PARSER_OK
);
19137 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19139 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19141 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19143 u32
*digest
= (u32
*) hash_buf
->digest
;
19145 salt_t
*salt
= hash_buf
->salt
;
19147 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19155 char *iter_pos
= input_buf
+ 4;
19157 u32 iter
= atoi (iter_pos
);
19159 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19160 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19162 // first is *raw* salt
19164 char *salt_pos
= strchr (iter_pos
, ':');
19166 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19170 char *hash_pos
= strchr (salt_pos
, ':');
19172 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19174 u32 salt_len
= hash_pos
- salt_pos
;
19176 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19180 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19182 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19186 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19188 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19190 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19192 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19193 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19195 salt
->salt_len
= salt_len
;
19196 salt
->salt_iter
= iter
- 1;
19200 u8 tmp_buf
[100] = { 0 };
19202 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19204 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19206 memcpy (digest
, tmp_buf
, 16);
19208 // add some stuff to normal salt to make sorted happy
19210 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19211 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19212 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19213 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19214 salt
->salt_buf
[4] = salt
->salt_iter
;
19216 return (PARSER_OK
);
19219 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19221 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19223 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19225 u32
*digest
= (u32
*) hash_buf
->digest
;
19227 salt_t
*salt
= hash_buf
->salt
;
19229 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19237 char *iter_pos
= input_buf
+ 5;
19239 u32 iter
= atoi (iter_pos
);
19241 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19242 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19244 // first is *raw* salt
19246 char *salt_pos
= strchr (iter_pos
, ':');
19248 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19252 char *hash_pos
= strchr (salt_pos
, ':');
19254 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19256 u32 salt_len
= hash_pos
- salt_pos
;
19258 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19262 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19264 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19268 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19270 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19272 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19274 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19275 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19277 salt
->salt_len
= salt_len
;
19278 salt
->salt_iter
= iter
- 1;
19282 u8 tmp_buf
[100] = { 0 };
19284 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19286 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19288 memcpy (digest
, tmp_buf
, 16);
19290 digest
[0] = byte_swap_32 (digest
[0]);
19291 digest
[1] = byte_swap_32 (digest
[1]);
19292 digest
[2] = byte_swap_32 (digest
[2]);
19293 digest
[3] = byte_swap_32 (digest
[3]);
19295 // add some stuff to normal salt to make sorted happy
19297 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19298 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19299 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19300 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19301 salt
->salt_buf
[4] = salt
->salt_iter
;
19303 return (PARSER_OK
);
19306 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19308 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19310 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19312 u64
*digest
= (u64
*) hash_buf
->digest
;
19314 salt_t
*salt
= hash_buf
->salt
;
19316 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19324 char *iter_pos
= input_buf
+ 7;
19326 u32 iter
= atoi (iter_pos
);
19328 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19329 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19331 // first is *raw* salt
19333 char *salt_pos
= strchr (iter_pos
, ':');
19335 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19339 char *hash_pos
= strchr (salt_pos
, ':');
19341 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19343 u32 salt_len
= hash_pos
- salt_pos
;
19345 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19349 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19351 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19355 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19357 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19359 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19361 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19362 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19364 salt
->salt_len
= salt_len
;
19365 salt
->salt_iter
= iter
- 1;
19369 u8 tmp_buf
[100] = { 0 };
19371 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19373 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19375 memcpy (digest
, tmp_buf
, 64);
19377 digest
[0] = byte_swap_64 (digest
[0]);
19378 digest
[1] = byte_swap_64 (digest
[1]);
19379 digest
[2] = byte_swap_64 (digest
[2]);
19380 digest
[3] = byte_swap_64 (digest
[3]);
19381 digest
[4] = byte_swap_64 (digest
[4]);
19382 digest
[5] = byte_swap_64 (digest
[5]);
19383 digest
[6] = byte_swap_64 (digest
[6]);
19384 digest
[7] = byte_swap_64 (digest
[7]);
19386 // add some stuff to normal salt to make sorted happy
19388 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19389 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19390 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19391 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19392 salt
->salt_buf
[4] = salt
->salt_iter
;
19394 return (PARSER_OK
);
19397 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19399 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19401 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19403 uint
*digest
= (uint
*) hash_buf
->digest
;
19405 salt_t
*salt
= hash_buf
->salt
;
19411 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19413 char *hash_pos
= strchr (salt_pos
, '$');
19415 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19417 u32 salt_len
= hash_pos
- salt_pos
;
19419 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19423 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19425 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19429 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19430 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19448 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19449 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19451 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19452 salt
->salt_len
= 8;
19454 return (PARSER_OK
);
19457 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19459 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19461 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19463 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19465 if (c19
& 3) return (PARSER_HASH_VALUE
);
19467 salt_t
*salt
= hash_buf
->salt
;
19469 u32
*digest
= (u32
*) hash_buf
->digest
;
19473 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19474 | itoa64_to_int (input_buf
[2]) << 6
19475 | itoa64_to_int (input_buf
[3]) << 12
19476 | itoa64_to_int (input_buf
[4]) << 18;
19480 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19481 | itoa64_to_int (input_buf
[6]) << 6
19482 | itoa64_to_int (input_buf
[7]) << 12
19483 | itoa64_to_int (input_buf
[8]) << 18;
19485 salt
->salt_len
= 4;
19487 u8 tmp_buf
[100] = { 0 };
19489 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19491 memcpy (digest
, tmp_buf
, 8);
19495 IP (digest
[0], digest
[1], tt
);
19497 digest
[0] = rotr32 (digest
[0], 31);
19498 digest
[1] = rotr32 (digest
[1], 31);
19502 return (PARSER_OK
);
19505 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19507 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19509 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19511 u32
*digest
= (u32
*) hash_buf
->digest
;
19513 salt_t
*salt
= hash_buf
->salt
;
19519 char *type_pos
= input_buf
+ 6 + 1;
19521 char *salt_pos
= strchr (type_pos
, '*');
19523 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19525 u32 type_len
= salt_pos
- type_pos
;
19527 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19531 char *crypted_pos
= strchr (salt_pos
, '*');
19533 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19535 u32 salt_len
= crypted_pos
- salt_pos
;
19537 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19541 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19543 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19549 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19550 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19552 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19553 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19555 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19556 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19557 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19558 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19560 salt
->salt_len
= 24;
19561 salt
->salt_iter
= ROUNDS_RAR3
;
19563 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19564 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19566 digest
[0] = 0xc43d7b00;
19567 digest
[1] = 0x40070000;
19571 return (PARSER_OK
);
19574 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19576 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19578 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19580 u32
*digest
= (u32
*) hash_buf
->digest
;
19582 salt_t
*salt
= hash_buf
->salt
;
19584 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19590 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19592 char *param1_pos
= strchr (param0_pos
, '$');
19594 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19596 u32 param0_len
= param1_pos
- param0_pos
;
19600 char *param2_pos
= strchr (param1_pos
, '$');
19602 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19604 u32 param1_len
= param2_pos
- param1_pos
;
19608 char *param3_pos
= strchr (param2_pos
, '$');
19610 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19612 u32 param2_len
= param3_pos
- param2_pos
;
19616 char *param4_pos
= strchr (param3_pos
, '$');
19618 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19620 u32 param3_len
= param4_pos
- param3_pos
;
19624 char *param5_pos
= strchr (param4_pos
, '$');
19626 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19628 u32 param4_len
= param5_pos
- param4_pos
;
19632 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19634 char *salt_buf
= param1_pos
;
19635 char *iv
= param3_pos
;
19636 char *pswcheck
= param5_pos
;
19638 const uint salt_len
= atoi (param0_pos
);
19639 const uint iterations
= atoi (param2_pos
);
19640 const uint pswcheck_len
= atoi (param4_pos
);
19646 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19647 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19648 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19650 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19651 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19652 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19658 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19659 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19660 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19661 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19663 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19664 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19665 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19666 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19668 salt
->salt_len
= 16;
19670 salt
->salt_sign
[0] = iterations
;
19672 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19678 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19679 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19683 return (PARSER_OK
);
19686 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19688 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19690 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19692 u32
*digest
= (u32
*) hash_buf
->digest
;
19694 salt_t
*salt
= hash_buf
->salt
;
19696 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19703 char *account_pos
= input_buf
+ 11 + 1;
19709 if (account_pos
[0] == '*')
19713 data_pos
= strchr (account_pos
, '*');
19718 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19720 uint account_len
= data_pos
- account_pos
+ 1;
19722 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19727 data_len
= input_len
- 11 - 1 - account_len
- 2;
19729 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19733 /* assume $krb5tgs$23$checksum$edata2 */
19734 data_pos
= account_pos
;
19736 memcpy (krb5tgs
->account_info
, "**", 3);
19738 data_len
= input_len
- 11 - 1 - 1;
19741 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19743 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19745 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19747 const char p0
= data_pos
[i
+ 0];
19748 const char p1
= data_pos
[i
+ 1];
19750 *checksum_ptr
++ = hex_convert (p1
) << 0
19751 | hex_convert (p0
) << 4;
19754 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19756 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19759 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19761 const char p0
= data_pos
[i
+ 0];
19762 const char p1
= data_pos
[i
+ 1];
19763 *edata_ptr
++ = hex_convert (p1
) << 0
19764 | hex_convert (p0
) << 4;
19767 /* this is needed for hmac_md5 */
19768 *edata_ptr
++ = 0x80;
19770 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19771 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19772 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19773 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19775 salt
->salt_len
= 32;
19777 digest
[0] = krb5tgs
->checksum
[0];
19778 digest
[1] = krb5tgs
->checksum
[1];
19779 digest
[2] = krb5tgs
->checksum
[2];
19780 digest
[3] = krb5tgs
->checksum
[3];
19782 return (PARSER_OK
);
19785 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19787 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19789 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19791 u32
*digest
= (u32
*) hash_buf
->digest
;
19793 salt_t
*salt
= hash_buf
->salt
;
19800 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19804 char *wrapped_key_pos
;
19808 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19810 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19812 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19814 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19819 data_pos
= salt_pos
;
19821 wrapped_key_pos
= strchr (salt_pos
, '*');
19823 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19825 uint salt_len
= wrapped_key_pos
- salt_pos
;
19827 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19832 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19834 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19836 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19837 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19838 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19839 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19843 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19844 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19845 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19846 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19847 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19848 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19850 salt
->salt_len
= 40;
19852 digest
[0] = salt
->salt_buf
[0];
19853 digest
[1] = salt
->salt_buf
[1];
19854 digest
[2] = salt
->salt_buf
[2];
19855 digest
[3] = salt
->salt_buf
[3];
19857 return (PARSER_OK
);
19860 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19862 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19864 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19866 u32
*digest
= (u32
*) hash_buf
->digest
;
19868 salt_t
*salt
= hash_buf
->salt
;
19870 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19880 char *algorithm_pos
;
19882 char *final_random_seed_pos
;
19883 u32 final_random_seed_len
;
19885 char *transf_random_seed_pos
;
19886 u32 transf_random_seed_len
;
19891 /* default is no keyfile provided */
19892 char *keyfile_len_pos
;
19893 u32 keyfile_len
= 0;
19894 u32 is_keyfile_present
= 0;
19895 char *keyfile_inline_pos
;
19898 /* specific to version 1 */
19899 char *contents_len_pos
;
19901 char *contents_pos
;
19903 /* specific to version 2 */
19904 char *expected_bytes_pos
;
19905 u32 expected_bytes_len
;
19907 char *contents_hash_pos
;
19908 u32 contents_hash_len
;
19910 version_pos
= input_buf
+ 8 + 1 + 1;
19912 keepass
->version
= atoi (version_pos
);
19914 rounds_pos
= strchr (version_pos
, '*');
19916 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19920 salt
->salt_iter
= (atoi (rounds_pos
));
19922 algorithm_pos
= strchr (rounds_pos
, '*');
19924 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19928 keepass
->algorithm
= atoi (algorithm_pos
);
19930 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19932 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19934 final_random_seed_pos
++;
19936 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19937 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19938 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19939 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19941 if (keepass
->version
== 2)
19943 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19944 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19945 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19946 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19949 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19951 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19953 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19955 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19956 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19958 transf_random_seed_pos
++;
19960 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19961 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19962 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19963 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19964 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19965 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19966 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19967 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19969 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19971 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19973 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19975 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19979 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19980 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19981 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19982 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19984 if (keepass
->version
== 1)
19986 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19988 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19990 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19992 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19994 contents_hash_pos
++;
19996 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19997 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19998 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19999 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20000 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20001 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20002 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20003 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20005 /* get length of contents following */
20006 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
20008 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20010 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
20012 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20016 u32 inline_flag
= atoi (inline_flag_pos
);
20018 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
20020 contents_len_pos
= strchr (inline_flag_pos
, '*');
20022 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20024 contents_len_pos
++;
20026 contents_len
= atoi (contents_len_pos
);
20028 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
20030 contents_pos
= strchr (contents_len_pos
, '*');
20032 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20038 keepass
->contents_len
= contents_len
;
20040 contents_len
= contents_len
/ 4;
20042 keyfile_inline_pos
= strchr (contents_pos
, '*');
20044 u32 real_contents_len
;
20046 if (keyfile_inline_pos
== NULL
)
20047 real_contents_len
= input_len
- (contents_pos
- input_buf
);
20050 real_contents_len
= keyfile_inline_pos
- contents_pos
;
20051 keyfile_inline_pos
++;
20052 is_keyfile_present
= 1;
20055 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
20057 for (i
= 0; i
< contents_len
; i
++)
20058 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
20060 else if (keepass
->version
== 2)
20062 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
20064 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20066 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
20068 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
20070 expected_bytes_pos
++;
20072 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
20073 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
20074 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
20075 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
20076 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
20077 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
20078 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
20079 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
20081 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
20083 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20085 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
20087 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
20089 contents_hash_pos
++;
20091 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
20092 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
20093 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
20094 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20095 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20096 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20097 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20098 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20100 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
20102 if (keyfile_inline_pos
== NULL
)
20103 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
20106 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
20107 keyfile_inline_pos
++;
20108 is_keyfile_present
= 1;
20110 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20113 if (is_keyfile_present
!= 0)
20115 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20119 keyfile_len
= atoi (keyfile_len_pos
);
20121 keepass
->keyfile_len
= keyfile_len
;
20123 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20125 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20127 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20131 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20133 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20135 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20136 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20137 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20138 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20139 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20140 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20141 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20142 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20145 digest
[0] = keepass
->enc_iv
[0];
20146 digest
[1] = keepass
->enc_iv
[1];
20147 digest
[2] = keepass
->enc_iv
[2];
20148 digest
[3] = keepass
->enc_iv
[3];
20150 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20151 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20152 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20153 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20154 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20155 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20156 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20157 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20159 return (PARSER_OK
);
20162 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20164 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20166 u32
*digest
= (u32
*) hash_buf
->digest
;
20168 salt_t
*salt
= hash_buf
->salt
;
20170 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20171 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20172 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20173 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20174 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20175 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20176 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20177 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20179 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20181 uint salt_len
= input_len
- 64 - 1;
20183 char *salt_buf
= input_buf
+ 64 + 1;
20185 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20187 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20189 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20191 salt
->salt_len
= salt_len
;
20194 * we can precompute the first sha256 transform
20197 uint w
[16] = { 0 };
20199 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20200 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20201 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20202 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20203 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20204 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20205 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20206 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20207 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20208 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20209 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20210 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20211 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20212 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20213 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20214 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20216 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20218 sha256_64 (w
, pc256
);
20220 salt
->salt_buf_pc
[0] = pc256
[0];
20221 salt
->salt_buf_pc
[1] = pc256
[1];
20222 salt
->salt_buf_pc
[2] = pc256
[2];
20223 salt
->salt_buf_pc
[3] = pc256
[3];
20224 salt
->salt_buf_pc
[4] = pc256
[4];
20225 salt
->salt_buf_pc
[5] = pc256
[5];
20226 salt
->salt_buf_pc
[6] = pc256
[6];
20227 salt
->salt_buf_pc
[7] = pc256
[7];
20229 digest
[0] -= pc256
[0];
20230 digest
[1] -= pc256
[1];
20231 digest
[2] -= pc256
[2];
20232 digest
[3] -= pc256
[3];
20233 digest
[4] -= pc256
[4];
20234 digest
[5] -= pc256
[5];
20235 digest
[6] -= pc256
[6];
20236 digest
[7] -= pc256
[7];
20238 return (PARSER_OK
);
20241 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20243 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20245 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20247 u32
*digest
= (u32
*) hash_buf
->digest
;
20249 salt_t
*salt
= hash_buf
->salt
;
20255 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20257 char *data_buf_pos
= strchr (data_len_pos
, '$');
20259 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20261 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20263 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20264 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20268 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20270 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20272 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20274 u32 data_len
= atoi (data_len_pos
);
20276 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20282 char *salt_pos
= data_buf_pos
;
20284 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20285 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20286 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20287 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20289 // this is actually the CT, which is also the hash later (if matched)
20291 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20292 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20293 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20294 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20296 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20298 salt
->salt_iter
= 10 - 1;
20304 digest
[0] = salt
->salt_buf
[4];
20305 digest
[1] = salt
->salt_buf
[5];
20306 digest
[2] = salt
->salt_buf
[6];
20307 digest
[3] = salt
->salt_buf
[7];
20309 return (PARSER_OK
);
20312 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20314 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20316 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20318 u32
*digest
= (u32
*) hash_buf
->digest
;
20320 salt_t
*salt
= hash_buf
->salt
;
20326 char *salt_pos
= input_buf
+ 11 + 1;
20328 char *iter_pos
= strchr (salt_pos
, ',');
20330 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20332 u32 salt_len
= iter_pos
- salt_pos
;
20334 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20338 char *hash_pos
= strchr (iter_pos
, ',');
20340 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20342 u32 iter_len
= hash_pos
- iter_pos
;
20344 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20348 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20350 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20356 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20357 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20358 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20359 salt
->salt_buf
[3] = 0x00018000;
20361 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20362 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20363 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20364 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20366 salt
->salt_len
= salt_len
/ 2;
20368 salt
->salt_iter
= atoi (iter_pos
) - 1;
20374 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20375 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20376 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20377 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20378 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20379 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20380 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20381 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20383 return (PARSER_OK
);
20386 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20388 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20390 u32
*digest
= (u32
*) hash_buf
->digest
;
20392 salt_t
*salt
= hash_buf
->salt
;
20398 char *hash_pos
= input_buf
+ 64;
20399 char *salt1_pos
= input_buf
+ 128;
20400 char *salt2_pos
= input_buf
;
20406 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20407 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20408 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20409 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20411 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20412 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20413 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20414 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20416 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20417 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20418 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20419 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20421 salt
->salt_len
= 48;
20423 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20429 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20430 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20431 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20432 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20433 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20434 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20435 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20436 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20438 return (PARSER_OK
);
20441 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20443 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20445 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20446 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20448 u32
*digest
= (u32
*) hash_buf
->digest
;
20450 salt_t
*salt
= hash_buf
->salt
;
20452 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20458 char *param0_pos
= input_buf
+ 6 + 1;
20460 char *param1_pos
= strchr (param0_pos
, '*');
20462 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20464 u32 param0_len
= param1_pos
- param0_pos
;
20468 char *param2_pos
= strchr (param1_pos
, '*');
20470 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20472 u32 param1_len
= param2_pos
- param1_pos
;
20476 char *param3_pos
= strchr (param2_pos
, '*');
20478 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20480 u32 param2_len
= param3_pos
- param2_pos
;
20484 char *param4_pos
= strchr (param3_pos
, '*');
20486 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20488 u32 param3_len
= param4_pos
- param3_pos
;
20492 char *param5_pos
= strchr (param4_pos
, '*');
20494 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20496 u32 param4_len
= param5_pos
- param4_pos
;
20500 char *param6_pos
= strchr (param5_pos
, '*');
20502 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20504 u32 param5_len
= param6_pos
- param5_pos
;
20508 char *param7_pos
= strchr (param6_pos
, '*');
20510 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20512 u32 param6_len
= param7_pos
- param6_pos
;
20516 char *param8_pos
= strchr (param7_pos
, '*');
20518 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20520 u32 param7_len
= param8_pos
- param7_pos
;
20524 const uint type
= atoi (param0_pos
);
20525 const uint mode
= atoi (param1_pos
);
20526 const uint magic
= atoi (param2_pos
);
20528 char *salt_buf
= param3_pos
;
20530 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20532 const uint compress_length
= atoi (param5_pos
);
20534 char *data_buf
= param6_pos
;
20535 char *auth
= param7_pos
;
20541 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20543 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20545 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20547 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20549 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20551 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20553 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20555 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20557 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20559 if (type
!= 0) return (PARSER_SALT_VALUE
);
20561 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20563 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20565 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20573 zip2
->magic
= magic
;
20577 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20578 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20579 zip2
->salt_buf
[2] = 0;
20580 zip2
->salt_buf
[3] = 0;
20582 zip2
->salt_len
= 8;
20584 else if (mode
== 2)
20586 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20587 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20588 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20589 zip2
->salt_buf
[3] = 0;
20591 zip2
->salt_len
= 12;
20593 else if (mode
== 3)
20595 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20596 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20597 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20598 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20600 zip2
->salt_len
= 16;
20603 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20604 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20605 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20606 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20608 zip2
->verify_bytes
= verify_bytes
;
20610 zip2
->compress_length
= compress_length
;
20612 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20614 for (uint i
= 0; i
< param6_len
; i
+= 2)
20616 const char p0
= data_buf
[i
+ 0];
20617 const char p1
= data_buf
[i
+ 1];
20619 *data_buf_ptr
++ = hex_convert (p1
) << 0
20620 | hex_convert (p0
) << 4;
20625 *data_buf_ptr
= 0x80;
20627 char *auth_ptr
= (char *) zip2
->auth_buf
;
20629 for (uint i
= 0; i
< param7_len
; i
+= 2)
20631 const char p0
= auth
[i
+ 0];
20632 const char p1
= auth
[i
+ 1];
20634 *auth_ptr
++ = hex_convert (p1
) << 0
20635 | hex_convert (p0
) << 4;
20644 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20645 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20646 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20647 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20648 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20649 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20650 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20651 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20653 salt
->salt_len
= 32;
20655 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20658 * digest buf (fake)
20661 digest
[0] = zip2
->auth_buf
[0];
20662 digest
[1] = zip2
->auth_buf
[1];
20663 digest
[2] = zip2
->auth_buf
[2];
20664 digest
[3] = zip2
->auth_buf
[3];
20666 return (PARSER_OK
);
20669 int win8phone_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20671 if ((input_len
< DISPLAY_LEN_MIN_13800
) || (input_len
> DISPLAY_LEN_MAX_13800
)) return (PARSER_GLOBAL_LENGTH
);
20673 u32
*digest
= (u32
*) hash_buf
->digest
;
20675 salt_t
*salt
= hash_buf
->salt
;
20677 win8phone_t
*esalt
= hash_buf
->esalt
;
20679 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20680 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20681 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20682 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20683 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20684 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20685 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20686 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20688 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20690 char *salt_buf_ptr
= input_buf
+ 64 + 1;
20692 u32
*salt_buf
= esalt
->salt_buf
;
20694 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
20696 salt_buf
[i
] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[j
]);
20699 salt
->salt_buf
[0] = salt_buf
[0];
20700 salt
->salt_buf
[1] = salt_buf
[1];
20701 salt
->salt_buf
[2] = salt_buf
[2];
20702 salt
->salt_buf
[3] = salt_buf
[3];
20703 salt
->salt_buf
[4] = salt_buf
[4];
20704 salt
->salt_buf
[5] = salt_buf
[5];
20705 salt
->salt_buf
[6] = salt_buf
[6];
20706 salt
->salt_buf
[7] = salt_buf
[7];
20708 salt
->salt_len
= 64;
20710 return (PARSER_OK
);
20714 * parallel running threads
20719 BOOL WINAPI
sigHandler_default (DWORD sig
)
20723 case CTRL_CLOSE_EVENT
:
20726 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20727 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20728 * function otherwise it is too late (e.g. after returning from this function)
20733 SetConsoleCtrlHandler (NULL
, TRUE
);
20740 case CTRL_LOGOFF_EVENT
:
20741 case CTRL_SHUTDOWN_EVENT
:
20745 SetConsoleCtrlHandler (NULL
, TRUE
);
20753 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20757 case CTRL_CLOSE_EVENT
:
20761 SetConsoleCtrlHandler (NULL
, TRUE
);
20768 case CTRL_LOGOFF_EVENT
:
20769 case CTRL_SHUTDOWN_EVENT
:
20773 SetConsoleCtrlHandler (NULL
, TRUE
);
20781 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20783 if (callback
== NULL
)
20785 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20789 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20795 void sigHandler_default (int sig
)
20799 signal (sig
, NULL
);
20802 void sigHandler_benchmark (int sig
)
20806 signal (sig
, NULL
);
20809 void hc_signal (void (callback
) (int))
20811 if (callback
== NULL
) callback
= SIG_DFL
;
20813 signal (SIGINT
, callback
);
20814 signal (SIGTERM
, callback
);
20815 signal (SIGABRT
, callback
);
20820 void status_display ();
20822 void *thread_keypress (void *p
)
20824 uint quiet
= data
.quiet
;
20828 while (data
.shutdown_outer
== 0)
20830 int ch
= tty_getchar();
20832 if (ch
== -1) break;
20834 if (ch
== 0) continue;
20836 //https://github.com/hashcat/hashcat/issues/302
20841 hc_thread_mutex_lock (mux_display
);
20857 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20858 if (quiet
== 0) fflush (stdout
);
20870 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20871 if (quiet
== 0) fflush (stdout
);
20883 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20884 if (quiet
== 0) fflush (stdout
);
20896 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20897 if (quiet
== 0) fflush (stdout
);
20905 stop_at_checkpoint ();
20909 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20910 if (quiet
== 0) fflush (stdout
);
20923 //https://github.com/hashcat/hashcat/issues/302
20928 hc_thread_mutex_unlock (mux_display
);
20940 bool class_num (const u8 c
)
20942 return ((c
>= '0') && (c
<= '9'));
20945 bool class_lower (const u8 c
)
20947 return ((c
>= 'a') && (c
<= 'z'));
20950 bool class_upper (const u8 c
)
20952 return ((c
>= 'A') && (c
<= 'Z'));
20955 bool class_alpha (const u8 c
)
20957 return (class_lower (c
) || class_upper (c
));
20960 int conv_ctoi (const u8 c
)
20966 else if (class_upper (c
))
20968 return c
- 'A' + 10;
20974 int conv_itoc (const u8 c
)
20982 return c
+ 'A' - 10;
20992 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20993 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20994 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20995 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20996 #define MAX_KERNEL_RULES 255
20997 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20998 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20999 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
21001 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
21002 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
21003 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
21004 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
21006 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
21011 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21013 switch (rule_buf
[rule_pos
])
21019 case RULE_OP_MANGLE_NOOP
:
21020 SET_NAME (rule
, rule_buf
[rule_pos
]);
21023 case RULE_OP_MANGLE_LREST
:
21024 SET_NAME (rule
, rule_buf
[rule_pos
]);
21027 case RULE_OP_MANGLE_UREST
:
21028 SET_NAME (rule
, rule_buf
[rule_pos
]);
21031 case RULE_OP_MANGLE_LREST_UFIRST
:
21032 SET_NAME (rule
, rule_buf
[rule_pos
]);
21035 case RULE_OP_MANGLE_UREST_LFIRST
:
21036 SET_NAME (rule
, rule_buf
[rule_pos
]);
21039 case RULE_OP_MANGLE_TREST
:
21040 SET_NAME (rule
, rule_buf
[rule_pos
]);
21043 case RULE_OP_MANGLE_TOGGLE_AT
:
21044 SET_NAME (rule
, rule_buf
[rule_pos
]);
21045 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21048 case RULE_OP_MANGLE_REVERSE
:
21049 SET_NAME (rule
, rule_buf
[rule_pos
]);
21052 case RULE_OP_MANGLE_DUPEWORD
:
21053 SET_NAME (rule
, rule_buf
[rule_pos
]);
21056 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21057 SET_NAME (rule
, rule_buf
[rule_pos
]);
21058 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21061 case RULE_OP_MANGLE_REFLECT
:
21062 SET_NAME (rule
, rule_buf
[rule_pos
]);
21065 case RULE_OP_MANGLE_ROTATE_LEFT
:
21066 SET_NAME (rule
, rule_buf
[rule_pos
]);
21069 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21070 SET_NAME (rule
, rule_buf
[rule_pos
]);
21073 case RULE_OP_MANGLE_APPEND
:
21074 SET_NAME (rule
, rule_buf
[rule_pos
]);
21075 SET_P0 (rule
, rule_buf
[rule_pos
]);
21078 case RULE_OP_MANGLE_PREPEND
:
21079 SET_NAME (rule
, rule_buf
[rule_pos
]);
21080 SET_P0 (rule
, rule_buf
[rule_pos
]);
21083 case RULE_OP_MANGLE_DELETE_FIRST
:
21084 SET_NAME (rule
, rule_buf
[rule_pos
]);
21087 case RULE_OP_MANGLE_DELETE_LAST
:
21088 SET_NAME (rule
, rule_buf
[rule_pos
]);
21091 case RULE_OP_MANGLE_DELETE_AT
:
21092 SET_NAME (rule
, rule_buf
[rule_pos
]);
21093 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21096 case RULE_OP_MANGLE_EXTRACT
:
21097 SET_NAME (rule
, rule_buf
[rule_pos
]);
21098 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21099 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21102 case RULE_OP_MANGLE_OMIT
:
21103 SET_NAME (rule
, rule_buf
[rule_pos
]);
21104 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21105 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21108 case RULE_OP_MANGLE_INSERT
:
21109 SET_NAME (rule
, rule_buf
[rule_pos
]);
21110 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21111 SET_P1 (rule
, rule_buf
[rule_pos
]);
21114 case RULE_OP_MANGLE_OVERSTRIKE
:
21115 SET_NAME (rule
, rule_buf
[rule_pos
]);
21116 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21117 SET_P1 (rule
, rule_buf
[rule_pos
]);
21120 case RULE_OP_MANGLE_TRUNCATE_AT
:
21121 SET_NAME (rule
, rule_buf
[rule_pos
]);
21122 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21125 case RULE_OP_MANGLE_REPLACE
:
21126 SET_NAME (rule
, rule_buf
[rule_pos
]);
21127 SET_P0 (rule
, rule_buf
[rule_pos
]);
21128 SET_P1 (rule
, rule_buf
[rule_pos
]);
21131 case RULE_OP_MANGLE_PURGECHAR
:
21135 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21139 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21140 SET_NAME (rule
, rule_buf
[rule_pos
]);
21141 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21144 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21145 SET_NAME (rule
, rule_buf
[rule_pos
]);
21146 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21149 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21150 SET_NAME (rule
, rule_buf
[rule_pos
]);
21153 case RULE_OP_MANGLE_SWITCH_FIRST
:
21154 SET_NAME (rule
, rule_buf
[rule_pos
]);
21157 case RULE_OP_MANGLE_SWITCH_LAST
:
21158 SET_NAME (rule
, rule_buf
[rule_pos
]);
21161 case RULE_OP_MANGLE_SWITCH_AT
:
21162 SET_NAME (rule
, rule_buf
[rule_pos
]);
21163 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21164 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21167 case RULE_OP_MANGLE_CHR_SHIFTL
:
21168 SET_NAME (rule
, rule_buf
[rule_pos
]);
21169 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21172 case RULE_OP_MANGLE_CHR_SHIFTR
:
21173 SET_NAME (rule
, rule_buf
[rule_pos
]);
21174 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21177 case RULE_OP_MANGLE_CHR_INCR
:
21178 SET_NAME (rule
, rule_buf
[rule_pos
]);
21179 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21182 case RULE_OP_MANGLE_CHR_DECR
:
21183 SET_NAME (rule
, rule_buf
[rule_pos
]);
21184 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21187 case RULE_OP_MANGLE_REPLACE_NP1
:
21188 SET_NAME (rule
, rule_buf
[rule_pos
]);
21189 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21192 case RULE_OP_MANGLE_REPLACE_NM1
:
21193 SET_NAME (rule
, rule_buf
[rule_pos
]);
21194 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21197 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21198 SET_NAME (rule
, rule_buf
[rule_pos
]);
21199 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21202 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21203 SET_NAME (rule
, rule_buf
[rule_pos
]);
21204 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21207 case RULE_OP_MANGLE_TITLE
:
21208 SET_NAME (rule
, rule_buf
[rule_pos
]);
21217 if (rule_pos
< rule_len
) return (-1);
21222 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21226 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21230 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21234 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21238 case RULE_OP_MANGLE_NOOP
:
21239 rule_buf
[rule_pos
] = rule_cmd
;
21242 case RULE_OP_MANGLE_LREST
:
21243 rule_buf
[rule_pos
] = rule_cmd
;
21246 case RULE_OP_MANGLE_UREST
:
21247 rule_buf
[rule_pos
] = rule_cmd
;
21250 case RULE_OP_MANGLE_LREST_UFIRST
:
21251 rule_buf
[rule_pos
] = rule_cmd
;
21254 case RULE_OP_MANGLE_UREST_LFIRST
:
21255 rule_buf
[rule_pos
] = rule_cmd
;
21258 case RULE_OP_MANGLE_TREST
:
21259 rule_buf
[rule_pos
] = rule_cmd
;
21262 case RULE_OP_MANGLE_TOGGLE_AT
:
21263 rule_buf
[rule_pos
] = rule_cmd
;
21264 GET_P0_CONV (rule
);
21267 case RULE_OP_MANGLE_REVERSE
:
21268 rule_buf
[rule_pos
] = rule_cmd
;
21271 case RULE_OP_MANGLE_DUPEWORD
:
21272 rule_buf
[rule_pos
] = rule_cmd
;
21275 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21276 rule_buf
[rule_pos
] = rule_cmd
;
21277 GET_P0_CONV (rule
);
21280 case RULE_OP_MANGLE_REFLECT
:
21281 rule_buf
[rule_pos
] = rule_cmd
;
21284 case RULE_OP_MANGLE_ROTATE_LEFT
:
21285 rule_buf
[rule_pos
] = rule_cmd
;
21288 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21289 rule_buf
[rule_pos
] = rule_cmd
;
21292 case RULE_OP_MANGLE_APPEND
:
21293 rule_buf
[rule_pos
] = rule_cmd
;
21297 case RULE_OP_MANGLE_PREPEND
:
21298 rule_buf
[rule_pos
] = rule_cmd
;
21302 case RULE_OP_MANGLE_DELETE_FIRST
:
21303 rule_buf
[rule_pos
] = rule_cmd
;
21306 case RULE_OP_MANGLE_DELETE_LAST
:
21307 rule_buf
[rule_pos
] = rule_cmd
;
21310 case RULE_OP_MANGLE_DELETE_AT
:
21311 rule_buf
[rule_pos
] = rule_cmd
;
21312 GET_P0_CONV (rule
);
21315 case RULE_OP_MANGLE_EXTRACT
:
21316 rule_buf
[rule_pos
] = rule_cmd
;
21317 GET_P0_CONV (rule
);
21318 GET_P1_CONV (rule
);
21321 case RULE_OP_MANGLE_OMIT
:
21322 rule_buf
[rule_pos
] = rule_cmd
;
21323 GET_P0_CONV (rule
);
21324 GET_P1_CONV (rule
);
21327 case RULE_OP_MANGLE_INSERT
:
21328 rule_buf
[rule_pos
] = rule_cmd
;
21329 GET_P0_CONV (rule
);
21333 case RULE_OP_MANGLE_OVERSTRIKE
:
21334 rule_buf
[rule_pos
] = rule_cmd
;
21335 GET_P0_CONV (rule
);
21339 case RULE_OP_MANGLE_TRUNCATE_AT
:
21340 rule_buf
[rule_pos
] = rule_cmd
;
21341 GET_P0_CONV (rule
);
21344 case RULE_OP_MANGLE_REPLACE
:
21345 rule_buf
[rule_pos
] = rule_cmd
;
21350 case RULE_OP_MANGLE_PURGECHAR
:
21354 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21358 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21359 rule_buf
[rule_pos
] = rule_cmd
;
21360 GET_P0_CONV (rule
);
21363 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21364 rule_buf
[rule_pos
] = rule_cmd
;
21365 GET_P0_CONV (rule
);
21368 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21369 rule_buf
[rule_pos
] = rule_cmd
;
21372 case RULE_OP_MANGLE_SWITCH_FIRST
:
21373 rule_buf
[rule_pos
] = rule_cmd
;
21376 case RULE_OP_MANGLE_SWITCH_LAST
:
21377 rule_buf
[rule_pos
] = rule_cmd
;
21380 case RULE_OP_MANGLE_SWITCH_AT
:
21381 rule_buf
[rule_pos
] = rule_cmd
;
21382 GET_P0_CONV (rule
);
21383 GET_P1_CONV (rule
);
21386 case RULE_OP_MANGLE_CHR_SHIFTL
:
21387 rule_buf
[rule_pos
] = rule_cmd
;
21388 GET_P0_CONV (rule
);
21391 case RULE_OP_MANGLE_CHR_SHIFTR
:
21392 rule_buf
[rule_pos
] = rule_cmd
;
21393 GET_P0_CONV (rule
);
21396 case RULE_OP_MANGLE_CHR_INCR
:
21397 rule_buf
[rule_pos
] = rule_cmd
;
21398 GET_P0_CONV (rule
);
21401 case RULE_OP_MANGLE_CHR_DECR
:
21402 rule_buf
[rule_pos
] = rule_cmd
;
21403 GET_P0_CONV (rule
);
21406 case RULE_OP_MANGLE_REPLACE_NP1
:
21407 rule_buf
[rule_pos
] = rule_cmd
;
21408 GET_P0_CONV (rule
);
21411 case RULE_OP_MANGLE_REPLACE_NM1
:
21412 rule_buf
[rule_pos
] = rule_cmd
;
21413 GET_P0_CONV (rule
);
21416 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21417 rule_buf
[rule_pos
] = rule_cmd
;
21418 GET_P0_CONV (rule
);
21421 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21422 rule_buf
[rule_pos
] = rule_cmd
;
21423 GET_P0_CONV (rule
);
21426 case RULE_OP_MANGLE_TITLE
:
21427 rule_buf
[rule_pos
] = rule_cmd
;
21431 return rule_pos
- 1;
21449 * CPU rules : this is from hashcat sources, cpu based rules
21452 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21453 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21455 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21456 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21457 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21459 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21460 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21461 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21463 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21467 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21472 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21476 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21481 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21485 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21490 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21495 for (l
= 0; l
< arr_len
; l
++)
21497 r
= arr_len
- 1 - l
;
21501 MANGLE_SWITCH (arr
, l
, r
);
21507 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21509 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21511 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21513 return (arr_len
* 2);
21516 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21518 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21520 int orig_len
= arr_len
;
21524 for (i
= 0; i
< times
; i
++)
21526 memcpy (&arr
[arr_len
], arr
, orig_len
);
21528 arr_len
+= orig_len
;
21534 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21536 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21538 mangle_double (arr
, arr_len
);
21540 mangle_reverse (arr
+ arr_len
, arr_len
);
21542 return (arr_len
* 2);
21545 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21550 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21552 MANGLE_SWITCH (arr
, l
, r
);
21558 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21563 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21565 MANGLE_SWITCH (arr
, l
, r
);
21571 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21573 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21577 return (arr_len
+ 1);
21580 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21582 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21586 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21588 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21593 return (arr_len
+ 1);
21596 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21598 if (upos
>= arr_len
) return (arr_len
);
21602 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21604 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21607 return (arr_len
- 1);
21610 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21612 if (upos
>= arr_len
) return (arr_len
);
21614 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21618 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21620 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21626 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21628 if (upos
>= arr_len
) return (arr_len
);
21630 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21634 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21636 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21639 return (arr_len
- ulen
);
21642 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21644 if (upos
>= arr_len
) return (arr_len
);
21646 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21650 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21652 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21657 return (arr_len
+ 1);
21660 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
)
21662 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21664 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21666 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21668 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21670 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21672 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21674 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21676 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21678 return (arr_len
+ arr2_cpy
);
21681 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21683 if (upos
>= arr_len
) return (arr_len
);
21690 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21692 if (upos
>= arr_len
) return (arr_len
);
21694 memset (arr
+ upos
, 0, arr_len
- upos
);
21699 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21703 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21705 if (arr
[arr_pos
] != oldc
) continue;
21707 arr
[arr_pos
] = newc
;
21713 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21719 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21721 if (arr
[arr_pos
] == c
) continue;
21723 arr
[ret_len
] = arr
[arr_pos
];
21731 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21733 if (ulen
> arr_len
) return (arr_len
);
21735 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21737 char cs
[100] = { 0 };
21739 memcpy (cs
, arr
, ulen
);
21743 for (i
= 0; i
< ulen
; i
++)
21747 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21753 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21755 if (ulen
> arr_len
) return (arr_len
);
21757 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21759 int upos
= arr_len
- ulen
;
21763 for (i
= 0; i
< ulen
; i
++)
21765 char c
= arr
[upos
+ i
];
21767 arr_len
= mangle_append (arr
, arr_len
, c
);
21773 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21775 if ( arr_len
== 0) return (arr_len
);
21776 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21778 char c
= arr
[upos
];
21782 for (i
= 0; i
< ulen
; i
++)
21784 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21790 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21792 if ( arr_len
== 0) return (arr_len
);
21793 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21797 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21799 int new_pos
= arr_pos
* 2;
21801 arr
[new_pos
] = arr
[arr_pos
];
21803 arr
[new_pos
+ 1] = arr
[arr_pos
];
21806 return (arr_len
* 2);
21809 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21811 if (upos
>= arr_len
) return (arr_len
);
21812 if (upos2
>= arr_len
) return (arr_len
);
21814 MANGLE_SWITCH (arr
, upos
, upos2
);
21819 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21821 MANGLE_SWITCH (arr
, upos
, upos2
);
21826 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21828 if (upos
>= arr_len
) return (arr_len
);
21835 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21837 if (upos
>= arr_len
) return (arr_len
);
21844 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21846 if (upos
>= arr_len
) return (arr_len
);
21853 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21855 if (upos
>= arr_len
) return (arr_len
);
21862 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21864 int upper_next
= 1;
21868 for (pos
= 0; pos
< arr_len
; pos
++)
21870 if (arr
[pos
] == ' ')
21881 MANGLE_UPPER_AT (arr
, pos
);
21885 MANGLE_LOWER_AT (arr
, pos
);
21892 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21894 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21900 for (j
= 0; j
< rp_gen_num
; j
++)
21907 switch ((char) get_random_num (0, 9))
21910 r
= get_random_num (0, sizeof (grp_op_nop
));
21911 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21915 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21916 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21917 p1
= get_random_num (0, sizeof (grp_pos
));
21918 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21922 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21923 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21924 p1
= get_random_num (1, 6);
21925 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21929 r
= get_random_num (0, sizeof (grp_op_chr
));
21930 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21931 p1
= get_random_num (0x20, 0x7e);
21932 rule_buf
[rule_pos
++] = (char) p1
;
21936 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21937 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21938 p1
= get_random_num (0x20, 0x7e);
21939 rule_buf
[rule_pos
++] = (char) p1
;
21940 p2
= get_random_num (0x20, 0x7e);
21942 p2
= get_random_num (0x20, 0x7e);
21943 rule_buf
[rule_pos
++] = (char) p2
;
21947 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21948 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21949 p1
= get_random_num (0, sizeof (grp_pos
));
21950 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21951 p2
= get_random_num (0x20, 0x7e);
21952 rule_buf
[rule_pos
++] = (char) p2
;
21956 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21957 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21958 p1
= get_random_num (0, sizeof (grp_pos
));
21959 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21960 p2
= get_random_num (0, sizeof (grp_pos
));
21962 p2
= get_random_num (0, sizeof (grp_pos
));
21963 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21967 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21968 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21969 p1
= get_random_num (0, sizeof (grp_pos
));
21970 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21971 p2
= get_random_num (1, sizeof (grp_pos
));
21973 p2
= get_random_num (1, sizeof (grp_pos
));
21974 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21978 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21979 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21980 p1
= get_random_num (0, sizeof (grp_pos
));
21981 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21982 p2
= get_random_num (1, sizeof (grp_pos
));
21983 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21984 p3
= get_random_num (0, sizeof (grp_pos
));
21985 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21993 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21995 char mem
[BLOCK_SIZE
] = { 0 };
21997 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21999 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
22001 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22003 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
22005 int out_len
= in_len
;
22006 int mem_len
= in_len
;
22008 memcpy (out
, in
, out_len
);
22012 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
22017 switch (rule
[rule_pos
])
22022 case RULE_OP_MANGLE_NOOP
:
22025 case RULE_OP_MANGLE_LREST
:
22026 out_len
= mangle_lrest (out
, out_len
);
22029 case RULE_OP_MANGLE_UREST
:
22030 out_len
= mangle_urest (out
, out_len
);
22033 case RULE_OP_MANGLE_LREST_UFIRST
:
22034 out_len
= mangle_lrest (out
, out_len
);
22035 if (out_len
) MANGLE_UPPER_AT (out
, 0);
22038 case RULE_OP_MANGLE_UREST_LFIRST
:
22039 out_len
= mangle_urest (out
, out_len
);
22040 if (out_len
) MANGLE_LOWER_AT (out
, 0);
22043 case RULE_OP_MANGLE_TREST
:
22044 out_len
= mangle_trest (out
, out_len
);
22047 case RULE_OP_MANGLE_TOGGLE_AT
:
22048 NEXT_RULEPOS (rule_pos
);
22049 NEXT_RPTOI (rule
, rule_pos
, upos
);
22050 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
22053 case RULE_OP_MANGLE_REVERSE
:
22054 out_len
= mangle_reverse (out
, out_len
);
22057 case RULE_OP_MANGLE_DUPEWORD
:
22058 out_len
= mangle_double (out
, out_len
);
22061 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
22062 NEXT_RULEPOS (rule_pos
);
22063 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22064 out_len
= mangle_double_times (out
, out_len
, ulen
);
22067 case RULE_OP_MANGLE_REFLECT
:
22068 out_len
= mangle_reflect (out
, out_len
);
22071 case RULE_OP_MANGLE_ROTATE_LEFT
:
22072 mangle_rotate_left (out
, out_len
);
22075 case RULE_OP_MANGLE_ROTATE_RIGHT
:
22076 mangle_rotate_right (out
, out_len
);
22079 case RULE_OP_MANGLE_APPEND
:
22080 NEXT_RULEPOS (rule_pos
);
22081 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
22084 case RULE_OP_MANGLE_PREPEND
:
22085 NEXT_RULEPOS (rule_pos
);
22086 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
22089 case RULE_OP_MANGLE_DELETE_FIRST
:
22090 out_len
= mangle_delete_at (out
, out_len
, 0);
22093 case RULE_OP_MANGLE_DELETE_LAST
:
22094 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
22097 case RULE_OP_MANGLE_DELETE_AT
:
22098 NEXT_RULEPOS (rule_pos
);
22099 NEXT_RPTOI (rule
, rule_pos
, upos
);
22100 out_len
= mangle_delete_at (out
, out_len
, upos
);
22103 case RULE_OP_MANGLE_EXTRACT
:
22104 NEXT_RULEPOS (rule_pos
);
22105 NEXT_RPTOI (rule
, rule_pos
, upos
);
22106 NEXT_RULEPOS (rule_pos
);
22107 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22108 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
22111 case RULE_OP_MANGLE_OMIT
:
22112 NEXT_RULEPOS (rule_pos
);
22113 NEXT_RPTOI (rule
, rule_pos
, upos
);
22114 NEXT_RULEPOS (rule_pos
);
22115 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22116 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
22119 case RULE_OP_MANGLE_INSERT
:
22120 NEXT_RULEPOS (rule_pos
);
22121 NEXT_RPTOI (rule
, rule_pos
, upos
);
22122 NEXT_RULEPOS (rule_pos
);
22123 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22126 case RULE_OP_MANGLE_OVERSTRIKE
:
22127 NEXT_RULEPOS (rule_pos
);
22128 NEXT_RPTOI (rule
, rule_pos
, upos
);
22129 NEXT_RULEPOS (rule_pos
);
22130 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22133 case RULE_OP_MANGLE_TRUNCATE_AT
:
22134 NEXT_RULEPOS (rule_pos
);
22135 NEXT_RPTOI (rule
, rule_pos
, upos
);
22136 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22139 case RULE_OP_MANGLE_REPLACE
:
22140 NEXT_RULEPOS (rule_pos
);
22141 NEXT_RULEPOS (rule_pos
);
22142 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22145 case RULE_OP_MANGLE_PURGECHAR
:
22146 NEXT_RULEPOS (rule_pos
);
22147 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22150 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22154 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22155 NEXT_RULEPOS (rule_pos
);
22156 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22157 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22160 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22161 NEXT_RULEPOS (rule_pos
);
22162 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22163 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22166 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22167 out_len
= mangle_dupechar (out
, out_len
);
22170 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22171 NEXT_RULEPOS (rule_pos
);
22172 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22173 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22176 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22177 NEXT_RULEPOS (rule_pos
);
22178 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22179 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22182 case RULE_OP_MANGLE_SWITCH_FIRST
:
22183 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22186 case RULE_OP_MANGLE_SWITCH_LAST
:
22187 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22190 case RULE_OP_MANGLE_SWITCH_AT
:
22191 NEXT_RULEPOS (rule_pos
);
22192 NEXT_RPTOI (rule
, rule_pos
, upos
);
22193 NEXT_RULEPOS (rule_pos
);
22194 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22195 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22198 case RULE_OP_MANGLE_CHR_SHIFTL
:
22199 NEXT_RULEPOS (rule_pos
);
22200 NEXT_RPTOI (rule
, rule_pos
, upos
);
22201 mangle_chr_shiftl (out
, out_len
, upos
);
22204 case RULE_OP_MANGLE_CHR_SHIFTR
:
22205 NEXT_RULEPOS (rule_pos
);
22206 NEXT_RPTOI (rule
, rule_pos
, upos
);
22207 mangle_chr_shiftr (out
, out_len
, upos
);
22210 case RULE_OP_MANGLE_CHR_INCR
:
22211 NEXT_RULEPOS (rule_pos
);
22212 NEXT_RPTOI (rule
, rule_pos
, upos
);
22213 mangle_chr_incr (out
, out_len
, upos
);
22216 case RULE_OP_MANGLE_CHR_DECR
:
22217 NEXT_RULEPOS (rule_pos
);
22218 NEXT_RPTOI (rule
, rule_pos
, upos
);
22219 mangle_chr_decr (out
, out_len
, upos
);
22222 case RULE_OP_MANGLE_REPLACE_NP1
:
22223 NEXT_RULEPOS (rule_pos
);
22224 NEXT_RPTOI (rule
, rule_pos
, upos
);
22225 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22228 case RULE_OP_MANGLE_REPLACE_NM1
:
22229 NEXT_RULEPOS (rule_pos
);
22230 NEXT_RPTOI (rule
, rule_pos
, upos
);
22231 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22234 case RULE_OP_MANGLE_TITLE
:
22235 out_len
= mangle_title (out
, out_len
);
22238 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22239 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22240 NEXT_RULEPOS (rule_pos
);
22241 NEXT_RPTOI (rule
, rule_pos
, upos
);
22242 NEXT_RULEPOS (rule_pos
);
22243 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22244 NEXT_RULEPOS (rule_pos
);
22245 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22246 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22249 case RULE_OP_MANGLE_APPEND_MEMORY
:
22250 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22251 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22252 memcpy (out
+ out_len
, mem
, mem_len
);
22253 out_len
+= mem_len
;
22256 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22257 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22258 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22259 memcpy (mem
+ mem_len
, out
, out_len
);
22260 out_len
+= mem_len
;
22261 memcpy (out
, mem
, out_len
);
22264 case RULE_OP_MEMORIZE_WORD
:
22265 memcpy (mem
, out
, out_len
);
22269 case RULE_OP_REJECT_LESS
:
22270 NEXT_RULEPOS (rule_pos
);
22271 NEXT_RPTOI (rule
, rule_pos
, upos
);
22272 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22275 case RULE_OP_REJECT_GREATER
:
22276 NEXT_RULEPOS (rule_pos
);
22277 NEXT_RPTOI (rule
, rule_pos
, upos
);
22278 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22281 case RULE_OP_REJECT_CONTAIN
:
22282 NEXT_RULEPOS (rule_pos
);
22283 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22286 case RULE_OP_REJECT_NOT_CONTAIN
:
22287 NEXT_RULEPOS (rule_pos
);
22288 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22291 case RULE_OP_REJECT_EQUAL_FIRST
:
22292 NEXT_RULEPOS (rule_pos
);
22293 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22296 case RULE_OP_REJECT_EQUAL_LAST
:
22297 NEXT_RULEPOS (rule_pos
);
22298 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22301 case RULE_OP_REJECT_EQUAL_AT
:
22302 NEXT_RULEPOS (rule_pos
);
22303 NEXT_RPTOI (rule
, rule_pos
, upos
);
22304 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22305 NEXT_RULEPOS (rule_pos
);
22306 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22309 case RULE_OP_REJECT_CONTAINS
:
22310 NEXT_RULEPOS (rule_pos
);
22311 NEXT_RPTOI (rule
, rule_pos
, upos
);
22312 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22313 NEXT_RULEPOS (rule_pos
);
22314 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22315 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22318 case RULE_OP_REJECT_MEMORY
:
22319 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22323 return (RULE_RC_SYNTAX_ERROR
);
22328 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);