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
;
3494 memset (&CoolerLevels
, 0, sizeof (NV_GPU_COOLER_LEVELS
));
3496 CoolerLevels
.Version
= GPU_COOLER_LEVELS_VER
| sizeof (NV_GPU_COOLER_LEVELS
);
3498 CoolerLevels
.Levels
[0].Level
= fanspeed
;
3499 CoolerLevels
.Levels
[0].Policy
= 1;
3501 if (hm_NvAPI_GPU_SetCoolerLevels (data
.hm_nvapi
, data
.hm_device
[device_id
].nvapi
, 0, &CoolerLevels
) != NVAPI_OK
) return -1;
3507 if (hm_NvAPI_GPU_RestoreCoolerSettings (data
.hm_nvapi
, data
.hm_device
[device_id
].nvapi
, 0) != NVAPI_OK
) return -1;
3517 int hm_set_fanspeed_with_device_id_xnvctrl (const uint device_id
, const int fanspeed
)
3519 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3521 if (data
.hm_xnvctrl
)
3523 if (set_fan_speed_target (data
.hm_xnvctrl
, data
.hm_device
[device_id
].xnvctrl
, fanspeed
) != 0) return -1;
3532 #endif // HAVE_HWMON
3538 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3540 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3542 if (css_cnt
> SP_PW_MAX
)
3544 log_error ("ERROR: Mask length is too long");
3549 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3551 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3553 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3554 uint cs_len
= css
[css_pos
].cs_len
;
3556 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3558 uint c
= cs_buf
[cs_pos
] & 0xff;
3565 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3567 cs_t
*cs
= &css
[css_cnt
];
3569 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3571 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3575 for (i
= 0; i
< cs
->cs_len
; i
++)
3577 const uint u
= cs
->cs_buf
[i
];
3582 for (i
= 0; i
< in_len
; i
++)
3584 uint u
= in_buf
[i
] & 0xff;
3586 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3588 if (css_uniq
[u
] == 1) continue;
3592 cs
->cs_buf
[cs
->cs_len
] = u
;
3600 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3604 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3606 uint p0
= in_buf
[in_pos
] & 0xff;
3608 if (interpret
== 1 && p0
== '?')
3612 if (in_pos
== in_len
) break;
3614 uint p1
= in_buf
[in_pos
] & 0xff;
3618 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3620 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3622 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3624 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3626 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3628 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3630 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3631 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3633 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3634 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3636 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3637 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3639 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3640 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3642 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3644 default: log_error ("Syntax error: %s", in_buf
);
3650 if (data
.hex_charset
)
3654 if (in_pos
== in_len
)
3656 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3661 uint p1
= in_buf
[in_pos
] & 0xff;
3663 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3665 log_error ("ERROR: Invalid hex character detected in mask %s", in_buf
);
3672 chr
= hex_convert (p1
) << 0;
3673 chr
|= hex_convert (p0
) << 4;
3675 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3681 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3687 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3691 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3693 sum
*= css
[css_pos
].cs_len
;
3699 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3701 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3706 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3708 char p0
= mask_buf
[mask_pos
];
3714 if (mask_pos
== mask_len
) break;
3716 char p1
= mask_buf
[mask_pos
];
3722 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3724 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3726 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3728 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3730 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3732 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3734 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3735 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3737 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3738 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3740 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3741 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3743 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3744 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3746 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3748 default: log_error ("ERROR: Syntax error: %s", mask_buf
);
3754 if (data
.hex_charset
)
3758 // if there is no 2nd hex character, show an error:
3760 if (mask_pos
== mask_len
)
3762 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3767 char p1
= mask_buf
[mask_pos
];
3769 // if they are not valid hex character, show an error:
3771 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3773 log_error ("ERROR: Invalid hex character detected in mask %s", mask_buf
);
3780 chr
|= hex_convert (p1
) << 0;
3781 chr
|= hex_convert (p0
) << 4;
3783 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3789 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3796 log_error ("ERROR: Invalid mask length (0)");
3806 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3808 for (int i
= 0; i
< css_cnt
; i
++)
3810 uint len
= css
[i
].cs_len
;
3811 u64 next
= val
/ len
;
3812 uint pos
= val
% len
;
3813 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3818 void mp_cut_at (char *mask
, uint max
)
3822 uint mask_len
= strlen (mask
);
3824 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3826 if (mask
[i
] == '?') i
++;
3832 void mp_setup_sys (cs_t
*mp_sys
)
3836 uint donec
[CHARSIZ
] = { 0 };
3838 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3839 mp_sys
[0].cs_buf
[pos
++] = chr
;
3840 mp_sys
[0].cs_len
= pos
; }
3842 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3843 mp_sys
[1].cs_buf
[pos
++] = chr
;
3844 mp_sys
[1].cs_len
= pos
; }
3846 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3847 mp_sys
[2].cs_buf
[pos
++] = chr
;
3848 mp_sys
[2].cs_len
= pos
; }
3850 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3851 mp_sys
[3].cs_buf
[pos
++] = chr
;
3852 mp_sys
[3].cs_len
= pos
; }
3854 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3855 mp_sys
[4].cs_len
= pos
; }
3857 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3858 mp_sys
[5].cs_len
= pos
; }
3861 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3863 FILE *fp
= fopen (buf
, "rb");
3865 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3867 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3871 char mp_file
[1024] = { 0 };
3873 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3877 len
= in_superchop (mp_file
);
3881 log_info ("WARNING: Charset file corrupted");
3883 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3887 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3892 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3894 mp_usr
[index
].cs_len
= 0;
3896 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3899 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3901 char *new_mask_buf
= (char *) mymalloc (256);
3907 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3909 if (css_pos
== len
) break;
3911 char p0
= mask_buf
[mask_pos
];
3913 new_mask_buf
[mask_pos
] = p0
;
3919 if (mask_pos
== mask_len
) break;
3921 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3925 if (data
.hex_charset
)
3929 if (mask_pos
== mask_len
)
3931 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3936 char p1
= mask_buf
[mask_pos
];
3938 // if they are not valid hex character, show an error:
3940 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3942 log_error ("ERROR: Invalid hex character detected in mask: %s", mask_buf
);
3947 new_mask_buf
[mask_pos
] = p1
;
3952 if (css_pos
== len
) return (new_mask_buf
);
3954 myfree (new_mask_buf
);
3963 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3969 for (i
= start
; i
< stop
; i
++)
3971 sum
*= root_css_buf
[i
].cs_len
;
3977 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3981 cs_t
*cs
= &root_css_buf
[start
];
3985 for (i
= start
; i
< stop
; i
++)
3987 const u64 m
= v
% cs
->cs_len
;
3988 const u64 d
= v
/ cs
->cs_len
;
3992 const uint k
= cs
->cs_buf
[m
];
3994 pw_buf
[i
- start
] = (char) k
;
3996 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
4000 int sp_comp_val (const void *p1
, const void *p2
)
4002 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
4003 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
4005 return b2
->val
- b1
->val
;
4008 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
)
4015 * Initialize hcstats
4018 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
4020 u64
*root_stats_ptr
= root_stats_buf
;
4022 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
4024 for (i
= 0; i
< SP_PW_MAX
; i
++)
4026 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
4028 root_stats_ptr
+= CHARSIZ
;
4031 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
4033 u64
*markov_stats_ptr
= markov_stats_buf
;
4035 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4037 for (i
= 0; i
< SP_PW_MAX
; i
++)
4039 for (j
= 0; j
< CHARSIZ
; j
++)
4041 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
4043 markov_stats_ptr
+= CHARSIZ
;
4053 char hcstat_tmp
[256] = { 0 };
4055 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
4057 hcstat
= hcstat_tmp
;
4060 FILE *fd
= fopen (hcstat
, "rb");
4064 log_error ("%s: %s", hcstat
, strerror (errno
));
4069 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
4071 log_error ("%s: Could not load data", hcstat
);
4078 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
4080 log_error ("%s: Could not load data", hcstat
);
4090 * Markov modifier of hcstat_table on user request
4095 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4096 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4101 /* Add all stats to first position */
4103 for (i
= 1; i
< SP_PW_MAX
; i
++)
4105 u64
*out
= root_stats_buf_by_pos
[0];
4106 u64
*in
= root_stats_buf_by_pos
[i
];
4108 for (j
= 0; j
< CHARSIZ
; j
++)
4114 for (i
= 1; i
< SP_PW_MAX
; i
++)
4116 u64
*out
= markov_stats_buf_by_key
[0][0];
4117 u64
*in
= markov_stats_buf_by_key
[i
][0];
4119 for (j
= 0; j
< CHARSIZ
; j
++)
4121 for (k
= 0; k
< CHARSIZ
; k
++)
4128 /* copy them to all pw_positions */
4130 for (i
= 1; i
< SP_PW_MAX
; i
++)
4132 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4135 for (i
= 1; i
< SP_PW_MAX
; i
++)
4137 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4145 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4147 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4149 for (i
= 0; i
< SP_PW_MAX
; i
++)
4151 root_table_buf_by_pos
[i
] = root_table_ptr
;
4153 root_table_ptr
+= CHARSIZ
;
4156 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4158 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4160 for (i
= 0; i
< SP_PW_MAX
; i
++)
4162 for (j
= 0; j
< CHARSIZ
; j
++)
4164 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4166 markov_table_ptr
+= CHARSIZ
;
4171 * Convert hcstat to tables
4174 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4176 uint key
= i
% CHARSIZ
;
4178 root_table_buf
[i
].key
= key
;
4179 root_table_buf
[i
].val
= root_stats_buf
[i
];
4182 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4184 uint key
= i
% CHARSIZ
;
4186 markov_table_buf
[i
].key
= key
;
4187 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4190 myfree (root_stats_buf
);
4191 myfree (markov_stats_buf
);
4197 for (i
= 0; i
< SP_PW_MAX
; i
++)
4199 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4202 for (i
= 0; i
< SP_PW_MAX
; i
++)
4204 for (j
= 0; j
< CHARSIZ
; j
++)
4206 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4211 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
])
4214 * Convert tables to css
4217 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4219 uint pw_pos
= i
/ CHARSIZ
;
4221 cs_t
*cs
= &root_css_buf
[pw_pos
];
4223 if (cs
->cs_len
== threshold
) continue;
4225 uint key
= root_table_buf
[i
].key
;
4227 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4229 cs
->cs_buf
[cs
->cs_len
] = key
;
4235 * Convert table to css
4238 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4240 uint c
= i
/ CHARSIZ
;
4242 cs_t
*cs
= &markov_css_buf
[c
];
4244 if (cs
->cs_len
== threshold
) continue;
4246 uint pw_pos
= c
/ CHARSIZ
;
4248 uint key
= markov_table_buf
[i
].key
;
4250 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4252 cs
->cs_buf
[cs
->cs_len
] = key
;
4258 for (uint i = 0; i < 8; i++)
4260 for (uint j = 0x20; j < 0x80; j++)
4262 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4264 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4266 for (uint k = 0; k < 10; k++)
4268 printf (" %u\n", ptr->cs_buf[k]);
4275 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4277 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4279 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4289 for (uint j
= 1; j
< CHARSIZ
; j
++)
4299 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4301 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4303 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4305 out
+= CHARSIZ
* CHARSIZ
;
4306 in
+= CHARSIZ
* CHARSIZ
;
4308 for (uint j
= 0; j
< CHARSIZ
; j
++)
4315 for (uint k
= 1; k
< CHARSIZ
; k
++)
4327 * mixed shared functions
4330 void dump_hex (const u8
*s
, const int sz
)
4332 for (int i
= 0; i
< sz
; i
++)
4334 log_info_nn ("%02x ", s
[i
]);
4340 void usage_mini_print (const char *progname
)
4342 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4345 void usage_big_print (const char *progname
)
4347 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4350 char *get_exec_path ()
4352 int exec_path_len
= 1024;
4354 char *exec_path
= (char *) mymalloc (exec_path_len
);
4358 char tmp
[32] = { 0 };
4360 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4362 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4366 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4370 uint size
= exec_path_len
;
4372 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4374 log_error("! executable path buffer too small\n");
4379 const int len
= strlen (exec_path
);
4383 #include <sys/sysctl.h>
4388 mib
[2] = KERN_PROC_PATHNAME
;
4391 char tmp
[32] = { 0 };
4393 size_t size
= exec_path_len
;
4394 sysctl(mib
, 4, exec_path
, &size
, NULL
, 0);
4396 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4399 #error Your Operating System is not supported or detected
4407 char *get_install_dir (const char *progname
)
4409 char *install_dir
= mystrdup (progname
);
4410 char *last_slash
= NULL
;
4412 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4416 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4422 install_dir
[0] = '.';
4426 return (install_dir
);
4429 char *get_profile_dir (const char *homedir
)
4431 #define DOT_HASHCAT ".hashcat"
4433 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4435 char *profile_dir
= (char *) mymalloc (len
+ 1);
4437 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4442 char *get_session_dir (const char *profile_dir
)
4444 #define SESSIONS_FOLDER "sessions"
4446 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4448 char *session_dir
= (char *) mymalloc (len
+ 1);
4450 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4455 uint
count_lines (FILE *fd
)
4459 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4465 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4467 if (nread
< 1) continue;
4471 for (i
= 0; i
< nread
; i
++)
4473 if (prev
== '\n') cnt
++;
4484 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4488 FILE *fd
= fopen (filename
, "rb");
4492 log_error ("%s: %s", filename
, strerror (errno
));
4497 #define MAX_KEY_SIZE (1024 * 1024)
4499 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4501 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4507 for (int fpos
= 0; fpos
< nread
; fpos
++)
4509 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4511 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4512 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4513 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4514 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4516 if (kpos
>= 64) kpos
= 0;
4523 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4527 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4528 if (CPU_ISSET(core
, cpu_set
)) break;
4530 thread_affinity_policy_data_t policy
= { core
};
4532 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4534 if (data
.quiet
== 0)
4536 if (rc
!= KERN_SUCCESS
)
4538 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4546 void set_cpu_affinity (char *cpu_affinity
)
4549 DWORD_PTR aff_mask
= 0;
4560 char *devices
= strdup (cpu_affinity
);
4562 char *next
= strtok (devices
, ",");
4566 uint cpu_id
= atoi (next
);
4581 log_error ("ERROR: Invalid cpu_id %u specified", cpu_id
);
4587 aff_mask
|= 1 << (cpu_id
- 1);
4589 CPU_SET ((cpu_id
- 1), &cpuset
);
4592 } while ((next
= strtok (NULL
, ",")) != NULL
);
4598 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4599 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4601 pthread_t thread
= pthread_self ();
4602 pthread_setaffinity_np (thread
, sizeof (cpuset_t
), &cpuset
);
4604 pthread_t thread
= pthread_self ();
4605 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4609 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4611 char *element
, *end
;
4613 end
= (char *) base
+ nmemb
* size
;
4615 for (element
= (char *) base
; element
< end
; element
+= size
)
4616 if (!compar (element
, key
))
4622 int sort_by_u32 (const void *v1
, const void *v2
)
4624 const u32
*s1
= (const u32
*) v1
;
4625 const u32
*s2
= (const u32
*) v2
;
4630 int sort_by_salt (const void *v1
, const void *v2
)
4632 const salt_t
*s1
= (const salt_t
*) v1
;
4633 const salt_t
*s2
= (const salt_t
*) v2
;
4635 const int res1
= s1
->salt_len
- s2
->salt_len
;
4637 if (res1
!= 0) return (res1
);
4639 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4641 if (res2
!= 0) return (res2
);
4649 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4650 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4657 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4658 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4664 int sort_by_salt_buf (const void *v1
, const void *v2
)
4666 const pot_t
*p1
= (const pot_t
*) v1
;
4667 const pot_t
*p2
= (const pot_t
*) v2
;
4669 const hash_t
*h1
= &p1
->hash
;
4670 const hash_t
*h2
= &p2
->hash
;
4672 const salt_t
*s1
= h1
->salt
;
4673 const salt_t
*s2
= h2
->salt
;
4679 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4680 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4686 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4688 const hash_t
*h1
= (const hash_t
*) v1
;
4689 const hash_t
*h2
= (const hash_t
*) v2
;
4691 const salt_t
*s1
= h1
->salt
;
4692 const salt_t
*s2
= h2
->salt
;
4694 // testphase: this should work
4699 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4700 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4703 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4704 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4705 if (s1->salt_len > s2->salt_len) return ( 1);
4706 if (s1->salt_len < s2->salt_len) return (-1);
4708 uint n = s1->salt_len;
4712 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4713 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4720 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4722 const hash_t
*h1
= (const hash_t
*) v1
;
4723 const hash_t
*h2
= (const hash_t
*) v2
;
4725 const salt_t
*s1
= h1
->salt
;
4726 const salt_t
*s2
= h2
->salt
;
4728 // last 2: salt_buf[10] and salt_buf[11] contain the digest (skip them)
4730 uint n
= 9; // 9 * 4 = 36 bytes (max length of ESSID)
4734 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4735 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4741 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4743 const hash_t
*h1
= (const hash_t
*) v1
;
4744 const hash_t
*h2
= (const hash_t
*) v2
;
4746 const void *d1
= h1
->digest
;
4747 const void *d2
= h2
->digest
;
4749 return data
.sort_by_digest (d1
, d2
);
4752 int sort_by_hash (const void *v1
, const void *v2
)
4754 const hash_t
*h1
= (const hash_t
*) v1
;
4755 const hash_t
*h2
= (const hash_t
*) v2
;
4759 const salt_t
*s1
= h1
->salt
;
4760 const salt_t
*s2
= h2
->salt
;
4762 int res
= sort_by_salt (s1
, s2
);
4764 if (res
!= 0) return (res
);
4767 const void *d1
= h1
->digest
;
4768 const void *d2
= h2
->digest
;
4770 return data
.sort_by_digest (d1
, d2
);
4773 int sort_by_pot (const void *v1
, const void *v2
)
4775 const pot_t
*p1
= (const pot_t
*) v1
;
4776 const pot_t
*p2
= (const pot_t
*) v2
;
4778 const hash_t
*h1
= &p1
->hash
;
4779 const hash_t
*h2
= &p2
->hash
;
4781 return sort_by_hash (h1
, h2
);
4784 int sort_by_mtime (const void *p1
, const void *p2
)
4786 const char **f1
= (const char **) p1
;
4787 const char **f2
= (const char **) p2
;
4789 struct stat s1
; stat (*f1
, &s1
);
4790 struct stat s2
; stat (*f2
, &s2
);
4792 return s2
.st_mtime
- s1
.st_mtime
;
4795 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4797 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4798 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4800 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4803 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4805 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4806 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4808 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4811 int sort_by_stringptr (const void *p1
, const void *p2
)
4813 const char **s1
= (const char **) p1
;
4814 const char **s2
= (const char **) p2
;
4816 return strcmp (*s1
, *s2
);
4819 int sort_by_dictstat (const void *s1
, const void *s2
)
4821 dictstat_t
*d1
= (dictstat_t
*) s1
;
4822 dictstat_t
*d2
= (dictstat_t
*) s2
;
4825 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4827 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4830 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4833 int sort_by_bitmap (const void *p1
, const void *p2
)
4835 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4836 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4838 return b1
->collisions
- b2
->collisions
;
4841 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4843 const u32
*d1
= (const u32
*) v1
;
4844 const u32
*d2
= (const u32
*) v2
;
4850 if (d1
[n
] > d2
[n
]) return ( 1);
4851 if (d1
[n
] < d2
[n
]) return (-1);
4857 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4859 const u32
*d1
= (const u32
*) v1
;
4860 const u32
*d2
= (const u32
*) v2
;
4866 if (d1
[n
] > d2
[n
]) return ( 1);
4867 if (d1
[n
] < d2
[n
]) return (-1);
4873 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4875 const u32
*d1
= (const u32
*) v1
;
4876 const u32
*d2
= (const u32
*) v2
;
4882 if (d1
[n
] > d2
[n
]) return ( 1);
4883 if (d1
[n
] < d2
[n
]) return (-1);
4889 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4891 const u32
*d1
= (const u32
*) v1
;
4892 const u32
*d2
= (const u32
*) v2
;
4898 if (d1
[n
] > d2
[n
]) return ( 1);
4899 if (d1
[n
] < d2
[n
]) return (-1);
4905 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4907 const u32
*d1
= (const u32
*) v1
;
4908 const u32
*d2
= (const u32
*) v2
;
4914 if (d1
[n
] > d2
[n
]) return ( 1);
4915 if (d1
[n
] < d2
[n
]) return (-1);
4921 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4923 const u32
*d1
= (const u32
*) v1
;
4924 const u32
*d2
= (const u32
*) v2
;
4930 if (d1
[n
] > d2
[n
]) return ( 1);
4931 if (d1
[n
] < d2
[n
]) return (-1);
4937 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4939 const u32
*d1
= (const u32
*) v1
;
4940 const u32
*d2
= (const u32
*) v2
;
4946 if (d1
[n
] > d2
[n
]) return ( 1);
4947 if (d1
[n
] < d2
[n
]) return (-1);
4953 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4955 const u32
*d1
= (const u32
*) v1
;
4956 const u32
*d2
= (const u32
*) v2
;
4962 if (d1
[n
] > d2
[n
]) return ( 1);
4963 if (d1
[n
] < d2
[n
]) return (-1);
4969 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4971 const u64
*d1
= (const u64
*) v1
;
4972 const u64
*d2
= (const u64
*) v2
;
4978 if (d1
[n
] > d2
[n
]) return ( 1);
4979 if (d1
[n
] < d2
[n
]) return (-1);
4985 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4987 const u64
*d1
= (const u64
*) v1
;
4988 const u64
*d2
= (const u64
*) v2
;
4994 if (d1
[n
] > d2
[n
]) return ( 1);
4995 if (d1
[n
] < d2
[n
]) return (-1);
5001 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
5003 const u64
*d1
= (const u64
*) v1
;
5004 const u64
*d2
= (const u64
*) v2
;
5010 if (d1
[n
] > d2
[n
]) return ( 1);
5011 if (d1
[n
] < d2
[n
]) return (-1);
5017 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
5019 const u32
*d1
= (const u32
*) v1
;
5020 const u32
*d2
= (const u32
*) v2
;
5022 const uint dgst_pos0
= data
.dgst_pos0
;
5023 const uint dgst_pos1
= data
.dgst_pos1
;
5024 const uint dgst_pos2
= data
.dgst_pos2
;
5025 const uint dgst_pos3
= data
.dgst_pos3
;
5027 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
5028 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
5029 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
5030 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
5031 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
5032 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
5033 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
5034 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
5039 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
5041 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
5042 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
5044 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
5046 if (res1
!= 0) return (res1
);
5051 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
5053 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
5054 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
5056 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
5058 if (res1
!= 0) return (res1
);
5060 const int res2
= t1
->attack_mode
5063 if (res2
!= 0) return (res2
);
5065 const int res3
= t1
->hash_type
5068 if (res3
!= 0) return (res3
);
5073 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
)
5075 uint outfile_autohex
= data
.outfile_autohex
;
5077 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
5079 FILE *debug_fp
= NULL
;
5081 if (debug_file
!= NULL
)
5083 debug_fp
= fopen (debug_file
, "ab");
5085 lock_file (debug_fp
);
5092 if (debug_fp
== NULL
)
5094 log_info ("WARNING: Could not open debug-file for writing");
5098 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
5100 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
5102 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
5105 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
5107 if (debug_mode
== 4)
5109 fputc (':', debug_fp
);
5111 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5114 fputc ('\n', debug_fp
);
5116 if (debug_file
!= NULL
) fclose (debug_fp
);
5120 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5122 int needs_hexify
= 0;
5124 if (outfile_autohex
== 1)
5126 for (uint i
= 0; i
< plain_len
; i
++)
5128 if (plain_ptr
[i
] < 0x20)
5135 if (plain_ptr
[i
] > 0x7f)
5144 if (needs_hexify
== 1)
5146 fprintf (fp
, "$HEX[");
5148 for (uint i
= 0; i
< plain_len
; i
++)
5150 fprintf (fp
, "%02x", plain_ptr
[i
]);
5157 fwrite (plain_ptr
, plain_len
, 1, fp
);
5161 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
)
5163 uint outfile_format
= data
.outfile_format
;
5165 char separator
= data
.separator
;
5167 if (outfile_format
& OUTFILE_FMT_HASH
)
5169 fprintf (out_fp
, "%s", out_buf
);
5171 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5173 fputc (separator
, out_fp
);
5176 else if (data
.username
)
5178 if (username
!= NULL
)
5180 for (uint i
= 0; i
< user_len
; i
++)
5182 fprintf (out_fp
, "%c", username
[i
]);
5185 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5187 fputc (separator
, out_fp
);
5192 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5194 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5196 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5198 fputc (separator
, out_fp
);
5202 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5204 for (uint i
= 0; i
< plain_len
; i
++)
5206 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5209 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5211 fputc (separator
, out_fp
);
5215 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5218 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5223 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5225 fprintf (out_fp
, "%llu", crackpos
);
5230 fputc ('\n', out_fp
);
5233 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
)
5237 pot_key
.hash
.salt
= hashes_buf
->salt
;
5238 pot_key
.hash
.digest
= hashes_buf
->digest
;
5240 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5246 input_buf
[input_len
] = 0;
5249 unsigned char *username
= NULL
;
5254 user_t
*user
= hashes_buf
->hash_info
->user
;
5258 username
= (unsigned char *) (user
->user_name
);
5260 user_len
= user
->user_len
;
5264 // do output the line
5265 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5269 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5270 #define LM_MASKED_PLAIN "[notfound]"
5272 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
)
5278 pot_left_key
.hash
.salt
= hash_left
->salt
;
5279 pot_left_key
.hash
.digest
= hash_left
->digest
;
5281 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5285 uint weak_hash_found
= 0;
5287 pot_t pot_right_key
;
5289 pot_right_key
.hash
.salt
= hash_right
->salt
;
5290 pot_right_key
.hash
.digest
= hash_right
->digest
;
5292 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5294 if (pot_right_ptr
== NULL
)
5296 // special case, if "weak hash"
5298 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5300 weak_hash_found
= 1;
5302 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5304 // in theory this is not needed, but we are paranoia:
5306 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5307 pot_right_ptr
->plain_len
= 0;
5311 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5313 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
5318 // at least one half was found:
5322 input_buf
[input_len
] = 0;
5326 unsigned char *username
= NULL
;
5331 user_t
*user
= hash_left
->hash_info
->user
;
5335 username
= (unsigned char *) (user
->user_name
);
5337 user_len
= user
->user_len
;
5341 // mask the part which was not found
5343 uint left_part_masked
= 0;
5344 uint right_part_masked
= 0;
5346 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5348 if (pot_left_ptr
== NULL
)
5350 left_part_masked
= 1;
5352 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5354 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5356 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5357 pot_left_ptr
->plain_len
= mask_plain_len
;
5360 if (pot_right_ptr
== NULL
)
5362 right_part_masked
= 1;
5364 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5366 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5368 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5369 pot_right_ptr
->plain_len
= mask_plain_len
;
5372 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5376 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5378 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5380 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5382 // do output the line
5384 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5386 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5388 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5389 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5392 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
)
5396 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5398 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5400 if (pot_ptr
== NULL
)
5404 input_buf
[input_len
] = 0;
5406 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5410 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
)
5416 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5418 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5422 pot_t pot_right_key
;
5424 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5426 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5428 uint weak_hash_found
= 0;
5430 if (pot_right_ptr
== NULL
)
5432 // special case, if "weak hash"
5434 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5436 weak_hash_found
= 1;
5438 // we just need that pot_right_ptr is not a NULL pointer
5440 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5444 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5446 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5451 // ... at least one part was not cracked
5455 input_buf
[input_len
] = 0;
5457 // only show the hash part which is still not cracked
5459 uint user_len
= input_len
- 32;
5461 char *hash_output
= (char *) mymalloc (33);
5463 memcpy (hash_output
, input_buf
, input_len
);
5465 if (pot_left_ptr
!= NULL
)
5467 // only show right part (because left part was already found)
5469 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5471 hash_output
[user_len
+ 16] = 0;
5474 if (pot_right_ptr
!= NULL
)
5476 // only show left part (because right part was already found)
5478 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5480 hash_output
[user_len
+ 16] = 0;
5483 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5485 myfree (hash_output
);
5487 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5490 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5492 uint opencl_platforms_filter
= 0;
5494 if (opencl_platforms
)
5496 char *platforms
= strdup (opencl_platforms
);
5498 char *next
= strtok (platforms
, ",");
5502 int platform
= atoi (next
);
5504 if (platform
< 1 || platform
> 32)
5506 log_error ("ERROR: Invalid OpenCL platform %u specified", platform
);
5511 opencl_platforms_filter
|= 1 << (platform
- 1);
5513 } while ((next
= strtok (NULL
, ",")) != NULL
);
5519 opencl_platforms_filter
= -1;
5522 return opencl_platforms_filter
;
5525 u32
setup_devices_filter (char *opencl_devices
)
5527 u32 devices_filter
= 0;
5531 char *devices
= strdup (opencl_devices
);
5533 char *next
= strtok (devices
, ",");
5537 int device_id
= atoi (next
);
5539 if (device_id
< 1 || device_id
> 32)
5541 log_error ("ERROR: Invalid device_id %u specified", device_id
);
5546 devices_filter
|= 1 << (device_id
- 1);
5548 } while ((next
= strtok (NULL
, ",")) != NULL
);
5554 devices_filter
= -1;
5557 return devices_filter
;
5560 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5562 cl_device_type device_types_filter
= 0;
5564 if (opencl_device_types
)
5566 char *device_types
= strdup (opencl_device_types
);
5568 char *next
= strtok (device_types
, ",");
5572 int device_type
= atoi (next
);
5574 if (device_type
< 1 || device_type
> 3)
5576 log_error ("ERROR: Invalid device_type %u specified", device_type
);
5581 device_types_filter
|= 1 << device_type
;
5583 } while ((next
= strtok (NULL
, ",")) != NULL
);
5585 free (device_types
);
5589 // Do not use CPU by default, this often reduces GPU performance because
5590 // the CPU is too busy to handle GPU synchronization
5592 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5595 return device_types_filter
;
5598 u32
get_random_num (const u32 min
, const u32 max
)
5600 if (min
== max
) return (min
);
5602 return ((rand () % (max
- min
)) + min
);
5605 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5607 u32 quotient
= dividend
/ divisor
;
5609 if (dividend
% divisor
) quotient
++;
5614 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5616 u64 quotient
= dividend
/ divisor
;
5618 if (dividend
% divisor
) quotient
++;
5623 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5625 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5626 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5628 if (tm
->tm_year
- 70)
5630 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5631 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5633 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5635 else if (tm
->tm_yday
)
5637 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5638 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5640 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5642 else if (tm
->tm_hour
)
5644 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5645 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5647 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5649 else if (tm
->tm_min
)
5651 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5652 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5654 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5658 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5660 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5664 void format_speed_display (float val
, char *buf
, size_t len
)
5675 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5686 /* generate output */
5690 snprintf (buf
, len
- 1, "%.0f ", val
);
5694 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5698 void lowercase (u8
*buf
, int len
)
5700 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5703 void uppercase (u8
*buf
, int len
)
5705 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5708 int fgetl (FILE *fp
, char *line_buf
)
5714 const int c
= fgetc (fp
);
5716 if (c
== EOF
) break;
5718 line_buf
[line_len
] = (char) c
;
5722 if (line_len
== HCBUFSIZ
) line_len
--;
5724 if (c
== '\n') break;
5727 if (line_len
== 0) return 0;
5729 if (line_buf
[line_len
- 1] == '\n')
5733 line_buf
[line_len
] = 0;
5736 if (line_len
== 0) return 0;
5738 if (line_buf
[line_len
- 1] == '\r')
5742 line_buf
[line_len
] = 0;
5748 int in_superchop (char *buf
)
5750 int len
= strlen (buf
);
5754 if (buf
[len
- 1] == '\n')
5761 if (buf
[len
- 1] == '\r')
5776 char **scan_directory (const char *path
)
5778 char *tmp_path
= mystrdup (path
);
5780 size_t tmp_path_len
= strlen (tmp_path
);
5782 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5784 tmp_path
[tmp_path_len
- 1] = 0;
5786 tmp_path_len
= strlen (tmp_path
);
5789 char **files
= NULL
;
5795 if ((d
= opendir (tmp_path
)) != NULL
)
5801 memset (&e
, 0, sizeof (e
));
5802 struct dirent
*de
= NULL
;
5804 if (readdir_r (d
, &e
, &de
) != 0)
5806 log_error ("ERROR: readdir_r() failed");
5811 if (de
== NULL
) break;
5815 while ((de
= readdir (d
)) != NULL
)
5818 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5820 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5822 char *path_file
= (char *) mymalloc (path_size
+ 1);
5824 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5826 path_file
[path_size
] = 0;
5830 if ((d_test
= opendir (path_file
)) != NULL
)
5838 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5842 files
[num_files
- 1] = path_file
;
5848 else if (errno
== ENOTDIR
)
5850 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5854 files
[num_files
- 1] = mystrdup (path
);
5857 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5861 files
[num_files
- 1] = NULL
;
5868 int count_dictionaries (char **dictionary_files
)
5870 if (dictionary_files
== NULL
) return 0;
5874 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5882 char *stroptitype (const uint opti_type
)
5886 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5887 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5888 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5889 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5890 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5891 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5892 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5893 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5894 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5895 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5896 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5897 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5898 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5899 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5900 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5901 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5902 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5903 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5904 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5910 char *strparser (const uint parser_status
)
5912 switch (parser_status
)
5914 case PARSER_OK
: return ((char *) PA_000
); break;
5915 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5916 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5917 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5918 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5919 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5920 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5921 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5922 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5923 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5924 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5925 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5926 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5927 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5928 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5929 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5930 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5933 return ((char *) PA_255
);
5936 char *strhashtype (const uint hash_mode
)
5940 case 0: return ((char *) HT_00000
); break;
5941 case 10: return ((char *) HT_00010
); break;
5942 case 11: return ((char *) HT_00011
); break;
5943 case 12: return ((char *) HT_00012
); break;
5944 case 20: return ((char *) HT_00020
); break;
5945 case 21: return ((char *) HT_00021
); break;
5946 case 22: return ((char *) HT_00022
); break;
5947 case 23: return ((char *) HT_00023
); break;
5948 case 30: return ((char *) HT_00030
); break;
5949 case 40: return ((char *) HT_00040
); break;
5950 case 50: return ((char *) HT_00050
); break;
5951 case 60: return ((char *) HT_00060
); break;
5952 case 100: return ((char *) HT_00100
); break;
5953 case 101: return ((char *) HT_00101
); break;
5954 case 110: return ((char *) HT_00110
); break;
5955 case 111: return ((char *) HT_00111
); break;
5956 case 112: return ((char *) HT_00112
); break;
5957 case 120: return ((char *) HT_00120
); break;
5958 case 121: return ((char *) HT_00121
); break;
5959 case 122: return ((char *) HT_00122
); break;
5960 case 124: return ((char *) HT_00124
); break;
5961 case 125: return ((char *) HT_00125
); break;
5962 case 130: return ((char *) HT_00130
); break;
5963 case 131: return ((char *) HT_00131
); break;
5964 case 132: return ((char *) HT_00132
); break;
5965 case 133: return ((char *) HT_00133
); break;
5966 case 140: return ((char *) HT_00140
); break;
5967 case 141: return ((char *) HT_00141
); break;
5968 case 150: return ((char *) HT_00150
); break;
5969 case 160: return ((char *) HT_00160
); break;
5970 case 200: return ((char *) HT_00200
); break;
5971 case 300: return ((char *) HT_00300
); break;
5972 case 400: return ((char *) HT_00400
); break;
5973 case 500: return ((char *) HT_00500
); break;
5974 case 501: return ((char *) HT_00501
); break;
5975 case 900: return ((char *) HT_00900
); break;
5976 case 910: return ((char *) HT_00910
); break;
5977 case 1000: return ((char *) HT_01000
); break;
5978 case 1100: return ((char *) HT_01100
); break;
5979 case 1400: return ((char *) HT_01400
); break;
5980 case 1410: return ((char *) HT_01410
); break;
5981 case 1420: return ((char *) HT_01420
); break;
5982 case 1421: return ((char *) HT_01421
); break;
5983 case 1430: return ((char *) HT_01430
); break;
5984 case 1440: return ((char *) HT_01440
); break;
5985 case 1441: return ((char *) HT_01441
); break;
5986 case 1450: return ((char *) HT_01450
); break;
5987 case 1460: return ((char *) HT_01460
); break;
5988 case 1500: return ((char *) HT_01500
); break;
5989 case 1600: return ((char *) HT_01600
); break;
5990 case 1700: return ((char *) HT_01700
); break;
5991 case 1710: return ((char *) HT_01710
); break;
5992 case 1711: return ((char *) HT_01711
); break;
5993 case 1720: return ((char *) HT_01720
); break;
5994 case 1722: return ((char *) HT_01722
); break;
5995 case 1730: return ((char *) HT_01730
); break;
5996 case 1731: return ((char *) HT_01731
); break;
5997 case 1740: return ((char *) HT_01740
); break;
5998 case 1750: return ((char *) HT_01750
); break;
5999 case 1760: return ((char *) HT_01760
); break;
6000 case 1800: return ((char *) HT_01800
); break;
6001 case 2100: return ((char *) HT_02100
); break;
6002 case 2400: return ((char *) HT_02400
); break;
6003 case 2410: return ((char *) HT_02410
); break;
6004 case 2500: return ((char *) HT_02500
); break;
6005 case 2600: return ((char *) HT_02600
); break;
6006 case 2611: return ((char *) HT_02611
); break;
6007 case 2612: return ((char *) HT_02612
); break;
6008 case 2711: return ((char *) HT_02711
); break;
6009 case 2811: return ((char *) HT_02811
); break;
6010 case 3000: return ((char *) HT_03000
); break;
6011 case 3100: return ((char *) HT_03100
); break;
6012 case 3200: return ((char *) HT_03200
); break;
6013 case 3710: return ((char *) HT_03710
); break;
6014 case 3711: return ((char *) HT_03711
); break;
6015 case 3800: return ((char *) HT_03800
); break;
6016 case 4300: return ((char *) HT_04300
); break;
6017 case 4400: return ((char *) HT_04400
); break;
6018 case 4500: return ((char *) HT_04500
); break;
6019 case 4700: return ((char *) HT_04700
); break;
6020 case 4800: return ((char *) HT_04800
); break;
6021 case 4900: return ((char *) HT_04900
); break;
6022 case 5000: return ((char *) HT_05000
); break;
6023 case 5100: return ((char *) HT_05100
); break;
6024 case 5200: return ((char *) HT_05200
); break;
6025 case 5300: return ((char *) HT_05300
); break;
6026 case 5400: return ((char *) HT_05400
); break;
6027 case 5500: return ((char *) HT_05500
); break;
6028 case 5600: return ((char *) HT_05600
); break;
6029 case 5700: return ((char *) HT_05700
); break;
6030 case 5800: return ((char *) HT_05800
); break;
6031 case 6000: return ((char *) HT_06000
); break;
6032 case 6100: return ((char *) HT_06100
); break;
6033 case 6211: return ((char *) HT_06211
); break;
6034 case 6212: return ((char *) HT_06212
); break;
6035 case 6213: return ((char *) HT_06213
); break;
6036 case 6221: return ((char *) HT_06221
); break;
6037 case 6222: return ((char *) HT_06222
); break;
6038 case 6223: return ((char *) HT_06223
); break;
6039 case 6231: return ((char *) HT_06231
); break;
6040 case 6232: return ((char *) HT_06232
); break;
6041 case 6233: return ((char *) HT_06233
); break;
6042 case 6241: return ((char *) HT_06241
); break;
6043 case 6242: return ((char *) HT_06242
); break;
6044 case 6243: return ((char *) HT_06243
); break;
6045 case 6300: return ((char *) HT_06300
); break;
6046 case 6400: return ((char *) HT_06400
); break;
6047 case 6500: return ((char *) HT_06500
); break;
6048 case 6600: return ((char *) HT_06600
); break;
6049 case 6700: return ((char *) HT_06700
); break;
6050 case 6800: return ((char *) HT_06800
); break;
6051 case 6900: return ((char *) HT_06900
); break;
6052 case 7100: return ((char *) HT_07100
); break;
6053 case 7200: return ((char *) HT_07200
); break;
6054 case 7300: return ((char *) HT_07300
); break;
6055 case 7400: return ((char *) HT_07400
); break;
6056 case 7500: return ((char *) HT_07500
); break;
6057 case 7600: return ((char *) HT_07600
); break;
6058 case 7700: return ((char *) HT_07700
); break;
6059 case 7800: return ((char *) HT_07800
); break;
6060 case 7900: return ((char *) HT_07900
); break;
6061 case 8000: return ((char *) HT_08000
); break;
6062 case 8100: return ((char *) HT_08100
); break;
6063 case 8200: return ((char *) HT_08200
); break;
6064 case 8300: return ((char *) HT_08300
); break;
6065 case 8400: return ((char *) HT_08400
); break;
6066 case 8500: return ((char *) HT_08500
); break;
6067 case 8600: return ((char *) HT_08600
); break;
6068 case 8700: return ((char *) HT_08700
); break;
6069 case 8800: return ((char *) HT_08800
); break;
6070 case 8900: return ((char *) HT_08900
); break;
6071 case 9000: return ((char *) HT_09000
); break;
6072 case 9100: return ((char *) HT_09100
); break;
6073 case 9200: return ((char *) HT_09200
); break;
6074 case 9300: return ((char *) HT_09300
); break;
6075 case 9400: return ((char *) HT_09400
); break;
6076 case 9500: return ((char *) HT_09500
); break;
6077 case 9600: return ((char *) HT_09600
); break;
6078 case 9700: return ((char *) HT_09700
); break;
6079 case 9710: return ((char *) HT_09710
); break;
6080 case 9720: return ((char *) HT_09720
); break;
6081 case 9800: return ((char *) HT_09800
); break;
6082 case 9810: return ((char *) HT_09810
); break;
6083 case 9820: return ((char *) HT_09820
); break;
6084 case 9900: return ((char *) HT_09900
); break;
6085 case 10000: return ((char *) HT_10000
); break;
6086 case 10100: return ((char *) HT_10100
); break;
6087 case 10200: return ((char *) HT_10200
); break;
6088 case 10300: return ((char *) HT_10300
); break;
6089 case 10400: return ((char *) HT_10400
); break;
6090 case 10410: return ((char *) HT_10410
); break;
6091 case 10420: return ((char *) HT_10420
); break;
6092 case 10500: return ((char *) HT_10500
); break;
6093 case 10600: return ((char *) HT_10600
); break;
6094 case 10700: return ((char *) HT_10700
); break;
6095 case 10800: return ((char *) HT_10800
); break;
6096 case 10900: return ((char *) HT_10900
); break;
6097 case 11000: return ((char *) HT_11000
); break;
6098 case 11100: return ((char *) HT_11100
); break;
6099 case 11200: return ((char *) HT_11200
); break;
6100 case 11300: return ((char *) HT_11300
); break;
6101 case 11400: return ((char *) HT_11400
); break;
6102 case 11500: return ((char *) HT_11500
); break;
6103 case 11600: return ((char *) HT_11600
); break;
6104 case 11700: return ((char *) HT_11700
); break;
6105 case 11800: return ((char *) HT_11800
); break;
6106 case 11900: return ((char *) HT_11900
); break;
6107 case 12000: return ((char *) HT_12000
); break;
6108 case 12100: return ((char *) HT_12100
); break;
6109 case 12200: return ((char *) HT_12200
); break;
6110 case 12300: return ((char *) HT_12300
); break;
6111 case 12400: return ((char *) HT_12400
); break;
6112 case 12500: return ((char *) HT_12500
); break;
6113 case 12600: return ((char *) HT_12600
); break;
6114 case 12700: return ((char *) HT_12700
); break;
6115 case 12800: return ((char *) HT_12800
); break;
6116 case 12900: return ((char *) HT_12900
); break;
6117 case 13000: return ((char *) HT_13000
); break;
6118 case 13100: return ((char *) HT_13100
); break;
6119 case 13200: return ((char *) HT_13200
); break;
6120 case 13300: return ((char *) HT_13300
); break;
6121 case 13400: return ((char *) HT_13400
); break;
6122 case 13500: return ((char *) HT_13500
); break;
6123 case 13600: return ((char *) HT_13600
); break;
6124 case 13711: return ((char *) HT_13711
); break;
6125 case 13712: return ((char *) HT_13712
); break;
6126 case 13713: return ((char *) HT_13713
); break;
6127 case 13721: return ((char *) HT_13721
); break;
6128 case 13722: return ((char *) HT_13722
); break;
6129 case 13723: return ((char *) HT_13723
); break;
6130 case 13731: return ((char *) HT_13731
); break;
6131 case 13732: return ((char *) HT_13732
); break;
6132 case 13733: return ((char *) HT_13733
); break;
6133 case 13741: return ((char *) HT_13741
); break;
6134 case 13742: return ((char *) HT_13742
); break;
6135 case 13743: return ((char *) HT_13743
); break;
6136 case 13751: return ((char *) HT_13751
); break;
6137 case 13752: return ((char *) HT_13752
); break;
6138 case 13753: return ((char *) HT_13753
); break;
6139 case 13761: return ((char *) HT_13761
); break;
6140 case 13762: return ((char *) HT_13762
); break;
6141 case 13763: return ((char *) HT_13763
); break;
6142 case 13800: return ((char *) HT_13800
); break;
6145 return ((char *) "Unknown");
6148 char *strstatus (const uint devices_status
)
6150 switch (devices_status
)
6152 case STATUS_INIT
: return ((char *) ST_0000
); break;
6153 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6154 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6155 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6156 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6157 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6158 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6159 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6160 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6161 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6162 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6165 return ((char *) "Unknown");
6168 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6170 uint hash_type
= data
.hash_type
;
6171 uint hash_mode
= data
.hash_mode
;
6172 uint salt_type
= data
.salt_type
;
6173 uint opts_type
= data
.opts_type
;
6174 uint opti_type
= data
.opti_type
;
6175 uint dgst_size
= data
.dgst_size
;
6177 char *hashfile
= data
.hashfile
;
6181 u8 datax
[256] = { 0 };
6183 u64
*digest_buf64
= (u64
*) datax
;
6184 u32
*digest_buf
= (u32
*) datax
;
6186 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6188 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6190 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6196 case HASH_TYPE_DESCRYPT
:
6197 FP (digest_buf
[1], digest_buf
[0], tt
);
6200 case HASH_TYPE_DESRACF
:
6201 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6202 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6204 FP (digest_buf
[1], digest_buf
[0], tt
);
6208 FP (digest_buf
[1], digest_buf
[0], tt
);
6211 case HASH_TYPE_NETNTLM
:
6212 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6213 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6214 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6215 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6217 FP (digest_buf
[1], digest_buf
[0], tt
);
6218 FP (digest_buf
[3], digest_buf
[2], tt
);
6221 case HASH_TYPE_BSDICRYPT
:
6222 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6223 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6225 FP (digest_buf
[1], digest_buf
[0], tt
);
6230 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6235 digest_buf
[0] += MD4M_A
;
6236 digest_buf
[1] += MD4M_B
;
6237 digest_buf
[2] += MD4M_C
;
6238 digest_buf
[3] += MD4M_D
;
6242 digest_buf
[0] += MD5M_A
;
6243 digest_buf
[1] += MD5M_B
;
6244 digest_buf
[2] += MD5M_C
;
6245 digest_buf
[3] += MD5M_D
;
6248 case HASH_TYPE_SHA1
:
6249 digest_buf
[0] += SHA1M_A
;
6250 digest_buf
[1] += SHA1M_B
;
6251 digest_buf
[2] += SHA1M_C
;
6252 digest_buf
[3] += SHA1M_D
;
6253 digest_buf
[4] += SHA1M_E
;
6256 case HASH_TYPE_SHA256
:
6257 digest_buf
[0] += SHA256M_A
;
6258 digest_buf
[1] += SHA256M_B
;
6259 digest_buf
[2] += SHA256M_C
;
6260 digest_buf
[3] += SHA256M_D
;
6261 digest_buf
[4] += SHA256M_E
;
6262 digest_buf
[5] += SHA256M_F
;
6263 digest_buf
[6] += SHA256M_G
;
6264 digest_buf
[7] += SHA256M_H
;
6267 case HASH_TYPE_SHA384
:
6268 digest_buf64
[0] += SHA384M_A
;
6269 digest_buf64
[1] += SHA384M_B
;
6270 digest_buf64
[2] += SHA384M_C
;
6271 digest_buf64
[3] += SHA384M_D
;
6272 digest_buf64
[4] += SHA384M_E
;
6273 digest_buf64
[5] += SHA384M_F
;
6274 digest_buf64
[6] += 0;
6275 digest_buf64
[7] += 0;
6278 case HASH_TYPE_SHA512
:
6279 digest_buf64
[0] += SHA512M_A
;
6280 digest_buf64
[1] += SHA512M_B
;
6281 digest_buf64
[2] += SHA512M_C
;
6282 digest_buf64
[3] += SHA512M_D
;
6283 digest_buf64
[4] += SHA512M_E
;
6284 digest_buf64
[5] += SHA512M_F
;
6285 digest_buf64
[6] += SHA512M_G
;
6286 digest_buf64
[7] += SHA512M_H
;
6291 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6293 if (dgst_size
== DGST_SIZE_4_2
)
6295 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6297 else if (dgst_size
== DGST_SIZE_4_4
)
6299 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6301 else if (dgst_size
== DGST_SIZE_4_5
)
6303 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6305 else if (dgst_size
== DGST_SIZE_4_6
)
6307 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6309 else if (dgst_size
== DGST_SIZE_4_8
)
6311 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6313 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6315 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6317 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6319 else if (hash_type
== HASH_TYPE_SHA384
)
6321 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6323 else if (hash_type
== HASH_TYPE_SHA512
)
6325 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6327 else if (hash_type
== HASH_TYPE_GOST
)
6329 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6332 else if (dgst_size
== DGST_SIZE_4_64
)
6334 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6336 else if (dgst_size
== DGST_SIZE_8_25
)
6338 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6342 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6343 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6344 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6350 memset (&salt
, 0, sizeof (salt_t
));
6352 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6354 char *ptr
= (char *) salt
.salt_buf
;
6356 uint len
= salt
.salt_len
;
6358 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6364 case HASH_TYPE_NETNTLM
:
6366 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6367 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6369 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6375 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6377 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6385 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6387 uint max
= salt
.salt_len
/ 4;
6391 for (uint i
= 0; i
< max
; i
++)
6393 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6397 if (opts_type
& OPTS_TYPE_ST_HEX
)
6399 char tmp
[64] = { 0 };
6401 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6403 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6408 memcpy (ptr
, tmp
, len
);
6411 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6413 memset (ptr
+ len
, 0, memset_size
);
6415 salt
.salt_len
= len
;
6419 // some modes require special encoding
6422 uint out_buf_plain
[256] = { 0 };
6423 uint out_buf_salt
[256] = { 0 };
6425 char tmp_buf
[1024] = { 0 };
6427 char *ptr_plain
= (char *) out_buf_plain
;
6428 char *ptr_salt
= (char *) out_buf_salt
;
6430 if (hash_mode
== 22)
6432 char username
[30] = { 0 };
6434 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6436 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6438 u16
*ptr
= (u16
*) digest_buf
;
6440 tmp_buf
[ 0] = sig
[0];
6441 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6442 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6443 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6444 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6445 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6446 tmp_buf
[ 6] = sig
[1];
6447 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6448 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6449 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6450 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6451 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6452 tmp_buf
[12] = sig
[2];
6453 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6454 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6455 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6456 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6457 tmp_buf
[17] = sig
[3];
6458 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6459 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6460 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6461 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6462 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6463 tmp_buf
[23] = sig
[4];
6464 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6465 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6466 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6467 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6468 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6469 tmp_buf
[29] = sig
[5];
6471 snprintf (out_buf
, len
-1, "%s:%s",
6475 else if (hash_mode
== 23)
6477 // do not show the skyper part in output
6479 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6481 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6483 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6490 else if (hash_mode
== 101)
6492 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6494 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6495 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6496 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6497 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6498 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6500 memcpy (tmp_buf
, digest_buf
, 20);
6502 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6504 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6506 else if (hash_mode
== 111)
6508 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6510 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6511 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6512 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6513 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6514 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6516 memcpy (tmp_buf
, digest_buf
, 20);
6517 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6519 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6521 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6523 else if ((hash_mode
== 122) || (hash_mode
== 125))
6525 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6526 (char *) salt
.salt_buf
,
6533 else if (hash_mode
== 124)
6535 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6536 (char *) salt
.salt_buf
,
6543 else if (hash_mode
== 131)
6545 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6546 (char *) salt
.salt_buf
,
6554 else if (hash_mode
== 132)
6556 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6557 (char *) salt
.salt_buf
,
6564 else if (hash_mode
== 133)
6566 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6568 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6569 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6570 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6571 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6572 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6574 memcpy (tmp_buf
, digest_buf
, 20);
6576 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6578 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6580 else if (hash_mode
== 141)
6582 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6584 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6586 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6588 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6590 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6591 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6592 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6593 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6594 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6596 memcpy (tmp_buf
, digest_buf
, 20);
6598 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6602 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6604 else if (hash_mode
== 400)
6606 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6608 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6609 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6610 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6611 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6613 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6615 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6617 else if (hash_mode
== 500)
6619 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6621 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6622 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6623 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6624 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6626 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6628 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6630 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6634 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6637 else if (hash_mode
== 501)
6639 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6641 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6642 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6644 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6646 else if (hash_mode
== 1421)
6648 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6650 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6666 else if (hash_mode
== 1441)
6668 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6670 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6672 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6674 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6676 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6677 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6678 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6679 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6680 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6681 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6682 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6683 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6685 memcpy (tmp_buf
, digest_buf
, 32);
6687 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6691 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6693 else if (hash_mode
== 1500)
6695 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6696 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6697 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6698 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6699 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6701 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6703 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6705 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6706 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6708 memcpy (tmp_buf
, digest_buf
, 8);
6710 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6712 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6716 else if (hash_mode
== 1600)
6718 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6720 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6721 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6722 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6723 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6725 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6727 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6729 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6733 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6736 else if (hash_mode
== 1711)
6738 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6740 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6741 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6742 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6743 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6744 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6745 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6746 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6747 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6749 memcpy (tmp_buf
, digest_buf
, 64);
6750 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6752 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6754 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6756 else if (hash_mode
== 1722)
6758 uint
*ptr
= digest_buf
;
6760 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6761 (unsigned char *) salt
.salt_buf
,
6771 else if (hash_mode
== 1731)
6773 uint
*ptr
= digest_buf
;
6775 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6776 (unsigned char *) salt
.salt_buf
,
6786 else if (hash_mode
== 1800)
6790 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6791 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6792 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6793 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6794 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6795 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6796 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6797 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6799 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6801 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6803 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6807 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6810 else if (hash_mode
== 2100)
6814 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6816 salt
.salt_iter
+ 1);
6818 uint signature_len
= strlen (out_buf
);
6820 pos
+= signature_len
;
6821 len
-= signature_len
;
6823 char *salt_ptr
= (char *) salt
.salt_buf
;
6825 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6827 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6828 byte_swap_32 (digest_buf
[0]),
6829 byte_swap_32 (digest_buf
[1]),
6830 byte_swap_32 (digest_buf
[2]),
6831 byte_swap_32 (digest_buf
[3]));
6833 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6835 memcpy (tmp_buf
, digest_buf
, 16);
6837 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6839 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6840 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6841 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6842 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6844 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6845 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6846 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6847 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6849 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6850 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6851 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6852 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6854 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6855 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6856 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6857 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6859 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6860 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6861 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6862 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6866 else if (hash_mode
== 2500)
6868 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6870 wpa_t
*wpa
= &wpas
[salt_pos
];
6872 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6873 (char *) salt
.salt_buf
,
6887 else if (hash_mode
== 4400)
6889 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6890 byte_swap_32 (digest_buf
[0]),
6891 byte_swap_32 (digest_buf
[1]),
6892 byte_swap_32 (digest_buf
[2]),
6893 byte_swap_32 (digest_buf
[3]));
6895 else if (hash_mode
== 4700)
6897 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6898 byte_swap_32 (digest_buf
[0]),
6899 byte_swap_32 (digest_buf
[1]),
6900 byte_swap_32 (digest_buf
[2]),
6901 byte_swap_32 (digest_buf
[3]),
6902 byte_swap_32 (digest_buf
[4]));
6904 else if (hash_mode
== 4800)
6906 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6908 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6913 byte_swap_32 (salt
.salt_buf
[0]),
6914 byte_swap_32 (salt
.salt_buf
[1]),
6915 byte_swap_32 (salt
.salt_buf
[2]),
6916 byte_swap_32 (salt
.salt_buf
[3]),
6919 else if (hash_mode
== 4900)
6921 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6922 byte_swap_32 (digest_buf
[0]),
6923 byte_swap_32 (digest_buf
[1]),
6924 byte_swap_32 (digest_buf
[2]),
6925 byte_swap_32 (digest_buf
[3]),
6926 byte_swap_32 (digest_buf
[4]));
6928 else if (hash_mode
== 5100)
6930 snprintf (out_buf
, len
-1, "%08x%08x",
6934 else if (hash_mode
== 5200)
6936 snprintf (out_buf
, len
-1, "%s", hashfile
);
6938 else if (hash_mode
== 5300)
6940 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6942 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6944 int buf_len
= len
-1;
6948 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6950 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6952 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6954 snprintf (out_buf
, buf_len
, ":");
6960 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6968 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6970 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6972 if ((i
== 0) || (i
== 5))
6974 snprintf (out_buf
, buf_len
, ":");
6980 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6988 for (uint i
= 0; i
< 4; i
++)
6992 snprintf (out_buf
, buf_len
, ":");
6998 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
7004 else if (hash_mode
== 5400)
7006 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
7008 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
7010 int buf_len
= len
-1;
7014 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
7016 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
7018 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
7020 snprintf (out_buf
, buf_len
, ":");
7026 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
7034 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
7036 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
7038 if ((i
== 0) || (i
== 5))
7040 snprintf (out_buf
, buf_len
, ":");
7046 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
7054 for (uint i
= 0; i
< 5; i
++)
7058 snprintf (out_buf
, buf_len
, ":");
7064 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
7070 else if (hash_mode
== 5500)
7072 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7074 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7076 char user_buf
[64] = { 0 };
7077 char domain_buf
[64] = { 0 };
7078 char srvchall_buf
[1024] = { 0 };
7079 char clichall_buf
[1024] = { 0 };
7081 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7083 char *ptr
= (char *) netntlm
->userdomain_buf
;
7085 user_buf
[i
] = ptr
[j
];
7088 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7090 char *ptr
= (char *) netntlm
->userdomain_buf
;
7092 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7095 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7097 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7099 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7102 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7104 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7106 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7109 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7117 byte_swap_32 (salt
.salt_buf_pc
[0]),
7118 byte_swap_32 (salt
.salt_buf_pc
[1]),
7121 else if (hash_mode
== 5600)
7123 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7125 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7127 char user_buf
[64] = { 0 };
7128 char domain_buf
[64] = { 0 };
7129 char srvchall_buf
[1024] = { 0 };
7130 char clichall_buf
[1024] = { 0 };
7132 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7134 char *ptr
= (char *) netntlm
->userdomain_buf
;
7136 user_buf
[i
] = ptr
[j
];
7139 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7141 char *ptr
= (char *) netntlm
->userdomain_buf
;
7143 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7146 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7148 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7150 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7153 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7155 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7157 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7160 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7170 else if (hash_mode
== 5700)
7172 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7174 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7175 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7176 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7177 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7178 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7179 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7180 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7181 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7183 memcpy (tmp_buf
, digest_buf
, 32);
7185 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7189 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7191 else if (hash_mode
== 5800)
7193 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7194 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7195 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7196 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7197 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7199 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7206 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7208 snprintf (out_buf
, len
-1, "%s", hashfile
);
7210 else if (hash_mode
== 6300)
7212 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7214 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7215 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7216 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7217 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7219 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7221 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7223 else if (hash_mode
== 6400)
7225 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7227 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7229 else if (hash_mode
== 6500)
7231 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7233 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7235 else if (hash_mode
== 6600)
7237 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7239 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7241 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7242 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7244 uint buf_len
= len
- 1;
7246 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7249 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7251 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7256 else if (hash_mode
== 6700)
7258 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7260 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7262 else if (hash_mode
== 6800)
7264 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7266 else if (hash_mode
== 7100)
7268 uint
*ptr
= digest_buf
;
7270 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7272 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7274 uint esalt
[8] = { 0 };
7276 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7277 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7278 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7279 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7280 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7281 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7282 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7283 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7285 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",
7286 SIGNATURE_SHA512OSX
,
7288 esalt
[ 0], esalt
[ 1],
7289 esalt
[ 2], esalt
[ 3],
7290 esalt
[ 4], esalt
[ 5],
7291 esalt
[ 6], esalt
[ 7],
7299 ptr
[15], ptr
[14]);
7301 else if (hash_mode
== 7200)
7303 uint
*ptr
= digest_buf
;
7305 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7307 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7311 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7313 len_used
= strlen (out_buf
);
7315 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7317 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7319 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7322 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",
7330 ptr
[15], ptr
[14]);
7332 else if (hash_mode
== 7300)
7334 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7336 rakp_t
*rakp
= &rakps
[salt_pos
];
7338 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7340 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7343 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7350 else if (hash_mode
== 7400)
7352 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7354 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7355 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7356 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7357 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7358 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7359 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7360 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7361 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7363 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7365 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7367 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7371 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7374 else if (hash_mode
== 7500)
7376 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7378 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7380 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7381 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7383 char data
[128] = { 0 };
7385 char *ptr_data
= data
;
7387 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7389 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7392 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7394 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7399 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7401 (char *) krb5pa
->user
,
7402 (char *) krb5pa
->realm
,
7403 (char *) krb5pa
->salt
,
7406 else if (hash_mode
== 7700)
7408 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7409 (char *) salt
.salt_buf
,
7413 else if (hash_mode
== 7800)
7415 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7416 (char *) salt
.salt_buf
,
7423 else if (hash_mode
== 7900)
7425 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7429 char *tmp
= (char *) salt
.salt_buf_pc
;
7431 ptr_plain
[42] = tmp
[0];
7437 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7439 else if (hash_mode
== 8000)
7441 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7442 (unsigned char *) salt
.salt_buf
,
7452 else if (hash_mode
== 8100)
7454 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7455 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7457 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7458 (unsigned char *) salt
.salt_buf
,
7465 else if (hash_mode
== 8200)
7467 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7469 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7471 char data_buf
[4096] = { 0 };
7473 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7475 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7478 data_buf
[cloudkey
->data_len
* 2] = 0;
7480 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7481 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7482 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7483 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7484 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7485 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7486 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7487 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7489 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7490 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7491 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7492 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7494 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7510 else if (hash_mode
== 8300)
7512 char digest_buf_c
[34] = { 0 };
7514 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7515 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7516 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7517 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7518 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7520 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7522 digest_buf_c
[32] = 0;
7526 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7528 char domain_buf_c
[33] = { 0 };
7530 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7532 for (uint i
= 0; i
< salt_pc_len
; i
++)
7534 const char next
= domain_buf_c
[i
];
7536 domain_buf_c
[i
] = '.';
7541 domain_buf_c
[salt_pc_len
] = 0;
7545 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7547 else if (hash_mode
== 8500)
7549 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7551 else if (hash_mode
== 2612)
7553 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7555 (char *) salt
.salt_buf
,
7561 else if (hash_mode
== 3711)
7563 char *salt_ptr
= (char *) salt
.salt_buf
;
7565 salt_ptr
[salt
.salt_len
- 1] = 0;
7567 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7568 SIGNATURE_MEDIAWIKI_B
,
7575 else if (hash_mode
== 8800)
7577 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7579 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7581 char tmp
[3073] = { 0 };
7583 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7585 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7590 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7591 SIGNATURE_ANDROIDFDE
,
7592 byte_swap_32 (salt
.salt_buf
[0]),
7593 byte_swap_32 (salt
.salt_buf
[1]),
7594 byte_swap_32 (salt
.salt_buf
[2]),
7595 byte_swap_32 (salt
.salt_buf
[3]),
7596 byte_swap_32 (digest_buf
[0]),
7597 byte_swap_32 (digest_buf
[1]),
7598 byte_swap_32 (digest_buf
[2]),
7599 byte_swap_32 (digest_buf
[3]),
7602 else if (hash_mode
== 8900)
7604 uint N
= salt
.scrypt_N
;
7605 uint r
= salt
.scrypt_r
;
7606 uint p
= salt
.scrypt_p
;
7608 char base64_salt
[32] = { 0 };
7610 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7612 memset (tmp_buf
, 0, 46);
7614 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7615 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7616 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7617 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7618 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7619 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7620 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7621 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7622 digest_buf
[8] = 0; // needed for base64_encode ()
7624 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7626 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7634 else if (hash_mode
== 9000)
7636 snprintf (out_buf
, len
-1, "%s", hashfile
);
7638 else if (hash_mode
== 9200)
7642 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7644 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7646 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7650 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7651 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7652 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7653 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7654 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7655 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7656 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7657 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7658 digest_buf
[8] = 0; // needed for base64_encode ()
7660 char tmp_buf
[64] = { 0 };
7662 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7663 tmp_buf
[43] = 0; // cut it here
7667 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7669 else if (hash_mode
== 9300)
7671 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7672 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7673 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7674 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7675 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7676 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7677 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7678 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7679 digest_buf
[8] = 0; // needed for base64_encode ()
7681 char tmp_buf
[64] = { 0 };
7683 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7684 tmp_buf
[43] = 0; // cut it here
7686 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7688 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7690 else if (hash_mode
== 9400)
7692 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7694 office2007_t
*office2007
= &office2007s
[salt_pos
];
7696 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7697 SIGNATURE_OFFICE2007
,
7700 office2007
->keySize
,
7706 office2007
->encryptedVerifier
[0],
7707 office2007
->encryptedVerifier
[1],
7708 office2007
->encryptedVerifier
[2],
7709 office2007
->encryptedVerifier
[3],
7710 office2007
->encryptedVerifierHash
[0],
7711 office2007
->encryptedVerifierHash
[1],
7712 office2007
->encryptedVerifierHash
[2],
7713 office2007
->encryptedVerifierHash
[3],
7714 office2007
->encryptedVerifierHash
[4]);
7716 else if (hash_mode
== 9500)
7718 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7720 office2010_t
*office2010
= &office2010s
[salt_pos
];
7722 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,
7728 office2010
->encryptedVerifier
[0],
7729 office2010
->encryptedVerifier
[1],
7730 office2010
->encryptedVerifier
[2],
7731 office2010
->encryptedVerifier
[3],
7732 office2010
->encryptedVerifierHash
[0],
7733 office2010
->encryptedVerifierHash
[1],
7734 office2010
->encryptedVerifierHash
[2],
7735 office2010
->encryptedVerifierHash
[3],
7736 office2010
->encryptedVerifierHash
[4],
7737 office2010
->encryptedVerifierHash
[5],
7738 office2010
->encryptedVerifierHash
[6],
7739 office2010
->encryptedVerifierHash
[7]);
7741 else if (hash_mode
== 9600)
7743 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7745 office2013_t
*office2013
= &office2013s
[salt_pos
];
7747 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,
7753 office2013
->encryptedVerifier
[0],
7754 office2013
->encryptedVerifier
[1],
7755 office2013
->encryptedVerifier
[2],
7756 office2013
->encryptedVerifier
[3],
7757 office2013
->encryptedVerifierHash
[0],
7758 office2013
->encryptedVerifierHash
[1],
7759 office2013
->encryptedVerifierHash
[2],
7760 office2013
->encryptedVerifierHash
[3],
7761 office2013
->encryptedVerifierHash
[4],
7762 office2013
->encryptedVerifierHash
[5],
7763 office2013
->encryptedVerifierHash
[6],
7764 office2013
->encryptedVerifierHash
[7]);
7766 else if (hash_mode
== 9700)
7768 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7770 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7772 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7773 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7774 byte_swap_32 (salt
.salt_buf
[0]),
7775 byte_swap_32 (salt
.salt_buf
[1]),
7776 byte_swap_32 (salt
.salt_buf
[2]),
7777 byte_swap_32 (salt
.salt_buf
[3]),
7778 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7779 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7780 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7781 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7782 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7783 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7784 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7785 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7787 else if (hash_mode
== 9710)
7789 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7791 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7793 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7794 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7795 byte_swap_32 (salt
.salt_buf
[0]),
7796 byte_swap_32 (salt
.salt_buf
[1]),
7797 byte_swap_32 (salt
.salt_buf
[2]),
7798 byte_swap_32 (salt
.salt_buf
[3]),
7799 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7800 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7801 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7802 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7803 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7804 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7805 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7806 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7808 else if (hash_mode
== 9720)
7810 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7812 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7814 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7816 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7817 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7818 byte_swap_32 (salt
.salt_buf
[0]),
7819 byte_swap_32 (salt
.salt_buf
[1]),
7820 byte_swap_32 (salt
.salt_buf
[2]),
7821 byte_swap_32 (salt
.salt_buf
[3]),
7822 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7823 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7824 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7825 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7826 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7827 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7828 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7829 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7836 else if (hash_mode
== 9800)
7838 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7840 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7842 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7843 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7848 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7849 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7850 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7851 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7852 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7853 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7854 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7855 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7856 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7858 else if (hash_mode
== 9810)
7860 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7862 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7864 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7865 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7870 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7871 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7872 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7873 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7874 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7875 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7876 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7877 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7878 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7880 else if (hash_mode
== 9820)
7882 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7884 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7886 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7888 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7889 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7894 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7895 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7896 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7897 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7898 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7899 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7900 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7901 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7902 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7909 else if (hash_mode
== 10000)
7913 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7915 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7917 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7921 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7922 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7923 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7924 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7925 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7926 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7927 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7928 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7929 digest_buf
[8] = 0; // needed for base64_encode ()
7931 char tmp_buf
[64] = { 0 };
7933 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7937 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7939 else if (hash_mode
== 10100)
7941 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7946 byte_swap_32 (salt
.salt_buf
[0]),
7947 byte_swap_32 (salt
.salt_buf
[1]),
7948 byte_swap_32 (salt
.salt_buf
[2]),
7949 byte_swap_32 (salt
.salt_buf
[3]));
7951 else if (hash_mode
== 10200)
7953 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7955 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7959 char challenge
[100] = { 0 };
7961 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7965 char tmp_buf
[100] = { 0 };
7967 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7968 (char *) cram_md5
->user
,
7974 char response
[100] = { 0 };
7976 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7978 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7980 else if (hash_mode
== 10300)
7982 char tmp_buf
[100] = { 0 };
7984 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7985 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7987 uint tmp_len
= 20 + salt
.salt_len
;
7991 char base64_encoded
[100] = { 0 };
7993 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7995 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7997 else if (hash_mode
== 10400)
7999 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8001 pdf_t
*pdf
= &pdfs
[salt_pos
];
8003 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",
8011 byte_swap_32 (pdf
->id_buf
[0]),
8012 byte_swap_32 (pdf
->id_buf
[1]),
8013 byte_swap_32 (pdf
->id_buf
[2]),
8014 byte_swap_32 (pdf
->id_buf
[3]),
8016 byte_swap_32 (pdf
->u_buf
[0]),
8017 byte_swap_32 (pdf
->u_buf
[1]),
8018 byte_swap_32 (pdf
->u_buf
[2]),
8019 byte_swap_32 (pdf
->u_buf
[3]),
8020 byte_swap_32 (pdf
->u_buf
[4]),
8021 byte_swap_32 (pdf
->u_buf
[5]),
8022 byte_swap_32 (pdf
->u_buf
[6]),
8023 byte_swap_32 (pdf
->u_buf
[7]),
8025 byte_swap_32 (pdf
->o_buf
[0]),
8026 byte_swap_32 (pdf
->o_buf
[1]),
8027 byte_swap_32 (pdf
->o_buf
[2]),
8028 byte_swap_32 (pdf
->o_buf
[3]),
8029 byte_swap_32 (pdf
->o_buf
[4]),
8030 byte_swap_32 (pdf
->o_buf
[5]),
8031 byte_swap_32 (pdf
->o_buf
[6]),
8032 byte_swap_32 (pdf
->o_buf
[7])
8035 else if (hash_mode
== 10410)
8037 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8039 pdf_t
*pdf
= &pdfs
[salt_pos
];
8041 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",
8049 byte_swap_32 (pdf
->id_buf
[0]),
8050 byte_swap_32 (pdf
->id_buf
[1]),
8051 byte_swap_32 (pdf
->id_buf
[2]),
8052 byte_swap_32 (pdf
->id_buf
[3]),
8054 byte_swap_32 (pdf
->u_buf
[0]),
8055 byte_swap_32 (pdf
->u_buf
[1]),
8056 byte_swap_32 (pdf
->u_buf
[2]),
8057 byte_swap_32 (pdf
->u_buf
[3]),
8058 byte_swap_32 (pdf
->u_buf
[4]),
8059 byte_swap_32 (pdf
->u_buf
[5]),
8060 byte_swap_32 (pdf
->u_buf
[6]),
8061 byte_swap_32 (pdf
->u_buf
[7]),
8063 byte_swap_32 (pdf
->o_buf
[0]),
8064 byte_swap_32 (pdf
->o_buf
[1]),
8065 byte_swap_32 (pdf
->o_buf
[2]),
8066 byte_swap_32 (pdf
->o_buf
[3]),
8067 byte_swap_32 (pdf
->o_buf
[4]),
8068 byte_swap_32 (pdf
->o_buf
[5]),
8069 byte_swap_32 (pdf
->o_buf
[6]),
8070 byte_swap_32 (pdf
->o_buf
[7])
8073 else if (hash_mode
== 10420)
8075 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8077 pdf_t
*pdf
= &pdfs
[salt_pos
];
8079 u8
*rc4key
= (u8
*) pdf
->rc4key
;
8081 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",
8089 byte_swap_32 (pdf
->id_buf
[0]),
8090 byte_swap_32 (pdf
->id_buf
[1]),
8091 byte_swap_32 (pdf
->id_buf
[2]),
8092 byte_swap_32 (pdf
->id_buf
[3]),
8094 byte_swap_32 (pdf
->u_buf
[0]),
8095 byte_swap_32 (pdf
->u_buf
[1]),
8096 byte_swap_32 (pdf
->u_buf
[2]),
8097 byte_swap_32 (pdf
->u_buf
[3]),
8098 byte_swap_32 (pdf
->u_buf
[4]),
8099 byte_swap_32 (pdf
->u_buf
[5]),
8100 byte_swap_32 (pdf
->u_buf
[6]),
8101 byte_swap_32 (pdf
->u_buf
[7]),
8103 byte_swap_32 (pdf
->o_buf
[0]),
8104 byte_swap_32 (pdf
->o_buf
[1]),
8105 byte_swap_32 (pdf
->o_buf
[2]),
8106 byte_swap_32 (pdf
->o_buf
[3]),
8107 byte_swap_32 (pdf
->o_buf
[4]),
8108 byte_swap_32 (pdf
->o_buf
[5]),
8109 byte_swap_32 (pdf
->o_buf
[6]),
8110 byte_swap_32 (pdf
->o_buf
[7]),
8118 else if (hash_mode
== 10500)
8120 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8122 pdf_t
*pdf
= &pdfs
[salt_pos
];
8124 if (pdf
->id_len
== 32)
8126 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",
8134 byte_swap_32 (pdf
->id_buf
[0]),
8135 byte_swap_32 (pdf
->id_buf
[1]),
8136 byte_swap_32 (pdf
->id_buf
[2]),
8137 byte_swap_32 (pdf
->id_buf
[3]),
8138 byte_swap_32 (pdf
->id_buf
[4]),
8139 byte_swap_32 (pdf
->id_buf
[5]),
8140 byte_swap_32 (pdf
->id_buf
[6]),
8141 byte_swap_32 (pdf
->id_buf
[7]),
8143 byte_swap_32 (pdf
->u_buf
[0]),
8144 byte_swap_32 (pdf
->u_buf
[1]),
8145 byte_swap_32 (pdf
->u_buf
[2]),
8146 byte_swap_32 (pdf
->u_buf
[3]),
8147 byte_swap_32 (pdf
->u_buf
[4]),
8148 byte_swap_32 (pdf
->u_buf
[5]),
8149 byte_swap_32 (pdf
->u_buf
[6]),
8150 byte_swap_32 (pdf
->u_buf
[7]),
8152 byte_swap_32 (pdf
->o_buf
[0]),
8153 byte_swap_32 (pdf
->o_buf
[1]),
8154 byte_swap_32 (pdf
->o_buf
[2]),
8155 byte_swap_32 (pdf
->o_buf
[3]),
8156 byte_swap_32 (pdf
->o_buf
[4]),
8157 byte_swap_32 (pdf
->o_buf
[5]),
8158 byte_swap_32 (pdf
->o_buf
[6]),
8159 byte_swap_32 (pdf
->o_buf
[7])
8164 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",
8172 byte_swap_32 (pdf
->id_buf
[0]),
8173 byte_swap_32 (pdf
->id_buf
[1]),
8174 byte_swap_32 (pdf
->id_buf
[2]),
8175 byte_swap_32 (pdf
->id_buf
[3]),
8177 byte_swap_32 (pdf
->u_buf
[0]),
8178 byte_swap_32 (pdf
->u_buf
[1]),
8179 byte_swap_32 (pdf
->u_buf
[2]),
8180 byte_swap_32 (pdf
->u_buf
[3]),
8181 byte_swap_32 (pdf
->u_buf
[4]),
8182 byte_swap_32 (pdf
->u_buf
[5]),
8183 byte_swap_32 (pdf
->u_buf
[6]),
8184 byte_swap_32 (pdf
->u_buf
[7]),
8186 byte_swap_32 (pdf
->o_buf
[0]),
8187 byte_swap_32 (pdf
->o_buf
[1]),
8188 byte_swap_32 (pdf
->o_buf
[2]),
8189 byte_swap_32 (pdf
->o_buf
[3]),
8190 byte_swap_32 (pdf
->o_buf
[4]),
8191 byte_swap_32 (pdf
->o_buf
[5]),
8192 byte_swap_32 (pdf
->o_buf
[6]),
8193 byte_swap_32 (pdf
->o_buf
[7])
8197 else if (hash_mode
== 10600)
8199 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8201 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8202 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8204 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8206 else if (hash_mode
== 10700)
8208 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8210 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8211 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8213 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8215 else if (hash_mode
== 10900)
8217 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8219 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8220 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8222 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8224 else if (hash_mode
== 11100)
8226 u32 salt_challenge
= salt
.salt_buf
[0];
8228 salt_challenge
= byte_swap_32 (salt_challenge
);
8230 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8232 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8233 SIGNATURE_POSTGRESQL_AUTH
,
8241 else if (hash_mode
== 11200)
8243 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8244 SIGNATURE_MYSQL_AUTH
,
8245 (unsigned char *) salt
.salt_buf
,
8252 else if (hash_mode
== 11300)
8254 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8256 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8258 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8259 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8260 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8262 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8263 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8264 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8266 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8268 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8270 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8273 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8275 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8277 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8280 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8282 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8284 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8287 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8288 SIGNATURE_BITCOIN_WALLET
,
8292 (unsigned char *) salt
.salt_buf
,
8300 free (cry_master_buf
);
8302 free (public_key_buf
);
8304 else if (hash_mode
== 11400)
8306 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8308 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8309 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8311 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8313 else if (hash_mode
== 11600)
8315 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8317 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8319 const uint data_len
= seven_zip
->data_len
;
8321 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8323 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8325 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8327 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8330 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8331 SIGNATURE_SEVEN_ZIP
,
8335 (char *) seven_zip
->salt_buf
,
8337 seven_zip
->iv_buf
[0],
8338 seven_zip
->iv_buf
[1],
8339 seven_zip
->iv_buf
[2],
8340 seven_zip
->iv_buf
[3],
8342 seven_zip
->data_len
,
8343 seven_zip
->unpack_size
,
8348 else if (hash_mode
== 11700)
8350 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8360 else if (hash_mode
== 11800)
8362 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8380 else if (hash_mode
== 11900)
8382 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8384 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8385 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8387 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8389 else if (hash_mode
== 12000)
8391 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8393 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8394 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8396 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8398 else if (hash_mode
== 12100)
8400 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8402 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8403 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8405 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8407 else if (hash_mode
== 12200)
8409 uint
*ptr_digest
= digest_buf
;
8410 uint
*ptr_salt
= salt
.salt_buf
;
8412 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8419 else if (hash_mode
== 12300)
8421 uint
*ptr_digest
= digest_buf
;
8422 uint
*ptr_salt
= salt
.salt_buf
;
8424 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",
8425 ptr_digest
[ 0], ptr_digest
[ 1],
8426 ptr_digest
[ 2], ptr_digest
[ 3],
8427 ptr_digest
[ 4], ptr_digest
[ 5],
8428 ptr_digest
[ 6], ptr_digest
[ 7],
8429 ptr_digest
[ 8], ptr_digest
[ 9],
8430 ptr_digest
[10], ptr_digest
[11],
8431 ptr_digest
[12], ptr_digest
[13],
8432 ptr_digest
[14], ptr_digest
[15],
8438 else if (hash_mode
== 12400)
8440 // encode iteration count
8442 char salt_iter
[5] = { 0 };
8444 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8445 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8446 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8447 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8452 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8453 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8454 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8455 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8460 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8462 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8463 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8465 memcpy (tmp_buf
, digest_buf
, 8);
8467 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8471 // fill the resulting buffer
8473 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8475 else if (hash_mode
== 12500)
8477 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8479 byte_swap_32 (salt
.salt_buf
[0]),
8480 byte_swap_32 (salt
.salt_buf
[1]),
8486 else if (hash_mode
== 12600)
8488 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8489 digest_buf
[0] + salt
.salt_buf_pc
[0],
8490 digest_buf
[1] + salt
.salt_buf_pc
[1],
8491 digest_buf
[2] + salt
.salt_buf_pc
[2],
8492 digest_buf
[3] + salt
.salt_buf_pc
[3],
8493 digest_buf
[4] + salt
.salt_buf_pc
[4],
8494 digest_buf
[5] + salt
.salt_buf_pc
[5],
8495 digest_buf
[6] + salt
.salt_buf_pc
[6],
8496 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8498 else if (hash_mode
== 12700)
8500 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8502 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8503 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8505 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8507 else if (hash_mode
== 12800)
8509 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8511 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",
8524 byte_swap_32 (digest_buf
[0]),
8525 byte_swap_32 (digest_buf
[1]),
8526 byte_swap_32 (digest_buf
[2]),
8527 byte_swap_32 (digest_buf
[3]),
8528 byte_swap_32 (digest_buf
[4]),
8529 byte_swap_32 (digest_buf
[5]),
8530 byte_swap_32 (digest_buf
[6]),
8531 byte_swap_32 (digest_buf
[7])
8534 else if (hash_mode
== 12900)
8536 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",
8545 byte_swap_32 (digest_buf
[0]),
8546 byte_swap_32 (digest_buf
[1]),
8547 byte_swap_32 (digest_buf
[2]),
8548 byte_swap_32 (digest_buf
[3]),
8549 byte_swap_32 (digest_buf
[4]),
8550 byte_swap_32 (digest_buf
[5]),
8551 byte_swap_32 (digest_buf
[6]),
8552 byte_swap_32 (digest_buf
[7]),
8559 else if (hash_mode
== 13000)
8561 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8563 rar5_t
*rar5
= &rar5s
[salt_pos
];
8565 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8575 byte_swap_32 (digest_buf
[0]),
8576 byte_swap_32 (digest_buf
[1])
8579 else if (hash_mode
== 13100)
8581 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8583 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8585 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8586 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8588 char data
[2560 * 4 * 2] = { 0 };
8590 char *ptr_data
= data
;
8592 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8593 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8598 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8599 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8601 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8603 (char *) krb5tgs
->account_info
,
8607 else if (hash_mode
== 13200)
8609 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8623 else if (hash_mode
== 13300)
8625 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8626 SIGNATURE_AXCRYPT_SHA1
,
8632 else if (hash_mode
== 13400)
8634 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8636 keepass_t
*keepass
= &keepasss
[salt_pos
];
8638 u32 version
= (u32
) keepass
->version
;
8639 u32 rounds
= salt
.salt_iter
;
8640 u32 algorithm
= (u32
) keepass
->algorithm
;
8641 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8643 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8644 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8645 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8646 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8647 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8649 /* specific to version 1 */
8653 /* specific to version 2 */
8654 u32 expected_bytes_len
;
8655 u32
*ptr_expected_bytes
;
8657 u32 final_random_seed_len
;
8658 u32 transf_random_seed_len
;
8660 u32 contents_hash_len
;
8662 transf_random_seed_len
= 8;
8664 contents_hash_len
= 8;
8665 final_random_seed_len
= 8;
8668 final_random_seed_len
= 4;
8670 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8676 char *ptr_data
= out_buf
;
8678 ptr_data
+= strlen(out_buf
);
8683 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8684 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8689 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8690 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8695 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8696 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8703 contents_len
= (u32
) keepass
->contents_len
;
8704 ptr_contents
= (u32
*) keepass
->contents
;
8706 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8707 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8719 char ptr_contents_len
[10] = { 0 };
8721 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8723 sprintf (ptr_data
, "%d", contents_len
);
8725 ptr_data
+= strlen(ptr_contents_len
);
8730 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8731 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8733 else if (version
== 2)
8735 expected_bytes_len
= 8;
8736 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8738 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8739 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8744 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8745 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8759 sprintf (ptr_data
, "%d", keyfile_len
);
8766 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8767 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8770 else if (hash_mode
== 13500)
8772 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8774 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8776 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8778 char pstoken_tmp
[1024 + 1] = { 0 };
8780 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8782 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8784 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8787 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8795 else if (hash_mode
== 13600)
8797 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8799 zip2_t
*zip2
= &zip2s
[salt_pos
];
8801 const u32 salt_len
= zip2
->salt_len
;
8803 char salt_tmp
[32 + 1] = { 0 };
8805 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8807 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8809 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8812 const u32 data_len
= zip2
->data_len
;
8814 char data_tmp
[8192 + 1] = { 0 };
8816 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8818 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8820 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8823 const u32 auth_len
= zip2
->auth_len
;
8825 char auth_tmp
[20 + 1] = { 0 };
8827 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8829 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8831 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8834 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8835 SIGNATURE_ZIP2_START
,
8841 zip2
->compress_length
,
8844 SIGNATURE_ZIP2_STOP
);
8846 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8848 snprintf (out_buf
, len
-1, "%s", hashfile
);
8850 else if (hash_mode
== 13800)
8852 win8phone_t
*esalts
= (win8phone_t
*) data
.esalts_buf
;
8854 win8phone_t
*esalt
= &esalts
[salt_pos
];
8856 char buf
[256 + 1] = { 0 };
8858 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
8860 sprintf (buf
+ j
, "%08x", esalt
->salt_buf
[i
]);
8863 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%s",
8876 if (hash_type
== HASH_TYPE_MD4
)
8878 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8884 else if (hash_type
== HASH_TYPE_MD5
)
8886 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8892 else if (hash_type
== HASH_TYPE_SHA1
)
8894 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8901 else if (hash_type
== HASH_TYPE_SHA256
)
8903 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8913 else if (hash_type
== HASH_TYPE_SHA384
)
8915 uint
*ptr
= digest_buf
;
8917 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8925 else if (hash_type
== HASH_TYPE_SHA512
)
8927 uint
*ptr
= digest_buf
;
8929 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8939 else if (hash_type
== HASH_TYPE_LM
)
8941 snprintf (out_buf
, len
-1, "%08x%08x",
8945 else if (hash_type
== HASH_TYPE_ORACLEH
)
8947 snprintf (out_buf
, len
-1, "%08X%08X",
8951 else if (hash_type
== HASH_TYPE_BCRYPT
)
8953 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8954 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8956 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8958 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8960 else if (hash_type
== HASH_TYPE_KECCAK
)
8962 uint
*ptr
= digest_buf
;
8964 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",
8992 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8994 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8996 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
9003 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
9005 digest_buf
[ 0] = digest_buf
[ 0];
9006 digest_buf
[ 1] = digest_buf
[ 1];
9007 digest_buf
[ 2] = digest_buf
[ 2];
9008 digest_buf
[ 3] = digest_buf
[ 3];
9009 digest_buf
[ 4] = digest_buf
[ 4];
9010 digest_buf
[ 5] = digest_buf
[ 5];
9011 digest_buf
[ 6] = digest_buf
[ 6];
9012 digest_buf
[ 7] = digest_buf
[ 7];
9013 digest_buf
[ 8] = digest_buf
[ 8];
9014 digest_buf
[ 9] = digest_buf
[ 9];
9015 digest_buf
[10] = digest_buf
[10];
9016 digest_buf
[11] = digest_buf
[11];
9017 digest_buf
[12] = digest_buf
[12];
9018 digest_buf
[13] = digest_buf
[13];
9019 digest_buf
[14] = digest_buf
[14];
9020 digest_buf
[15] = digest_buf
[15];
9022 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
9040 else if (hash_type
== HASH_TYPE_GOST
)
9042 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
9052 else if (hash_type
== HASH_TYPE_MYSQL
)
9054 snprintf (out_buf
, len
-1, "%08x%08x",
9058 else if (hash_type
== HASH_TYPE_LOTUS5
)
9060 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
9066 else if (hash_type
== HASH_TYPE_LOTUS6
)
9068 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
9069 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
9070 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
9071 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
9073 char buf
[16] = { 0 };
9075 memcpy (buf
+ 0, salt
.salt_buf
, 5);
9076 memcpy (buf
+ 5, digest_buf
, 9);
9080 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
9082 tmp_buf
[18] = salt
.salt_buf_pc
[7];
9085 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
9087 else if (hash_type
== HASH_TYPE_LOTUS8
)
9089 char buf
[52] = { 0 };
9093 memcpy (buf
+ 0, salt
.salt_buf
, 16);
9099 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
9103 buf
[26] = salt
.salt_buf_pc
[0];
9104 buf
[27] = salt
.salt_buf_pc
[1];
9108 memcpy (buf
+ 28, digest_buf
, 8);
9110 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9114 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9116 else if (hash_type
== HASH_TYPE_CRC32
)
9118 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9122 if (salt_type
== SALT_TYPE_INTERN
)
9124 size_t pos
= strlen (out_buf
);
9126 out_buf
[pos
] = data
.separator
;
9128 char *ptr
= (char *) salt
.salt_buf
;
9130 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9132 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9136 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9138 memset (hccap
, 0, sizeof (hccap_t
));
9140 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9142 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9144 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9145 wpa_t
*wpa
= &wpas
[salt_pos
];
9147 hccap
->keyver
= wpa
->keyver
;
9149 hccap
->eapol_size
= wpa
->eapol_size
;
9151 if (wpa
->keyver
!= 1)
9153 uint eapol_tmp
[64] = { 0 };
9155 for (uint i
= 0; i
< 64; i
++)
9157 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9160 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9164 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9167 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9168 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9169 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9170 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9172 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9174 uint dgst_size
= data
.dgst_size
;
9176 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9178 if (wpa
->keyver
!= 1)
9180 uint digest_tmp
[4] = { 0 };
9182 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9183 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9184 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9185 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9187 memcpy (hccap
->keymic
, digest_tmp
, 16);
9191 memcpy (hccap
->keymic
, digest_ptr
, 16);
9195 void SuspendThreads ()
9197 if (data
.devices_status
!= STATUS_RUNNING
) return;
9199 hc_timer_set (&data
.timer_paused
);
9201 data
.devices_status
= STATUS_PAUSED
;
9203 log_info ("Paused");
9206 void ResumeThreads ()
9208 if (data
.devices_status
!= STATUS_PAUSED
) return;
9212 hc_timer_get (data
.timer_paused
, ms_paused
);
9214 data
.ms_paused
+= ms_paused
;
9216 data
.devices_status
= STATUS_RUNNING
;
9218 log_info ("Resumed");
9223 data
.devices_status
= STATUS_BYPASS
;
9225 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9228 void stop_at_checkpoint ()
9230 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9232 if (data
.devices_status
!= STATUS_RUNNING
) return;
9235 // this feature only makes sense if --restore-disable was not specified
9237 if (data
.restore_disable
== 1)
9239 log_info ("WARNING: This feature is disabled when --restore-disable is specified");
9244 // check if monitoring of Restore Point updates should be enabled or disabled
9246 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9248 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9250 // save the current restore point value
9252 data
.checkpoint_cur_words
= get_lowest_words_done ();
9254 log_info ("Checkpoint enabled: Will quit at next Restore Point update");
9258 data
.devices_status
= STATUS_RUNNING
;
9260 // reset the global value for checkpoint checks
9262 data
.checkpoint_cur_words
= 0;
9264 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9270 data
.devices_status
= STATUS_ABORTED
;
9275 data
.devices_status
= STATUS_QUIT
;
9278 void naive_replace (char *s
, const u8 key_char
, const u8 replace_char
)
9280 const size_t len
= strlen (s
);
9282 for (size_t in
= 0; in
< len
; in
++)
9288 s
[in
] = replace_char
;
9293 void naive_escape (char *s
, size_t s_max
, const u8 key_char
, const u8 escape_char
)
9295 char s_escaped
[1024] = { 0 };
9297 size_t s_escaped_max
= sizeof (s_escaped
);
9299 const size_t len
= strlen (s
);
9301 for (size_t in
= 0, out
= 0; in
< len
; in
++, out
++)
9307 s_escaped
[out
] = escape_char
;
9312 if (out
== s_escaped_max
- 2) break;
9317 strncpy (s
, s_escaped
, s_max
- 1);
9320 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9322 FILE *fp
= fopen (kernel_file
, "rb");
9328 memset (&st
, 0, sizeof (st
));
9330 stat (kernel_file
, &st
);
9332 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9334 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9336 if (num_read
!= (size_t) st
.st_size
)
9338 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9345 buf
[st
.st_size
] = 0;
9347 for (int i
= 0; i
< num_devices
; i
++)
9349 kernel_lengths
[i
] = (size_t) st
.st_size
;
9351 kernel_sources
[i
] = buf
;
9356 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9364 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9366 if (binary_size
> 0)
9368 FILE *fp
= fopen (dst
, "wb");
9371 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9382 restore_data_t
*init_restore (int argc
, char **argv
)
9384 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9386 if (data
.restore_disable
== 0)
9388 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9392 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9396 log_error ("ERROR: Cannot read %s", data
.eff_restore_file
);
9405 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9407 int pidbin_len
= -1;
9410 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9412 FILE *fd
= fopen (pidbin
, "rb");
9416 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9418 pidbin
[pidbin_len
] = 0;
9422 char *argv0_r
= strrchr (argv
[0], '/');
9424 char *pidbin_r
= strrchr (pidbin
, '/');
9426 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9428 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9430 if (strcmp (argv0_r
, pidbin_r
) == 0)
9432 log_error ("ERROR: Already an instance %s running on pid %d", pidbin
, rd
->pid
);
9439 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9441 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9443 int pidbin2_len
= -1;
9445 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9446 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9448 pidbin
[pidbin_len
] = 0;
9449 pidbin2
[pidbin2_len
] = 0;
9453 if (strcmp (pidbin
, pidbin2
) == 0)
9455 log_error ("ERROR: Already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9468 if (rd
->version_bin
< RESTORE_MIN
)
9470 log_error ("ERROR: Cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9477 memset (rd
, 0, sizeof (restore_data_t
));
9479 rd
->version_bin
= VERSION_BIN
;
9482 rd
->pid
= getpid ();
9484 rd
->pid
= GetCurrentProcessId ();
9487 if (getcwd (rd
->cwd
, 255) == NULL
)
9500 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9502 FILE *fp
= fopen (eff_restore_file
, "rb");
9506 log_error ("ERROR: Restore file '%s': %s", eff_restore_file
, strerror (errno
));
9511 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9513 log_error ("ERROR: Can't read %s", eff_restore_file
);
9518 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9520 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9522 for (uint i
= 0; i
< rd
->argc
; i
++)
9524 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9526 log_error ("ERROR: Can't read %s", eff_restore_file
);
9531 size_t len
= strlen (buf
);
9533 if (len
) buf
[len
- 1] = 0;
9535 rd
->argv
[i
] = mystrdup (buf
);
9542 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9544 if (chdir (rd
->cwd
))
9546 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9547 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9548 " https://github.com/philsmd/analyze_hc_restore\n"
9549 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9555 u64
get_lowest_words_done ()
9559 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9561 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9563 if (device_param
->skipped
) continue;
9565 const u64 words_done
= device_param
->words_done
;
9567 if (words_done
< words_cur
) words_cur
= words_done
;
9570 // It's possible that a device's workload isn't finished right after a restore-case.
9571 // In that case, this function would return 0 and overwrite the real restore point
9572 // There's also data.words_cur which is set to rd->words_cur but it changes while
9573 // the attack is running therefore we should stick to rd->words_cur.
9574 // Note that -s influences rd->words_cur we should keep a close look on that.
9576 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9581 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9583 u64 words_cur
= get_lowest_words_done ();
9585 rd
->words_cur
= words_cur
;
9587 FILE *fp
= fopen (new_restore_file
, "wb");
9591 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9596 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9598 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9603 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9605 for (uint i
= 0; i
< rd
->argc
; i
++)
9607 fprintf (fp
, "%s", rd
->argv
[i
]);
9613 fsync (fileno (fp
));
9618 void cycle_restore ()
9620 const char *eff_restore_file
= data
.eff_restore_file
;
9621 const char *new_restore_file
= data
.new_restore_file
;
9623 restore_data_t
*rd
= data
.rd
;
9625 write_restore (new_restore_file
, rd
);
9629 memset (&st
, 0, sizeof(st
));
9631 if (stat (eff_restore_file
, &st
) == 0)
9633 if (unlink (eff_restore_file
))
9635 log_info ("WARN: Unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9639 if (rename (new_restore_file
, eff_restore_file
))
9641 log_info ("WARN: Rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9645 void check_checkpoint ()
9647 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9649 u64 words_cur
= get_lowest_words_done ();
9651 if (words_cur
!= data
.checkpoint_cur_words
)
9661 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9665 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9667 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9669 myfree (alias
->device_name
);
9670 myfree (alias
->alias_name
);
9673 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9675 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9677 myfree (entry
->device_name
);
9680 myfree (tuning_db
->alias_buf
);
9681 myfree (tuning_db
->entry_buf
);
9686 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9688 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9690 int num_lines
= count_lines (fp
);
9692 // a bit over-allocated
9694 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9695 tuning_db
->alias_cnt
= 0;
9697 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9698 tuning_db
->entry_cnt
= 0;
9703 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9705 FILE *fp
= fopen (tuning_db_file
, "rb");
9709 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9714 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9720 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9724 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9726 if (line_buf
== NULL
) break;
9730 const int line_len
= in_superchop (line_buf
);
9732 if (line_len
== 0) continue;
9734 if (line_buf
[0] == '#') continue;
9738 char *token_ptr
[7] = { NULL
};
9742 char *next
= strtok (line_buf
, "\t ");
9744 token_ptr
[token_cnt
] = next
;
9748 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9750 token_ptr
[token_cnt
] = next
;
9757 char *device_name
= token_ptr
[0];
9758 char *alias_name
= token_ptr
[1];
9760 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9762 alias
->device_name
= mystrdup (device_name
);
9763 alias
->alias_name
= mystrdup (alias_name
);
9765 tuning_db
->alias_cnt
++;
9767 else if (token_cnt
== 6)
9769 if ((token_ptr
[1][0] != '0') &&
9770 (token_ptr
[1][0] != '1') &&
9771 (token_ptr
[1][0] != '3') &&
9772 (token_ptr
[1][0] != '*'))
9774 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9779 if ((token_ptr
[3][0] != '1') &&
9780 (token_ptr
[3][0] != '2') &&
9781 (token_ptr
[3][0] != '4') &&
9782 (token_ptr
[3][0] != '8') &&
9783 (token_ptr
[3][0] != 'N'))
9785 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9790 char *device_name
= token_ptr
[0];
9792 int attack_mode
= -1;
9794 int vector_width
= -1;
9795 int kernel_accel
= -1;
9796 int kernel_loops
= -1;
9798 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9799 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9800 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9802 if (token_ptr
[4][0] != 'A')
9804 kernel_accel
= atoi (token_ptr
[4]);
9806 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9808 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9818 if (token_ptr
[5][0] != 'A')
9820 kernel_loops
= atoi (token_ptr
[5]);
9822 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9824 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9834 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9836 entry
->device_name
= mystrdup (device_name
);
9837 entry
->attack_mode
= attack_mode
;
9838 entry
->hash_type
= hash_type
;
9839 entry
->vector_width
= vector_width
;
9840 entry
->kernel_accel
= kernel_accel
;
9841 entry
->kernel_loops
= kernel_loops
;
9843 tuning_db
->entry_cnt
++;
9847 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9857 // todo: print loaded 'cnt' message
9859 // sort the database
9861 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9862 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9867 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9869 static tuning_db_entry_t s
;
9871 // first we need to convert all spaces in the device_name to underscore
9873 char *device_name_nospace
= strdup (device_param
->device_name
);
9875 int device_name_length
= strlen (device_name_nospace
);
9879 for (i
= 0; i
< device_name_length
; i
++)
9881 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9884 // find out if there's an alias configured
9886 tuning_db_alias_t a
;
9888 a
.device_name
= device_name_nospace
;
9890 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
);
9892 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9894 // attack-mode 6 and 7 are attack-mode 1 basically
9896 if (attack_mode
== 6) attack_mode
= 1;
9897 if (attack_mode
== 7) attack_mode
= 1;
9899 // bsearch is not ideal but fast enough
9901 s
.device_name
= device_name_nospace
;
9902 s
.attack_mode
= attack_mode
;
9903 s
.hash_type
= hash_type
;
9905 tuning_db_entry_t
*entry
= NULL
;
9907 // this will produce all 2^3 combinations required
9909 for (i
= 0; i
< 8; i
++)
9911 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9912 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9913 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9915 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9917 if (entry
!= NULL
) break;
9919 // in non-wildcard mode do some additional checks:
9923 // in case we have an alias-name
9925 if (alias_name
!= NULL
)
9927 s
.device_name
= alias_name
;
9929 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9931 if (entry
!= NULL
) break;
9934 // or by device type
9936 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9938 s
.device_name
= "DEVICE_TYPE_CPU";
9940 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9942 s
.device_name
= "DEVICE_TYPE_GPU";
9944 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9946 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9949 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9951 if (entry
!= NULL
) break;
9955 // free converted device_name
9957 myfree (device_name_nospace
);
9966 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9968 u8 tmp
[256] = { 0 };
9970 if (salt_len
> sizeof (tmp
))
9975 memcpy (tmp
, in
, salt_len
);
9977 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9979 if ((salt_len
% 2) == 0)
9981 u32 new_salt_len
= salt_len
/ 2;
9983 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9988 tmp
[i
] = hex_convert (p1
) << 0;
9989 tmp
[i
] |= hex_convert (p0
) << 4;
9992 salt_len
= new_salt_len
;
9999 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
10001 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
10004 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
10006 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
10010 u32
*tmp_uint
= (u32
*) tmp
;
10012 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
10013 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
10014 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
10015 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
10016 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
10017 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
10018 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
10019 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
10020 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
10021 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
10023 salt_len
= salt_len
* 2;
10031 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
10033 lowercase (tmp
, salt_len
);
10036 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
10038 uppercase (tmp
, salt_len
);
10041 u32 len
= salt_len
;
10043 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
10048 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
10053 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
10055 u32
*tmp_uint
= (uint
*) tmp
;
10059 if (len
% 4) max
++;
10061 for (u32 i
= 0; i
< max
; i
++)
10063 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
10066 // Important: we may need to increase the length of memcpy since
10067 // we don't want to "loose" some swapped bytes (could happen if
10068 // they do not perfectly fit in the 4-byte blocks)
10069 // Memcpy does always copy the bytes in the BE order, but since
10070 // we swapped them, some important bytes could be in positions
10071 // we normally skip with the original len
10073 if (len
% 4) len
+= 4 - (len
% 4);
10076 memcpy (out
, tmp
, len
);
10081 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10083 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
10085 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
10087 u32
*digest
= (u32
*) hash_buf
->digest
;
10089 salt_t
*salt
= hash_buf
->salt
;
10091 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
10093 char *iter_pos
= input_buf
+ 4;
10095 salt
->salt_iter
= 1 << atoi (iter_pos
);
10097 char *salt_pos
= strchr (iter_pos
, '$');
10099 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10103 uint salt_len
= 16;
10105 salt
->salt_len
= salt_len
;
10107 u8 tmp_buf
[100] = { 0 };
10109 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
10111 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10113 memcpy (salt_buf_ptr
, tmp_buf
, 16);
10115 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
10116 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
10117 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
10118 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
10120 char *hash_pos
= salt_pos
+ 22;
10122 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10124 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
10126 memcpy (digest
, tmp_buf
, 24);
10128 digest
[0] = byte_swap_32 (digest
[0]);
10129 digest
[1] = byte_swap_32 (digest
[1]);
10130 digest
[2] = byte_swap_32 (digest
[2]);
10131 digest
[3] = byte_swap_32 (digest
[3]);
10132 digest
[4] = byte_swap_32 (digest
[4]);
10133 digest
[5] = byte_swap_32 (digest
[5]);
10135 digest
[5] &= ~0xff; // its just 23 not 24 !
10137 return (PARSER_OK
);
10140 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10142 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10144 u32
*digest
= (u32
*) hash_buf
->digest
;
10146 u8 tmp_buf
[100] = { 0 };
10148 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10150 memcpy (digest
, tmp_buf
, 32);
10152 digest
[0] = byte_swap_32 (digest
[0]);
10153 digest
[1] = byte_swap_32 (digest
[1]);
10154 digest
[2] = byte_swap_32 (digest
[2]);
10155 digest
[3] = byte_swap_32 (digest
[3]);
10156 digest
[4] = byte_swap_32 (digest
[4]);
10157 digest
[5] = byte_swap_32 (digest
[5]);
10158 digest
[6] = byte_swap_32 (digest
[6]);
10159 digest
[7] = byte_swap_32 (digest
[7]);
10161 digest
[0] -= SHA256M_A
;
10162 digest
[1] -= SHA256M_B
;
10163 digest
[2] -= SHA256M_C
;
10164 digest
[3] -= SHA256M_D
;
10165 digest
[4] -= SHA256M_E
;
10166 digest
[5] -= SHA256M_F
;
10167 digest
[6] -= SHA256M_G
;
10168 digest
[7] -= SHA256M_H
;
10170 return (PARSER_OK
);
10173 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10175 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10177 u32
*digest
= (u32
*) hash_buf
->digest
;
10179 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10180 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10182 digest
[0] = byte_swap_32 (digest
[0]);
10183 digest
[1] = byte_swap_32 (digest
[1]);
10187 IP (digest
[0], digest
[1], tt
);
10189 digest
[0] = digest
[0];
10190 digest
[1] = digest
[1];
10194 return (PARSER_OK
);
10197 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10199 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10201 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10203 u32
*digest
= (u32
*) hash_buf
->digest
;
10205 salt_t
*salt
= hash_buf
->salt
;
10207 char *hash_pos
= input_buf
+ 10;
10209 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10210 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10211 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10212 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10213 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10215 digest
[0] -= SHA1M_A
;
10216 digest
[1] -= SHA1M_B
;
10217 digest
[2] -= SHA1M_C
;
10218 digest
[3] -= SHA1M_D
;
10219 digest
[4] -= SHA1M_E
;
10221 uint salt_len
= 10;
10223 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10225 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10227 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10229 salt
->salt_len
= salt_len
;
10231 return (PARSER_OK
);
10234 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10236 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10238 u32
*digest
= (u32
*) hash_buf
->digest
;
10240 salt_t
*salt
= hash_buf
->salt
;
10242 char *hash_pos
= input_buf
+ 8;
10244 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10245 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10246 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10247 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10248 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10250 digest
[0] -= SHA1M_A
;
10251 digest
[1] -= SHA1M_B
;
10252 digest
[2] -= SHA1M_C
;
10253 digest
[3] -= SHA1M_D
;
10254 digest
[4] -= SHA1M_E
;
10258 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10260 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10262 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10264 salt
->salt_len
= salt_len
;
10266 return (PARSER_OK
);
10269 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10271 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10273 u64
*digest
= (u64
*) hash_buf
->digest
;
10275 salt_t
*salt
= hash_buf
->salt
;
10277 char *hash_pos
= input_buf
+ 8;
10279 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10280 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10281 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10282 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10283 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10284 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10285 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10286 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10288 digest
[0] -= SHA512M_A
;
10289 digest
[1] -= SHA512M_B
;
10290 digest
[2] -= SHA512M_C
;
10291 digest
[3] -= SHA512M_D
;
10292 digest
[4] -= SHA512M_E
;
10293 digest
[5] -= SHA512M_F
;
10294 digest
[6] -= SHA512M_G
;
10295 digest
[7] -= SHA512M_H
;
10299 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10301 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10303 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10305 salt
->salt_len
= salt_len
;
10307 return (PARSER_OK
);
10310 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10312 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10314 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10318 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10321 u32
*digest
= (u32
*) hash_buf
->digest
;
10323 salt_t
*salt
= hash_buf
->salt
;
10325 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10326 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10327 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10328 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10330 digest
[0] = byte_swap_32 (digest
[0]);
10331 digest
[1] = byte_swap_32 (digest
[1]);
10332 digest
[2] = byte_swap_32 (digest
[2]);
10333 digest
[3] = byte_swap_32 (digest
[3]);
10335 digest
[0] -= MD5M_A
;
10336 digest
[1] -= MD5M_B
;
10337 digest
[2] -= MD5M_C
;
10338 digest
[3] -= MD5M_D
;
10340 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10342 uint salt_len
= input_len
- 32 - 1;
10344 char *salt_buf
= input_buf
+ 32 + 1;
10346 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10348 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10350 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10352 salt
->salt_len
= salt_len
;
10354 return (PARSER_OK
);
10357 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10359 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10361 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10365 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10370 char clean_input_buf
[32] = { 0 };
10372 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10373 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10375 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10379 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10385 clean_input_buf
[k
] = input_buf
[i
];
10393 u32
*digest
= (u32
*) hash_buf
->digest
;
10395 salt_t
*salt
= hash_buf
->salt
;
10397 u32 a
, b
, c
, d
, e
, f
;
10399 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10400 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10401 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10402 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10403 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10404 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10406 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10407 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10409 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10410 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10411 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10412 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10413 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10414 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10416 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10417 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10419 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10420 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10421 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10422 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10423 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10424 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10426 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10427 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10429 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10430 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10431 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10432 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10433 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10434 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10436 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10437 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10439 digest
[0] = byte_swap_32 (digest
[0]);
10440 digest
[1] = byte_swap_32 (digest
[1]);
10441 digest
[2] = byte_swap_32 (digest
[2]);
10442 digest
[3] = byte_swap_32 (digest
[3]);
10444 digest
[0] -= MD5M_A
;
10445 digest
[1] -= MD5M_B
;
10446 digest
[2] -= MD5M_C
;
10447 digest
[3] -= MD5M_D
;
10449 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10451 uint salt_len
= input_len
- 30 - 1;
10453 char *salt_buf
= input_buf
+ 30 + 1;
10455 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10457 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10459 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10460 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10462 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10464 salt
->salt_len
= salt_len
;
10466 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10468 salt
->salt_len
+= 22;
10470 return (PARSER_OK
);
10473 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10475 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10477 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10481 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10484 u32
*digest
= (u32
*) hash_buf
->digest
;
10486 salt_t
*salt
= hash_buf
->salt
;
10488 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10489 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10490 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10491 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10492 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10494 digest
[0] -= SHA1M_A
;
10495 digest
[1] -= SHA1M_B
;
10496 digest
[2] -= SHA1M_C
;
10497 digest
[3] -= SHA1M_D
;
10498 digest
[4] -= SHA1M_E
;
10500 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10502 uint salt_len
= input_len
- 40 - 1;
10504 char *salt_buf
= input_buf
+ 40 + 1;
10506 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10508 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10510 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10512 salt
->salt_len
= salt_len
;
10514 return (PARSER_OK
);
10517 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10519 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10521 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10525 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10528 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10530 char *iter_pos
= input_buf
+ 6;
10532 salt_t
*salt
= hash_buf
->salt
;
10534 uint iter
= atoi (iter_pos
);
10538 iter
= ROUNDS_DCC2
;
10541 salt
->salt_iter
= iter
- 1;
10543 char *salt_pos
= strchr (iter_pos
, '#');
10545 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10549 char *digest_pos
= strchr (salt_pos
, '#');
10551 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10555 uint salt_len
= digest_pos
- salt_pos
- 1;
10557 u32
*digest
= (u32
*) hash_buf
->digest
;
10559 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10560 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10561 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10562 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10564 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10566 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10568 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10570 salt
->salt_len
= salt_len
;
10572 return (PARSER_OK
);
10575 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10577 u32
*digest
= (u32
*) hash_buf
->digest
;
10579 salt_t
*salt
= hash_buf
->salt
;
10581 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10585 memcpy (&in
, input_buf
, input_len
);
10587 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10589 memcpy (digest
, in
.keymic
, 16);
10592 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10593 The phrase "Pairwise key expansion"
10594 Access Point Address (referred to as Authenticator Address AA)
10595 Supplicant Address (referred to as Supplicant Address SA)
10596 Access Point Nonce (referred to as Authenticator Anonce)
10597 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10600 uint salt_len
= strlen (in
.essid
);
10604 log_info ("WARNING: The ESSID length is too long, the hccap file may be invalid or corrupted");
10606 return (PARSER_SALT_LENGTH
);
10609 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10611 salt
->salt_len
= salt_len
;
10613 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10615 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10617 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10619 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10621 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10622 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10626 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10627 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10630 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10632 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10633 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10637 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10638 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10641 for (int i
= 0; i
< 25; i
++)
10643 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10646 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10647 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10648 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10649 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10651 wpa
->keyver
= in
.keyver
;
10653 if (wpa
->keyver
> 255)
10655 log_info ("ATTENTION!");
10656 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10657 log_info (" This could be due to a recent aircrack-ng bug.");
10658 log_info (" The key version was automatically reset to a reasonable value.");
10661 wpa
->keyver
&= 0xff;
10664 wpa
->eapol_size
= in
.eapol_size
;
10666 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10668 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10670 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10672 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10674 if (wpa
->keyver
== 1)
10680 digest
[0] = byte_swap_32 (digest
[0]);
10681 digest
[1] = byte_swap_32 (digest
[1]);
10682 digest
[2] = byte_swap_32 (digest
[2]);
10683 digest
[3] = byte_swap_32 (digest
[3]);
10685 for (int i
= 0; i
< 64; i
++)
10687 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10691 uint32_t *p0
= (uint32_t *) in
.essid
;
10695 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10696 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10698 salt
->salt_buf
[10] = c0
;
10699 salt
->salt_buf
[11] = c1
;
10701 return (PARSER_OK
);
10704 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10706 u32
*digest
= (u32
*) hash_buf
->digest
;
10708 salt_t
*salt
= hash_buf
->salt
;
10710 if (input_len
== 0)
10712 log_error ("Password Safe v2 container not specified");
10717 FILE *fp
= fopen (input_buf
, "rb");
10721 log_error ("%s: %s", input_buf
, strerror (errno
));
10728 memset (&buf
, 0, sizeof (psafe2_hdr
));
10730 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10734 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10736 salt
->salt_buf
[0] = buf
.random
[0];
10737 salt
->salt_buf
[1] = buf
.random
[1];
10739 salt
->salt_len
= 8;
10740 salt
->salt_iter
= 1000;
10742 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10743 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10744 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10745 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10746 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10748 return (PARSER_OK
);
10751 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10753 u32
*digest
= (u32
*) hash_buf
->digest
;
10755 salt_t
*salt
= hash_buf
->salt
;
10757 if (input_len
== 0)
10759 log_error (".psafe3 not specified");
10764 FILE *fp
= fopen (input_buf
, "rb");
10768 log_error ("%s: %s", input_buf
, strerror (errno
));
10775 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10779 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10781 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10783 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10785 salt
->salt_iter
= in
.iterations
+ 1;
10787 salt
->salt_buf
[0] = in
.salt_buf
[0];
10788 salt
->salt_buf
[1] = in
.salt_buf
[1];
10789 salt
->salt_buf
[2] = in
.salt_buf
[2];
10790 salt
->salt_buf
[3] = in
.salt_buf
[3];
10791 salt
->salt_buf
[4] = in
.salt_buf
[4];
10792 salt
->salt_buf
[5] = in
.salt_buf
[5];
10793 salt
->salt_buf
[6] = in
.salt_buf
[6];
10794 salt
->salt_buf
[7] = in
.salt_buf
[7];
10796 salt
->salt_len
= 32;
10798 digest
[0] = in
.hash_buf
[0];
10799 digest
[1] = in
.hash_buf
[1];
10800 digest
[2] = in
.hash_buf
[2];
10801 digest
[3] = in
.hash_buf
[3];
10802 digest
[4] = in
.hash_buf
[4];
10803 digest
[5] = in
.hash_buf
[5];
10804 digest
[6] = in
.hash_buf
[6];
10805 digest
[7] = in
.hash_buf
[7];
10807 digest
[0] = byte_swap_32 (digest
[0]);
10808 digest
[1] = byte_swap_32 (digest
[1]);
10809 digest
[2] = byte_swap_32 (digest
[2]);
10810 digest
[3] = byte_swap_32 (digest
[3]);
10811 digest
[4] = byte_swap_32 (digest
[4]);
10812 digest
[5] = byte_swap_32 (digest
[5]);
10813 digest
[6] = byte_swap_32 (digest
[6]);
10814 digest
[7] = byte_swap_32 (digest
[7]);
10816 return (PARSER_OK
);
10819 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10821 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10823 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10825 u32
*digest
= (u32
*) hash_buf
->digest
;
10827 salt_t
*salt
= hash_buf
->salt
;
10829 char *iter_pos
= input_buf
+ 3;
10831 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10833 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10835 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10837 salt
->salt_iter
= salt_iter
;
10839 char *salt_pos
= iter_pos
+ 1;
10843 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10845 salt
->salt_len
= salt_len
;
10847 char *hash_pos
= salt_pos
+ salt_len
;
10849 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10851 return (PARSER_OK
);
10854 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10856 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10858 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10860 u32
*digest
= (u32
*) hash_buf
->digest
;
10862 salt_t
*salt
= hash_buf
->salt
;
10864 char *salt_pos
= input_buf
+ 3;
10866 uint iterations_len
= 0;
10868 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10872 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10874 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10875 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10879 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10883 iterations_len
+= 8;
10887 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10890 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10892 char *hash_pos
= strchr (salt_pos
, '$');
10894 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10896 uint salt_len
= hash_pos
- salt_pos
;
10898 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10900 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10902 salt
->salt_len
= salt_len
;
10906 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10908 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10910 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10912 return (PARSER_OK
);
10915 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10917 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10919 u32
*digest
= (u32
*) hash_buf
->digest
;
10921 salt_t
*salt
= hash_buf
->salt
;
10923 char *salt_pos
= input_buf
+ 6;
10925 uint iterations_len
= 0;
10927 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10931 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10933 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10934 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10938 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10942 iterations_len
+= 8;
10946 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10949 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10951 char *hash_pos
= strchr (salt_pos
, '$');
10953 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10955 uint salt_len
= hash_pos
- salt_pos
;
10957 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10959 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10961 salt
->salt_len
= salt_len
;
10965 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10967 return (PARSER_OK
);
10970 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10972 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10974 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10976 u32
*digest
= (u32
*) hash_buf
->digest
;
10978 salt_t
*salt
= hash_buf
->salt
;
10980 char *salt_pos
= input_buf
+ 14;
10982 char *hash_pos
= strchr (salt_pos
, '*');
10984 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10988 uint salt_len
= hash_pos
- salt_pos
- 1;
10990 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10992 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10994 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10996 salt
->salt_len
= salt_len
;
10998 u8 tmp_buf
[100] = { 0 };
11000 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
11002 memcpy (digest
, tmp_buf
, 20);
11004 digest
[0] = byte_swap_32 (digest
[0]);
11005 digest
[1] = byte_swap_32 (digest
[1]);
11006 digest
[2] = byte_swap_32 (digest
[2]);
11007 digest
[3] = byte_swap_32 (digest
[3]);
11008 digest
[4] = byte_swap_32 (digest
[4]);
11010 digest
[0] -= SHA1M_A
;
11011 digest
[1] -= SHA1M_B
;
11012 digest
[2] -= SHA1M_C
;
11013 digest
[3] -= SHA1M_D
;
11014 digest
[4] -= SHA1M_E
;
11016 return (PARSER_OK
);
11019 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11021 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
11023 unsigned char c12
= itoa64_to_int (input_buf
[12]);
11025 if (c12
& 3) return (PARSER_HASH_VALUE
);
11027 u32
*digest
= (u32
*) hash_buf
->digest
;
11029 salt_t
*salt
= hash_buf
->salt
;
11031 // for ascii_digest
11032 salt
->salt_sign
[0] = input_buf
[0];
11033 salt
->salt_sign
[1] = input_buf
[1];
11035 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
11036 | itoa64_to_int (input_buf
[1]) << 6;
11038 salt
->salt_len
= 2;
11040 u8 tmp_buf
[100] = { 0 };
11042 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
11044 memcpy (digest
, tmp_buf
, 8);
11048 IP (digest
[0], digest
[1], tt
);
11053 return (PARSER_OK
);
11056 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11058 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
11060 u32
*digest
= (u32
*) hash_buf
->digest
;
11062 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11063 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11064 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11065 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11067 digest
[0] = byte_swap_32 (digest
[0]);
11068 digest
[1] = byte_swap_32 (digest
[1]);
11069 digest
[2] = byte_swap_32 (digest
[2]);
11070 digest
[3] = byte_swap_32 (digest
[3]);
11072 digest
[0] -= MD4M_A
;
11073 digest
[1] -= MD4M_B
;
11074 digest
[2] -= MD4M_C
;
11075 digest
[3] -= MD4M_D
;
11077 return (PARSER_OK
);
11080 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11082 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11084 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
11088 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
11091 u32
*digest
= (u32
*) hash_buf
->digest
;
11093 salt_t
*salt
= hash_buf
->salt
;
11095 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11096 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11097 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11098 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11100 digest
[0] = byte_swap_32 (digest
[0]);
11101 digest
[1] = byte_swap_32 (digest
[1]);
11102 digest
[2] = byte_swap_32 (digest
[2]);
11103 digest
[3] = byte_swap_32 (digest
[3]);
11105 digest
[0] -= MD4M_A
;
11106 digest
[1] -= MD4M_B
;
11107 digest
[2] -= MD4M_C
;
11108 digest
[3] -= MD4M_D
;
11110 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11112 uint salt_len
= input_len
- 32 - 1;
11114 char *salt_buf
= input_buf
+ 32 + 1;
11116 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11118 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11120 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11122 salt
->salt_len
= salt_len
;
11124 return (PARSER_OK
);
11127 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11129 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
11131 u32
*digest
= (u32
*) hash_buf
->digest
;
11133 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11134 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11135 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11136 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11138 digest
[0] = byte_swap_32 (digest
[0]);
11139 digest
[1] = byte_swap_32 (digest
[1]);
11140 digest
[2] = byte_swap_32 (digest
[2]);
11141 digest
[3] = byte_swap_32 (digest
[3]);
11143 digest
[0] -= MD5M_A
;
11144 digest
[1] -= MD5M_B
;
11145 digest
[2] -= MD5M_C
;
11146 digest
[3] -= MD5M_D
;
11148 return (PARSER_OK
);
11151 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11153 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11155 u32
*digest
= (u32
*) hash_buf
->digest
;
11157 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11158 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11162 digest
[0] = byte_swap_32 (digest
[0]);
11163 digest
[1] = byte_swap_32 (digest
[1]);
11165 return (PARSER_OK
);
11168 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11170 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11172 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11176 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11179 u32
*digest
= (u32
*) hash_buf
->digest
;
11181 salt_t
*salt
= hash_buf
->salt
;
11183 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11184 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11185 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11186 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11188 digest
[0] = byte_swap_32 (digest
[0]);
11189 digest
[1] = byte_swap_32 (digest
[1]);
11190 digest
[2] = byte_swap_32 (digest
[2]);
11191 digest
[3] = byte_swap_32 (digest
[3]);
11193 digest
[0] -= MD5M_A
;
11194 digest
[1] -= MD5M_B
;
11195 digest
[2] -= MD5M_C
;
11196 digest
[3] -= MD5M_D
;
11198 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11200 uint salt_len
= input_len
- 32 - 1;
11202 char *salt_buf
= input_buf
+ 32 + 1;
11204 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11206 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11208 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11210 salt
->salt_len
= salt_len
;
11212 return (PARSER_OK
);
11215 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11217 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11219 u32
*digest
= (u32
*) hash_buf
->digest
;
11221 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11222 | itoa64_to_int (input_buf
[ 1]) << 6
11223 | itoa64_to_int (input_buf
[ 2]) << 12
11224 | itoa64_to_int (input_buf
[ 3]) << 18;
11225 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11226 | itoa64_to_int (input_buf
[ 5]) << 6
11227 | itoa64_to_int (input_buf
[ 6]) << 12
11228 | itoa64_to_int (input_buf
[ 7]) << 18;
11229 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11230 | itoa64_to_int (input_buf
[ 9]) << 6
11231 | itoa64_to_int (input_buf
[10]) << 12
11232 | itoa64_to_int (input_buf
[11]) << 18;
11233 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11234 | itoa64_to_int (input_buf
[13]) << 6
11235 | itoa64_to_int (input_buf
[14]) << 12
11236 | itoa64_to_int (input_buf
[15]) << 18;
11238 digest
[0] -= MD5M_A
;
11239 digest
[1] -= MD5M_B
;
11240 digest
[2] -= MD5M_C
;
11241 digest
[3] -= MD5M_D
;
11243 digest
[0] &= 0x00ffffff;
11244 digest
[1] &= 0x00ffffff;
11245 digest
[2] &= 0x00ffffff;
11246 digest
[3] &= 0x00ffffff;
11248 return (PARSER_OK
);
11251 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11253 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11255 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11259 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11262 u32
*digest
= (u32
*) hash_buf
->digest
;
11264 salt_t
*salt
= hash_buf
->salt
;
11266 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11267 | itoa64_to_int (input_buf
[ 1]) << 6
11268 | itoa64_to_int (input_buf
[ 2]) << 12
11269 | itoa64_to_int (input_buf
[ 3]) << 18;
11270 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11271 | itoa64_to_int (input_buf
[ 5]) << 6
11272 | itoa64_to_int (input_buf
[ 6]) << 12
11273 | itoa64_to_int (input_buf
[ 7]) << 18;
11274 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11275 | itoa64_to_int (input_buf
[ 9]) << 6
11276 | itoa64_to_int (input_buf
[10]) << 12
11277 | itoa64_to_int (input_buf
[11]) << 18;
11278 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11279 | itoa64_to_int (input_buf
[13]) << 6
11280 | itoa64_to_int (input_buf
[14]) << 12
11281 | itoa64_to_int (input_buf
[15]) << 18;
11283 digest
[0] -= MD5M_A
;
11284 digest
[1] -= MD5M_B
;
11285 digest
[2] -= MD5M_C
;
11286 digest
[3] -= MD5M_D
;
11288 digest
[0] &= 0x00ffffff;
11289 digest
[1] &= 0x00ffffff;
11290 digest
[2] &= 0x00ffffff;
11291 digest
[3] &= 0x00ffffff;
11293 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11295 uint salt_len
= input_len
- 16 - 1;
11297 char *salt_buf
= input_buf
+ 16 + 1;
11299 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11301 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11303 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11305 salt
->salt_len
= salt_len
;
11307 return (PARSER_OK
);
11310 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11312 key
[0] = (nthash
[0] >> 0);
11313 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11314 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11315 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11316 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11317 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11318 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11319 key
[7] = (nthash
[6] << 1);
11331 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11333 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11335 u32
*digest
= (u32
*) hash_buf
->digest
;
11337 salt_t
*salt
= hash_buf
->salt
;
11339 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11345 char *user_pos
= input_buf
;
11347 char *unused_pos
= strchr (user_pos
, ':');
11349 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11351 uint user_len
= unused_pos
- user_pos
;
11353 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11357 char *domain_pos
= strchr (unused_pos
, ':');
11359 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11361 uint unused_len
= domain_pos
- unused_pos
;
11363 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11367 char *srvchall_pos
= strchr (domain_pos
, ':');
11369 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11371 uint domain_len
= srvchall_pos
- domain_pos
;
11373 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11377 char *hash_pos
= strchr (srvchall_pos
, ':');
11379 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11381 uint srvchall_len
= hash_pos
- srvchall_pos
;
11383 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11387 char *clichall_pos
= strchr (hash_pos
, ':');
11389 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11391 uint hash_len
= clichall_pos
- hash_pos
;
11393 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11397 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11399 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11402 * store some data for later use
11405 netntlm
->user_len
= user_len
* 2;
11406 netntlm
->domain_len
= domain_len
* 2;
11407 netntlm
->srvchall_len
= srvchall_len
/ 2;
11408 netntlm
->clichall_len
= clichall_len
/ 2;
11410 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11411 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11414 * handle username and domainname
11417 for (uint i
= 0; i
< user_len
; i
++)
11419 *userdomain_ptr
++ = user_pos
[i
];
11420 *userdomain_ptr
++ = 0;
11423 for (uint i
= 0; i
< domain_len
; i
++)
11425 *userdomain_ptr
++ = domain_pos
[i
];
11426 *userdomain_ptr
++ = 0;
11430 * handle server challenge encoding
11433 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11435 const char p0
= srvchall_pos
[i
+ 0];
11436 const char p1
= srvchall_pos
[i
+ 1];
11438 *chall_ptr
++ = hex_convert (p1
) << 0
11439 | hex_convert (p0
) << 4;
11443 * handle client challenge encoding
11446 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11448 const char p0
= clichall_pos
[i
+ 0];
11449 const char p1
= clichall_pos
[i
+ 1];
11451 *chall_ptr
++ = hex_convert (p1
) << 0
11452 | hex_convert (p0
) << 4;
11459 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11461 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11463 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11465 salt
->salt_len
= salt_len
;
11467 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11468 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11469 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11470 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11472 digest
[0] = byte_swap_32 (digest
[0]);
11473 digest
[1] = byte_swap_32 (digest
[1]);
11474 digest
[2] = byte_swap_32 (digest
[2]);
11475 digest
[3] = byte_swap_32 (digest
[3]);
11477 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11479 uint digest_tmp
[2] = { 0 };
11481 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11482 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11484 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11485 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11487 /* special case 2: ESS */
11489 if (srvchall_len
== 48)
11491 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11493 uint w
[16] = { 0 };
11495 w
[ 0] = netntlm
->chall_buf
[6];
11496 w
[ 1] = netntlm
->chall_buf
[7];
11497 w
[ 2] = netntlm
->chall_buf
[0];
11498 w
[ 3] = netntlm
->chall_buf
[1];
11502 uint dgst
[4] = { 0 };
11511 salt
->salt_buf
[0] = dgst
[0];
11512 salt
->salt_buf
[1] = dgst
[1];
11516 /* precompute netntlmv1 exploit start */
11518 for (uint i
= 0; i
< 0x10000; i
++)
11520 uint key_md4
[2] = { i
, 0 };
11521 uint key_des
[2] = { 0, 0 };
11523 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11525 uint Kc
[16] = { 0 };
11526 uint Kd
[16] = { 0 };
11528 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11530 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11532 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11534 if (data3
[0] != digest_tmp
[0]) continue;
11535 if (data3
[1] != digest_tmp
[1]) continue;
11537 salt
->salt_buf
[2] = i
;
11539 salt
->salt_len
= 24;
11544 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11545 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11547 /* precompute netntlmv1 exploit stop */
11551 IP (digest
[0], digest
[1], tt
);
11552 IP (digest
[2], digest
[3], tt
);
11554 digest
[0] = rotr32 (digest
[0], 29);
11555 digest
[1] = rotr32 (digest
[1], 29);
11556 digest
[2] = rotr32 (digest
[2], 29);
11557 digest
[3] = rotr32 (digest
[3], 29);
11559 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11561 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11562 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11564 return (PARSER_OK
);
11567 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11569 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11571 u32
*digest
= (u32
*) hash_buf
->digest
;
11573 salt_t
*salt
= hash_buf
->salt
;
11575 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11581 char *user_pos
= input_buf
;
11583 char *unused_pos
= strchr (user_pos
, ':');
11585 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11587 uint user_len
= unused_pos
- user_pos
;
11589 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11593 char *domain_pos
= strchr (unused_pos
, ':');
11595 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11597 uint unused_len
= domain_pos
- unused_pos
;
11599 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11603 char *srvchall_pos
= strchr (domain_pos
, ':');
11605 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11607 uint domain_len
= srvchall_pos
- domain_pos
;
11609 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11613 char *hash_pos
= strchr (srvchall_pos
, ':');
11615 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11617 uint srvchall_len
= hash_pos
- srvchall_pos
;
11619 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11623 char *clichall_pos
= strchr (hash_pos
, ':');
11625 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11627 uint hash_len
= clichall_pos
- hash_pos
;
11629 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11633 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11635 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11637 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11640 * store some data for later use
11643 netntlm
->user_len
= user_len
* 2;
11644 netntlm
->domain_len
= domain_len
* 2;
11645 netntlm
->srvchall_len
= srvchall_len
/ 2;
11646 netntlm
->clichall_len
= clichall_len
/ 2;
11648 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11649 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11652 * handle username and domainname
11655 for (uint i
= 0; i
< user_len
; i
++)
11657 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11658 *userdomain_ptr
++ = 0;
11661 for (uint i
= 0; i
< domain_len
; i
++)
11663 *userdomain_ptr
++ = domain_pos
[i
];
11664 *userdomain_ptr
++ = 0;
11667 *userdomain_ptr
++ = 0x80;
11670 * handle server challenge encoding
11673 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11675 const char p0
= srvchall_pos
[i
+ 0];
11676 const char p1
= srvchall_pos
[i
+ 1];
11678 *chall_ptr
++ = hex_convert (p1
) << 0
11679 | hex_convert (p0
) << 4;
11683 * handle client challenge encoding
11686 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11688 const char p0
= clichall_pos
[i
+ 0];
11689 const char p1
= clichall_pos
[i
+ 1];
11691 *chall_ptr
++ = hex_convert (p1
) << 0
11692 | hex_convert (p0
) << 4;
11695 *chall_ptr
++ = 0x80;
11698 * handle hash itself
11701 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11702 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11703 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11704 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11706 digest
[0] = byte_swap_32 (digest
[0]);
11707 digest
[1] = byte_swap_32 (digest
[1]);
11708 digest
[2] = byte_swap_32 (digest
[2]);
11709 digest
[3] = byte_swap_32 (digest
[3]);
11712 * reuse challange data as salt_buf, its the buffer that is most likely unique
11715 salt
->salt_buf
[0] = 0;
11716 salt
->salt_buf
[1] = 0;
11717 salt
->salt_buf
[2] = 0;
11718 salt
->salt_buf
[3] = 0;
11719 salt
->salt_buf
[4] = 0;
11720 salt
->salt_buf
[5] = 0;
11721 salt
->salt_buf
[6] = 0;
11722 salt
->salt_buf
[7] = 0;
11726 uptr
= (uint
*) netntlm
->userdomain_buf
;
11728 for (uint i
= 0; i
< 16; i
+= 16)
11730 md5_64 (uptr
, salt
->salt_buf
);
11733 uptr
= (uint
*) netntlm
->chall_buf
;
11735 for (uint i
= 0; i
< 256; i
+= 16)
11737 md5_64 (uptr
, salt
->salt_buf
);
11740 salt
->salt_len
= 16;
11742 return (PARSER_OK
);
11745 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11747 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11749 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11753 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11756 u32
*digest
= (u32
*) hash_buf
->digest
;
11758 salt_t
*salt
= hash_buf
->salt
;
11760 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11761 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11762 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11763 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11765 digest
[0] = byte_swap_32 (digest
[0]);
11766 digest
[1] = byte_swap_32 (digest
[1]);
11767 digest
[2] = byte_swap_32 (digest
[2]);
11768 digest
[3] = byte_swap_32 (digest
[3]);
11770 digest
[0] -= MD5M_A
;
11771 digest
[1] -= MD5M_B
;
11772 digest
[2] -= MD5M_C
;
11773 digest
[3] -= MD5M_D
;
11775 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11777 uint salt_len
= input_len
- 32 - 1;
11779 char *salt_buf
= input_buf
+ 32 + 1;
11781 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11783 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11785 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11787 salt
->salt_len
= salt_len
;
11789 return (PARSER_OK
);
11792 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11794 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11796 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11800 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11803 u32
*digest
= (u32
*) hash_buf
->digest
;
11805 salt_t
*salt
= hash_buf
->salt
;
11807 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11808 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11809 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11810 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11812 digest
[0] = byte_swap_32 (digest
[0]);
11813 digest
[1] = byte_swap_32 (digest
[1]);
11814 digest
[2] = byte_swap_32 (digest
[2]);
11815 digest
[3] = byte_swap_32 (digest
[3]);
11817 digest
[0] -= MD5M_A
;
11818 digest
[1] -= MD5M_B
;
11819 digest
[2] -= MD5M_C
;
11820 digest
[3] -= MD5M_D
;
11822 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11824 uint salt_len
= input_len
- 32 - 1;
11826 char *salt_buf
= input_buf
+ 32 + 1;
11828 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11830 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11832 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11834 salt
->salt_len
= salt_len
;
11836 return (PARSER_OK
);
11839 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11841 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11843 u32
*digest
= (u32
*) hash_buf
->digest
;
11845 salt_t
*salt
= hash_buf
->salt
;
11847 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11848 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11849 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11850 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11852 digest
[0] = byte_swap_32 (digest
[0]);
11853 digest
[1] = byte_swap_32 (digest
[1]);
11854 digest
[2] = byte_swap_32 (digest
[2]);
11855 digest
[3] = byte_swap_32 (digest
[3]);
11857 digest
[0] -= MD5M_A
;
11858 digest
[1] -= MD5M_B
;
11859 digest
[2] -= MD5M_C
;
11860 digest
[3] -= MD5M_D
;
11863 * This is a virtual salt. While the algorithm is basically not salted
11864 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11865 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11868 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11870 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11872 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11874 salt
->salt_len
= salt_len
;
11876 return (PARSER_OK
);
11879 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11881 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11883 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11887 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11890 u32
*digest
= (u32
*) hash_buf
->digest
;
11892 salt_t
*salt
= hash_buf
->salt
;
11894 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11895 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11896 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11897 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11899 digest
[0] = byte_swap_32 (digest
[0]);
11900 digest
[1] = byte_swap_32 (digest
[1]);
11901 digest
[2] = byte_swap_32 (digest
[2]);
11902 digest
[3] = byte_swap_32 (digest
[3]);
11904 digest
[0] -= MD5M_A
;
11905 digest
[1] -= MD5M_B
;
11906 digest
[2] -= MD5M_C
;
11907 digest
[3] -= MD5M_D
;
11909 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11911 uint salt_len
= input_len
- 32 - 1;
11913 char *salt_buf
= input_buf
+ 32 + 1;
11915 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11917 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11919 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11921 salt
->salt_len
= salt_len
;
11923 return (PARSER_OK
);
11926 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11928 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11930 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11934 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11937 u32
*digest
= (u32
*) hash_buf
->digest
;
11939 salt_t
*salt
= hash_buf
->salt
;
11941 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11942 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11943 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11944 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11946 digest
[0] = byte_swap_32 (digest
[0]);
11947 digest
[1] = byte_swap_32 (digest
[1]);
11948 digest
[2] = byte_swap_32 (digest
[2]);
11949 digest
[3] = byte_swap_32 (digest
[3]);
11951 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11953 uint salt_len
= input_len
- 32 - 1;
11955 char *salt_buf
= input_buf
+ 32 + 1;
11957 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11959 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11961 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11963 salt
->salt_len
= salt_len
;
11965 return (PARSER_OK
);
11968 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11970 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11972 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11976 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11979 u32
*digest
= (u32
*) hash_buf
->digest
;
11981 salt_t
*salt
= hash_buf
->salt
;
11983 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11984 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11985 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11986 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11988 digest
[0] = byte_swap_32 (digest
[0]);
11989 digest
[1] = byte_swap_32 (digest
[1]);
11990 digest
[2] = byte_swap_32 (digest
[2]);
11991 digest
[3] = byte_swap_32 (digest
[3]);
11993 digest
[0] -= MD4M_A
;
11994 digest
[1] -= MD4M_B
;
11995 digest
[2] -= MD4M_C
;
11996 digest
[3] -= MD4M_D
;
11998 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12000 uint salt_len
= input_len
- 32 - 1;
12002 char *salt_buf
= input_buf
+ 32 + 1;
12004 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12006 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12008 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12010 salt
->salt_len
= salt_len
;
12012 return (PARSER_OK
);
12015 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12017 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12019 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
12023 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
12026 u32
*digest
= (u32
*) hash_buf
->digest
;
12028 salt_t
*salt
= hash_buf
->salt
;
12030 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12031 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12032 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12033 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12035 digest
[0] = byte_swap_32 (digest
[0]);
12036 digest
[1] = byte_swap_32 (digest
[1]);
12037 digest
[2] = byte_swap_32 (digest
[2]);
12038 digest
[3] = byte_swap_32 (digest
[3]);
12040 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12042 uint salt_len
= input_len
- 32 - 1;
12044 char *salt_buf
= input_buf
+ 32 + 1;
12046 uint salt_pc_block
[16] = { 0 };
12048 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
12050 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
12052 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12054 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
12056 salt_pc_block
[14] = salt_len
* 8;
12058 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
12060 md5_64 (salt_pc_block
, salt_pc_digest
);
12062 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
12063 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
12064 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
12065 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
12067 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
12069 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
12071 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
12073 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
12074 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
12075 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
12076 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
12078 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
12080 return (PARSER_OK
);
12083 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12085 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
12087 u32
*digest
= (u32
*) hash_buf
->digest
;
12089 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12090 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12091 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12092 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12093 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12095 digest
[0] -= SHA1M_A
;
12096 digest
[1] -= SHA1M_B
;
12097 digest
[2] -= SHA1M_C
;
12098 digest
[3] -= SHA1M_D
;
12099 digest
[4] -= SHA1M_E
;
12101 return (PARSER_OK
);
12104 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12106 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
12108 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
12110 u32
*digest
= (u32
*) hash_buf
->digest
;
12114 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12115 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12116 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12117 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12120 return (PARSER_OK
);
12123 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12125 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12127 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12131 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12134 u32
*digest
= (u32
*) hash_buf
->digest
;
12136 salt_t
*salt
= hash_buf
->salt
;
12138 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12139 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12140 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12141 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12142 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12144 digest
[0] -= SHA1M_A
;
12145 digest
[1] -= SHA1M_B
;
12146 digest
[2] -= SHA1M_C
;
12147 digest
[3] -= SHA1M_D
;
12148 digest
[4] -= SHA1M_E
;
12150 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12152 uint salt_len
= input_len
- 40 - 1;
12154 char *salt_buf
= input_buf
+ 40 + 1;
12156 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12158 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12160 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12162 salt
->salt_len
= salt_len
;
12164 return (PARSER_OK
);
12167 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12169 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12171 u32
*digest
= (u32
*) hash_buf
->digest
;
12173 salt_t
*salt
= hash_buf
->salt
;
12175 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12177 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12178 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12179 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12180 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12181 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12183 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12185 uint salt_len
= input_len
- 40 - 1;
12187 char *salt_buf
= input_buf
+ 40 + 1;
12189 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12191 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12193 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12195 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12198 pstoken
->salt_len
= salt_len
/ 2;
12200 /* some fake salt for the sorting mechanisms */
12202 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12203 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12204 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12205 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12206 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12207 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12208 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12209 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12211 salt
->salt_len
= 32;
12213 /* we need to check if we can precompute some of the data --
12214 this is possible since the scheme is badly designed */
12216 pstoken
->pc_digest
[0] = SHA1M_A
;
12217 pstoken
->pc_digest
[1] = SHA1M_B
;
12218 pstoken
->pc_digest
[2] = SHA1M_C
;
12219 pstoken
->pc_digest
[3] = SHA1M_D
;
12220 pstoken
->pc_digest
[4] = SHA1M_E
;
12222 pstoken
->pc_offset
= 0;
12224 for (int i
= 0; i
< (int) pstoken
->salt_len
- 63; i
+= 64)
12228 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12229 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12230 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12231 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12232 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12233 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12234 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12235 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12236 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12237 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12238 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12239 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12240 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12241 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12242 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12243 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12245 sha1_64 (w
, pstoken
->pc_digest
);
12247 pstoken
->pc_offset
+= 16;
12250 return (PARSER_OK
);
12253 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12255 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12257 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12259 u32
*digest
= (u32
*) hash_buf
->digest
;
12261 u8 tmp_buf
[100] = { 0 };
12263 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12265 memcpy (digest
, tmp_buf
, 20);
12267 digest
[0] = byte_swap_32 (digest
[0]);
12268 digest
[1] = byte_swap_32 (digest
[1]);
12269 digest
[2] = byte_swap_32 (digest
[2]);
12270 digest
[3] = byte_swap_32 (digest
[3]);
12271 digest
[4] = byte_swap_32 (digest
[4]);
12273 digest
[0] -= SHA1M_A
;
12274 digest
[1] -= SHA1M_B
;
12275 digest
[2] -= SHA1M_C
;
12276 digest
[3] -= SHA1M_D
;
12277 digest
[4] -= SHA1M_E
;
12279 return (PARSER_OK
);
12282 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12284 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12286 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12288 u32
*digest
= (u32
*) hash_buf
->digest
;
12290 salt_t
*salt
= hash_buf
->salt
;
12292 u8 tmp_buf
[100] = { 0 };
12294 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12296 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12298 memcpy (digest
, tmp_buf
, 20);
12300 int salt_len
= tmp_len
- 20;
12302 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12304 salt
->salt_len
= salt_len
;
12306 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12308 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12310 char *ptr
= (char *) salt
->salt_buf
;
12312 ptr
[salt
->salt_len
] = 0x80;
12315 digest
[0] = byte_swap_32 (digest
[0]);
12316 digest
[1] = byte_swap_32 (digest
[1]);
12317 digest
[2] = byte_swap_32 (digest
[2]);
12318 digest
[3] = byte_swap_32 (digest
[3]);
12319 digest
[4] = byte_swap_32 (digest
[4]);
12321 digest
[0] -= SHA1M_A
;
12322 digest
[1] -= SHA1M_B
;
12323 digest
[2] -= SHA1M_C
;
12324 digest
[3] -= SHA1M_D
;
12325 digest
[4] -= SHA1M_E
;
12327 return (PARSER_OK
);
12330 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12332 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12334 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12336 u32
*digest
= (u32
*) hash_buf
->digest
;
12338 salt_t
*salt
= hash_buf
->salt
;
12340 char *salt_buf
= input_buf
+ 6;
12344 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12346 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12348 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12350 salt
->salt_len
= salt_len
;
12352 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12354 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12355 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12356 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12357 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12358 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12360 digest
[0] -= SHA1M_A
;
12361 digest
[1] -= SHA1M_B
;
12362 digest
[2] -= SHA1M_C
;
12363 digest
[3] -= SHA1M_D
;
12364 digest
[4] -= SHA1M_E
;
12366 return (PARSER_OK
);
12369 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12371 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12373 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12375 u32
*digest
= (u32
*) hash_buf
->digest
;
12377 salt_t
*salt
= hash_buf
->salt
;
12379 char *salt_buf
= input_buf
+ 6;
12383 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12385 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12387 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12389 salt
->salt_len
= salt_len
;
12391 char *hash_pos
= input_buf
+ 6 + 8;
12393 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12394 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12395 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12396 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12397 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12399 digest
[0] -= SHA1M_A
;
12400 digest
[1] -= SHA1M_B
;
12401 digest
[2] -= SHA1M_C
;
12402 digest
[3] -= SHA1M_D
;
12403 digest
[4] -= SHA1M_E
;
12405 return (PARSER_OK
);
12408 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12410 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12412 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12414 u64
*digest
= (u64
*) hash_buf
->digest
;
12416 salt_t
*salt
= hash_buf
->salt
;
12418 char *salt_buf
= input_buf
+ 6;
12422 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12424 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12426 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12428 salt
->salt_len
= salt_len
;
12430 char *hash_pos
= input_buf
+ 6 + 8;
12432 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12433 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12434 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12435 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12436 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12437 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12438 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12439 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12441 digest
[0] -= SHA512M_A
;
12442 digest
[1] -= SHA512M_B
;
12443 digest
[2] -= SHA512M_C
;
12444 digest
[3] -= SHA512M_D
;
12445 digest
[4] -= SHA512M_E
;
12446 digest
[5] -= SHA512M_F
;
12447 digest
[6] -= SHA512M_G
;
12448 digest
[7] -= SHA512M_H
;
12450 return (PARSER_OK
);
12453 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12455 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12457 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12461 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12464 u32
*digest
= (u32
*) hash_buf
->digest
;
12466 salt_t
*salt
= hash_buf
->salt
;
12468 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12469 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12473 digest
[0] = byte_swap_32 (digest
[0]);
12474 digest
[1] = byte_swap_32 (digest
[1]);
12476 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12478 uint salt_len
= input_len
- 16 - 1;
12480 char *salt_buf
= input_buf
+ 16 + 1;
12482 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12484 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12486 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12488 salt
->salt_len
= salt_len
;
12490 return (PARSER_OK
);
12493 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12495 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12497 u32
*digest
= (u32
*) hash_buf
->digest
;
12499 salt_t
*salt
= hash_buf
->salt
;
12501 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12502 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12503 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12504 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12505 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12507 digest
[0] -= SHA1M_A
;
12508 digest
[1] -= SHA1M_B
;
12509 digest
[2] -= SHA1M_C
;
12510 digest
[3] -= SHA1M_D
;
12511 digest
[4] -= SHA1M_E
;
12513 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12515 uint salt_len
= input_len
- 40 - 1;
12517 char *salt_buf
= input_buf
+ 40 + 1;
12519 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12521 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12523 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12525 salt
->salt_len
= salt_len
;
12527 return (PARSER_OK
);
12530 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12532 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12534 u32
*digest
= (u32
*) hash_buf
->digest
;
12536 salt_t
*salt
= hash_buf
->salt
;
12538 char *hash_pos
= input_buf
;
12540 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12541 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12542 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12543 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12544 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12545 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12546 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12547 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12548 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12549 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12550 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12551 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12552 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12553 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12554 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12555 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12557 char *salt_pos
= input_buf
+ 128;
12559 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12560 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12561 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12562 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12564 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12565 salt
->salt_len
= 16;
12567 return (PARSER_OK
);
12570 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12572 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12574 u32
*digest
= (u32
*) hash_buf
->digest
;
12576 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12577 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12578 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12579 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12580 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12581 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12582 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12583 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12585 digest
[0] -= SHA256M_A
;
12586 digest
[1] -= SHA256M_B
;
12587 digest
[2] -= SHA256M_C
;
12588 digest
[3] -= SHA256M_D
;
12589 digest
[4] -= SHA256M_E
;
12590 digest
[5] -= SHA256M_F
;
12591 digest
[6] -= SHA256M_G
;
12592 digest
[7] -= SHA256M_H
;
12594 return (PARSER_OK
);
12597 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12599 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12601 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12605 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12608 u32
*digest
= (u32
*) hash_buf
->digest
;
12610 salt_t
*salt
= hash_buf
->salt
;
12612 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12613 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12614 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12615 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12616 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12617 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12618 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12619 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12621 digest
[0] -= SHA256M_A
;
12622 digest
[1] -= SHA256M_B
;
12623 digest
[2] -= SHA256M_C
;
12624 digest
[3] -= SHA256M_D
;
12625 digest
[4] -= SHA256M_E
;
12626 digest
[5] -= SHA256M_F
;
12627 digest
[6] -= SHA256M_G
;
12628 digest
[7] -= SHA256M_H
;
12630 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12632 uint salt_len
= input_len
- 64 - 1;
12634 char *salt_buf
= input_buf
+ 64 + 1;
12636 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12638 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12640 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12642 salt
->salt_len
= salt_len
;
12644 return (PARSER_OK
);
12647 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12649 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12651 u64
*digest
= (u64
*) hash_buf
->digest
;
12653 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12654 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12655 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12656 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12657 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12658 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12662 digest
[0] -= SHA384M_A
;
12663 digest
[1] -= SHA384M_B
;
12664 digest
[2] -= SHA384M_C
;
12665 digest
[3] -= SHA384M_D
;
12666 digest
[4] -= SHA384M_E
;
12667 digest
[5] -= SHA384M_F
;
12671 return (PARSER_OK
);
12674 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12676 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12678 u64
*digest
= (u64
*) hash_buf
->digest
;
12680 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12681 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12682 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12683 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12684 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12685 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12686 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12687 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12689 digest
[0] -= SHA512M_A
;
12690 digest
[1] -= SHA512M_B
;
12691 digest
[2] -= SHA512M_C
;
12692 digest
[3] -= SHA512M_D
;
12693 digest
[4] -= SHA512M_E
;
12694 digest
[5] -= SHA512M_F
;
12695 digest
[6] -= SHA512M_G
;
12696 digest
[7] -= SHA512M_H
;
12698 return (PARSER_OK
);
12701 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12703 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12705 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12709 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12712 u64
*digest
= (u64
*) hash_buf
->digest
;
12714 salt_t
*salt
= hash_buf
->salt
;
12716 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12717 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12718 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12719 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12720 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12721 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12722 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12723 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12725 digest
[0] -= SHA512M_A
;
12726 digest
[1] -= SHA512M_B
;
12727 digest
[2] -= SHA512M_C
;
12728 digest
[3] -= SHA512M_D
;
12729 digest
[4] -= SHA512M_E
;
12730 digest
[5] -= SHA512M_F
;
12731 digest
[6] -= SHA512M_G
;
12732 digest
[7] -= SHA512M_H
;
12734 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12736 uint salt_len
= input_len
- 128 - 1;
12738 char *salt_buf
= input_buf
+ 128 + 1;
12740 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12742 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12744 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12746 salt
->salt_len
= salt_len
;
12748 return (PARSER_OK
);
12751 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12753 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12755 u64
*digest
= (u64
*) hash_buf
->digest
;
12757 salt_t
*salt
= hash_buf
->salt
;
12759 char *salt_pos
= input_buf
+ 3;
12761 uint iterations_len
= 0;
12763 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12767 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12769 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12770 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12774 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12778 iterations_len
+= 8;
12782 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12785 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12787 char *hash_pos
= strchr (salt_pos
, '$');
12789 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12791 uint salt_len
= hash_pos
- salt_pos
;
12793 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12795 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12797 salt
->salt_len
= salt_len
;
12801 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12803 return (PARSER_OK
);
12806 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12808 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12810 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12812 u64
*digest
= (u64
*) hash_buf
->digest
;
12814 salt_t
*salt
= hash_buf
->salt
;
12816 uint keccak_mdlen
= input_len
/ 2;
12818 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12820 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12822 digest
[i
] = byte_swap_64 (digest
[i
]);
12825 salt
->keccak_mdlen
= keccak_mdlen
;
12827 return (PARSER_OK
);
12830 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12832 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12834 u32
*digest
= (u32
*) hash_buf
->digest
;
12836 salt_t
*salt
= hash_buf
->salt
;
12838 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12841 * Parse that strange long line
12846 size_t in_len
[9] = { 0 };
12848 in_off
[0] = strtok (input_buf
, ":");
12850 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12852 in_len
[0] = strlen (in_off
[0]);
12856 for (i
= 1; i
< 9; i
++)
12858 in_off
[i
] = strtok (NULL
, ":");
12860 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12862 in_len
[i
] = strlen (in_off
[i
]);
12865 char *ptr
= (char *) ikepsk
->msg_buf
;
12867 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12868 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12869 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12870 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12871 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12872 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12876 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12878 ptr
= (char *) ikepsk
->nr_buf
;
12880 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12881 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12885 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12888 * Store to database
12893 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12894 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12895 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12896 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12898 digest
[0] = byte_swap_32 (digest
[0]);
12899 digest
[1] = byte_swap_32 (digest
[1]);
12900 digest
[2] = byte_swap_32 (digest
[2]);
12901 digest
[3] = byte_swap_32 (digest
[3]);
12903 salt
->salt_len
= 32;
12905 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12906 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12907 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12908 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12909 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12910 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12911 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12912 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12914 return (PARSER_OK
);
12917 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12919 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12921 u32
*digest
= (u32
*) hash_buf
->digest
;
12923 salt_t
*salt
= hash_buf
->salt
;
12925 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12928 * Parse that strange long line
12933 size_t in_len
[9] = { 0 };
12935 in_off
[0] = strtok (input_buf
, ":");
12937 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12939 in_len
[0] = strlen (in_off
[0]);
12943 for (i
= 1; i
< 9; i
++)
12945 in_off
[i
] = strtok (NULL
, ":");
12947 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12949 in_len
[i
] = strlen (in_off
[i
]);
12952 char *ptr
= (char *) ikepsk
->msg_buf
;
12954 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12955 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12956 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12957 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12958 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12959 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12963 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12965 ptr
= (char *) ikepsk
->nr_buf
;
12967 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12968 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12972 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12975 * Store to database
12980 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12981 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12982 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12983 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12984 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12986 salt
->salt_len
= 32;
12988 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12989 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12990 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12991 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12992 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12993 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12994 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12995 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12997 return (PARSER_OK
);
13000 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13002 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
13004 u32
*digest
= (u32
*) hash_buf
->digest
;
13006 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13007 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13008 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13009 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13010 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13012 digest
[0] = byte_swap_32 (digest
[0]);
13013 digest
[1] = byte_swap_32 (digest
[1]);
13014 digest
[2] = byte_swap_32 (digest
[2]);
13015 digest
[3] = byte_swap_32 (digest
[3]);
13016 digest
[4] = byte_swap_32 (digest
[4]);
13018 return (PARSER_OK
);
13021 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13023 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
13025 u32
*digest
= (u32
*) hash_buf
->digest
;
13027 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13028 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13029 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
13030 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
13031 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
13032 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
13033 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
13034 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
13035 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
13036 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
13037 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
13038 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
13039 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
13040 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
13041 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
13042 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
13044 return (PARSER_OK
);
13047 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13049 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
13051 u32
*digest
= (u32
*) hash_buf
->digest
;
13053 salt_t
*salt
= hash_buf
->salt
;
13055 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13056 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13057 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13058 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13059 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13061 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13063 uint salt_len
= input_len
- 40 - 1;
13065 char *salt_buf
= input_buf
+ 40 + 1;
13067 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13069 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13071 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13073 salt
->salt_len
= salt_len
;
13075 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
13077 return (PARSER_OK
);
13080 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13082 u32
*digest
= (u32
*) hash_buf
->digest
;
13084 salt_t
*salt
= hash_buf
->salt
;
13086 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13088 if (input_len
== 0)
13090 log_error ("TrueCrypt container not specified");
13095 FILE *fp
= fopen (input_buf
, "rb");
13099 log_error ("%s: %s", input_buf
, strerror (errno
));
13104 char buf
[512] = { 0 };
13106 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13110 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13112 memcpy (tc
->salt_buf
, buf
, 64);
13114 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13116 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13118 salt
->salt_len
= 4;
13120 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
13122 tc
->signature
= 0x45555254; // "TRUE"
13124 digest
[0] = tc
->data_buf
[0];
13126 return (PARSER_OK
);
13129 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13131 u32
*digest
= (u32
*) hash_buf
->digest
;
13133 salt_t
*salt
= hash_buf
->salt
;
13135 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13137 if (input_len
== 0)
13139 log_error ("TrueCrypt container not specified");
13144 FILE *fp
= fopen (input_buf
, "rb");
13148 log_error ("%s: %s", input_buf
, strerror (errno
));
13153 char buf
[512] = { 0 };
13155 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13159 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13161 memcpy (tc
->salt_buf
, buf
, 64);
13163 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13165 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13167 salt
->salt_len
= 4;
13169 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13171 tc
->signature
= 0x45555254; // "TRUE"
13173 digest
[0] = tc
->data_buf
[0];
13175 return (PARSER_OK
);
13178 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13180 u32
*digest
= (u32
*) hash_buf
->digest
;
13182 salt_t
*salt
= hash_buf
->salt
;
13184 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13186 if (input_len
== 0)
13188 log_error ("VeraCrypt container not specified");
13193 FILE *fp
= fopen (input_buf
, "rb");
13197 log_error ("%s: %s", input_buf
, strerror (errno
));
13202 char buf
[512] = { 0 };
13204 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13208 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13210 memcpy (tc
->salt_buf
, buf
, 64);
13212 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13214 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13216 salt
->salt_len
= 4;
13218 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13220 tc
->signature
= 0x41524556; // "VERA"
13222 digest
[0] = tc
->data_buf
[0];
13224 return (PARSER_OK
);
13227 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13229 u32
*digest
= (u32
*) hash_buf
->digest
;
13231 salt_t
*salt
= hash_buf
->salt
;
13233 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13235 if (input_len
== 0)
13237 log_error ("VeraCrypt container not specified");
13242 FILE *fp
= fopen (input_buf
, "rb");
13246 log_error ("%s: %s", input_buf
, strerror (errno
));
13251 char buf
[512] = { 0 };
13253 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13257 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13259 memcpy (tc
->salt_buf
, buf
, 64);
13261 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13263 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13265 salt
->salt_len
= 4;
13267 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13269 tc
->signature
= 0x41524556; // "VERA"
13271 digest
[0] = tc
->data_buf
[0];
13273 return (PARSER_OK
);
13276 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13278 u32
*digest
= (u32
*) hash_buf
->digest
;
13280 salt_t
*salt
= hash_buf
->salt
;
13282 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13284 if (input_len
== 0)
13286 log_error ("VeraCrypt container not specified");
13291 FILE *fp
= fopen (input_buf
, "rb");
13295 log_error ("%s: %s", input_buf
, strerror (errno
));
13300 char buf
[512] = { 0 };
13302 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13306 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13308 memcpy (tc
->salt_buf
, buf
, 64);
13310 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13312 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13314 salt
->salt_len
= 4;
13316 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13318 tc
->signature
= 0x41524556; // "VERA"
13320 digest
[0] = tc
->data_buf
[0];
13322 return (PARSER_OK
);
13325 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13327 u32
*digest
= (u32
*) hash_buf
->digest
;
13329 salt_t
*salt
= hash_buf
->salt
;
13331 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13333 if (input_len
== 0)
13335 log_error ("VeraCrypt container not specified");
13340 FILE *fp
= fopen (input_buf
, "rb");
13344 log_error ("%s: %s", input_buf
, strerror (errno
));
13349 char buf
[512] = { 0 };
13351 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13355 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13357 memcpy (tc
->salt_buf
, buf
, 64);
13359 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13361 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13363 salt
->salt_len
= 4;
13365 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13367 tc
->signature
= 0x41524556; // "VERA"
13369 digest
[0] = tc
->data_buf
[0];
13371 return (PARSER_OK
);
13374 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13376 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13378 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13380 u32
*digest
= (u32
*) hash_buf
->digest
;
13382 salt_t
*salt
= hash_buf
->salt
;
13384 char *salt_pos
= input_buf
+ 6;
13386 char *hash_pos
= strchr (salt_pos
, '$');
13388 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13390 uint salt_len
= hash_pos
- salt_pos
;
13392 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13394 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13396 salt
->salt_len
= salt_len
;
13398 salt
->salt_iter
= 1000;
13402 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13404 return (PARSER_OK
);
13407 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13409 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13411 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13413 u32
*digest
= (u32
*) hash_buf
->digest
;
13415 salt_t
*salt
= hash_buf
->salt
;
13417 char *iter_pos
= input_buf
+ 7;
13419 char *salt_pos
= strchr (iter_pos
, '$');
13421 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13425 char *hash_pos
= strchr (salt_pos
, '$');
13427 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13429 uint salt_len
= hash_pos
- salt_pos
;
13431 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13433 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13435 salt
->salt_len
= salt_len
;
13437 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13439 salt
->salt_sign
[0] = atoi (salt_iter
);
13441 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13445 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13447 digest
[0] = byte_swap_32 (digest
[0]);
13448 digest
[1] = byte_swap_32 (digest
[1]);
13449 digest
[2] = byte_swap_32 (digest
[2]);
13450 digest
[3] = byte_swap_32 (digest
[3]);
13451 digest
[4] = byte_swap_32 (digest
[4]);
13453 return (PARSER_OK
);
13456 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13458 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13460 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13462 u32
*digest
= (u32
*) hash_buf
->digest
;
13464 salt_t
*salt
= hash_buf
->salt
;
13466 char *iter_pos
= input_buf
+ 9;
13468 char *salt_pos
= strchr (iter_pos
, '$');
13470 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13474 char *hash_pos
= strchr (salt_pos
, '$');
13476 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13478 uint salt_len
= hash_pos
- salt_pos
;
13480 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13482 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13484 salt
->salt_len
= salt_len
;
13486 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13488 salt
->salt_sign
[0] = atoi (salt_iter
);
13490 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13494 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13496 digest
[0] = byte_swap_32 (digest
[0]);
13497 digest
[1] = byte_swap_32 (digest
[1]);
13498 digest
[2] = byte_swap_32 (digest
[2]);
13499 digest
[3] = byte_swap_32 (digest
[3]);
13500 digest
[4] = byte_swap_32 (digest
[4]);
13501 digest
[5] = byte_swap_32 (digest
[5]);
13502 digest
[6] = byte_swap_32 (digest
[6]);
13503 digest
[7] = byte_swap_32 (digest
[7]);
13505 return (PARSER_OK
);
13508 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13510 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13512 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13514 u64
*digest
= (u64
*) hash_buf
->digest
;
13516 salt_t
*salt
= hash_buf
->salt
;
13518 char *iter_pos
= input_buf
+ 9;
13520 char *salt_pos
= strchr (iter_pos
, '$');
13522 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13526 char *hash_pos
= strchr (salt_pos
, '$');
13528 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13530 uint salt_len
= hash_pos
- salt_pos
;
13532 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13534 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13536 salt
->salt_len
= salt_len
;
13538 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13540 salt
->salt_sign
[0] = atoi (salt_iter
);
13542 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13546 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13548 digest
[0] = byte_swap_64 (digest
[0]);
13549 digest
[1] = byte_swap_64 (digest
[1]);
13550 digest
[2] = byte_swap_64 (digest
[2]);
13551 digest
[3] = byte_swap_64 (digest
[3]);
13552 digest
[4] = byte_swap_64 (digest
[4]);
13553 digest
[5] = byte_swap_64 (digest
[5]);
13554 digest
[6] = byte_swap_64 (digest
[6]);
13555 digest
[7] = byte_swap_64 (digest
[7]);
13557 return (PARSER_OK
);
13560 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13562 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13564 u32
*digest
= (u32
*) hash_buf
->digest
;
13566 salt_t
*salt
= hash_buf
->salt
;
13568 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13574 char *iterations_pos
= input_buf
;
13576 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13578 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13580 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13582 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13586 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13588 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13590 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13592 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13594 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13596 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13601 * pbkdf2 iterations
13604 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13607 * handle salt encoding
13610 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13612 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13614 const char p0
= saltbuf_pos
[i
+ 0];
13615 const char p1
= saltbuf_pos
[i
+ 1];
13617 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13618 | hex_convert (p0
) << 4;
13621 salt
->salt_len
= saltbuf_len
/ 2;
13624 * handle cipher encoding
13627 uint
*tmp
= (uint
*) mymalloc (32);
13629 char *cipherbuf_ptr
= (char *) tmp
;
13631 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13633 const char p0
= cipherbuf_pos
[i
+ 0];
13634 const char p1
= cipherbuf_pos
[i
+ 1];
13636 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13637 | hex_convert (p0
) << 4;
13640 // iv is stored at salt_buf 4 (length 16)
13641 // data is stored at salt_buf 8 (length 16)
13643 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13644 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13645 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13646 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13648 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13649 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13650 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13651 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13655 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13657 const char p0
= cipherbuf_pos
[j
+ 0];
13658 const char p1
= cipherbuf_pos
[j
+ 1];
13660 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13661 | hex_convert (p0
) << 4;
13668 digest
[0] = 0x10101010;
13669 digest
[1] = 0x10101010;
13670 digest
[2] = 0x10101010;
13671 digest
[3] = 0x10101010;
13673 return (PARSER_OK
);
13676 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13678 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13680 u32
*digest
= (u32
*) hash_buf
->digest
;
13682 salt_t
*salt
= hash_buf
->salt
;
13684 char *hashbuf_pos
= input_buf
;
13686 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13688 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13690 uint hash_len
= iterations_pos
- hashbuf_pos
;
13692 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13696 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13698 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13700 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13704 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13706 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13708 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13710 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13712 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13714 salt
->salt_len
= salt_len
;
13716 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13718 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13719 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13720 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13721 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13723 return (PARSER_OK
);
13726 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13728 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13730 u32
*digest
= (u32
*) hash_buf
->digest
;
13732 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13733 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13734 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13735 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13736 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13737 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13738 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13739 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13741 digest
[0] = byte_swap_32 (digest
[0]);
13742 digest
[1] = byte_swap_32 (digest
[1]);
13743 digest
[2] = byte_swap_32 (digest
[2]);
13744 digest
[3] = byte_swap_32 (digest
[3]);
13745 digest
[4] = byte_swap_32 (digest
[4]);
13746 digest
[5] = byte_swap_32 (digest
[5]);
13747 digest
[6] = byte_swap_32 (digest
[6]);
13748 digest
[7] = byte_swap_32 (digest
[7]);
13750 return (PARSER_OK
);
13753 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13755 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13757 u32
*digest
= (u32
*) hash_buf
->digest
;
13759 salt_t
*salt
= hash_buf
->salt
;
13761 char *salt_pos
= input_buf
+ 3;
13763 uint iterations_len
= 0;
13765 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13769 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13771 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13772 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13776 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13780 iterations_len
+= 8;
13784 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13787 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13789 char *hash_pos
= strchr (salt_pos
, '$');
13791 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13793 uint salt_len
= hash_pos
- salt_pos
;
13795 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13797 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13799 salt
->salt_len
= salt_len
;
13803 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13805 return (PARSER_OK
);
13808 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13810 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13812 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13814 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13816 u64
*digest
= (u64
*) hash_buf
->digest
;
13818 salt_t
*salt
= hash_buf
->salt
;
13820 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13822 char *iter_pos
= input_buf
+ 4;
13824 char *salt_pos
= strchr (iter_pos
, '$');
13826 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13830 char *hash_pos
= strchr (salt_pos
, '$');
13832 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13834 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13838 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13839 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13840 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13841 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13842 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13843 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13844 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13845 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13847 uint salt_len
= hash_pos
- salt_pos
- 1;
13849 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13851 salt
->salt_len
= salt_len
/ 2;
13853 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13854 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13855 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13856 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13857 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13858 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13859 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13860 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13862 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13863 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13864 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13865 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13866 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13867 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13868 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13869 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13870 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13871 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13873 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13875 salt
->salt_iter
= atoi (iter_pos
) - 1;
13877 return (PARSER_OK
);
13880 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13882 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13884 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13886 u32
*digest
= (u32
*) hash_buf
->digest
;
13888 salt_t
*salt
= hash_buf
->salt
;
13890 char *salt_pos
= input_buf
+ 14;
13892 char *hash_pos
= strchr (salt_pos
, '*');
13894 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13898 uint salt_len
= hash_pos
- salt_pos
- 1;
13900 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13902 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13904 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13906 salt
->salt_len
= salt_len
;
13908 u8 tmp_buf
[100] = { 0 };
13910 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13912 memcpy (digest
, tmp_buf
, 32);
13914 digest
[0] = byte_swap_32 (digest
[0]);
13915 digest
[1] = byte_swap_32 (digest
[1]);
13916 digest
[2] = byte_swap_32 (digest
[2]);
13917 digest
[3] = byte_swap_32 (digest
[3]);
13918 digest
[4] = byte_swap_32 (digest
[4]);
13919 digest
[5] = byte_swap_32 (digest
[5]);
13920 digest
[6] = byte_swap_32 (digest
[6]);
13921 digest
[7] = byte_swap_32 (digest
[7]);
13923 digest
[0] -= SHA256M_A
;
13924 digest
[1] -= SHA256M_B
;
13925 digest
[2] -= SHA256M_C
;
13926 digest
[3] -= SHA256M_D
;
13927 digest
[4] -= SHA256M_E
;
13928 digest
[5] -= SHA256M_F
;
13929 digest
[6] -= SHA256M_G
;
13930 digest
[7] -= SHA256M_H
;
13932 return (PARSER_OK
);
13935 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13937 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13939 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13941 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13943 u64
*digest
= (u64
*) hash_buf
->digest
;
13945 salt_t
*salt
= hash_buf
->salt
;
13947 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13949 char *iter_pos
= input_buf
+ 19;
13951 char *salt_pos
= strchr (iter_pos
, '.');
13953 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13957 char *hash_pos
= strchr (salt_pos
, '.');
13959 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13961 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13965 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13966 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13967 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13968 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13969 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13970 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13971 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13972 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13974 uint salt_len
= hash_pos
- salt_pos
- 1;
13978 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13982 for (i
= 0; i
< salt_len
; i
++)
13984 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13987 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13988 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13990 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13992 salt
->salt_len
= salt_len
;
13994 salt
->salt_iter
= atoi (iter_pos
) - 1;
13996 return (PARSER_OK
);
13999 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14001 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
14003 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
14005 u64
*digest
= (u64
*) hash_buf
->digest
;
14007 salt_t
*salt
= hash_buf
->salt
;
14009 u8 tmp_buf
[120] = { 0 };
14011 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
14013 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
14015 memcpy (digest
, tmp_buf
, 64);
14017 digest
[0] = byte_swap_64 (digest
[0]);
14018 digest
[1] = byte_swap_64 (digest
[1]);
14019 digest
[2] = byte_swap_64 (digest
[2]);
14020 digest
[3] = byte_swap_64 (digest
[3]);
14021 digest
[4] = byte_swap_64 (digest
[4]);
14022 digest
[5] = byte_swap_64 (digest
[5]);
14023 digest
[6] = byte_swap_64 (digest
[6]);
14024 digest
[7] = byte_swap_64 (digest
[7]);
14026 digest
[0] -= SHA512M_A
;
14027 digest
[1] -= SHA512M_B
;
14028 digest
[2] -= SHA512M_C
;
14029 digest
[3] -= SHA512M_D
;
14030 digest
[4] -= SHA512M_E
;
14031 digest
[5] -= SHA512M_F
;
14032 digest
[6] -= SHA512M_G
;
14033 digest
[7] -= SHA512M_H
;
14035 int salt_len
= tmp_len
- 64;
14037 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
14039 salt
->salt_len
= salt_len
;
14041 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
14043 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
14045 char *ptr
= (char *) salt
->salt_buf
;
14047 ptr
[salt
->salt_len
] = 0x80;
14050 return (PARSER_OK
);
14053 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14055 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14057 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
14061 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
14064 u32
*digest
= (u32
*) hash_buf
->digest
;
14066 salt_t
*salt
= hash_buf
->salt
;
14068 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14069 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14070 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14071 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14073 digest
[0] = byte_swap_32 (digest
[0]);
14074 digest
[1] = byte_swap_32 (digest
[1]);
14075 digest
[2] = byte_swap_32 (digest
[2]);
14076 digest
[3] = byte_swap_32 (digest
[3]);
14078 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14080 uint salt_len
= input_len
- 32 - 1;
14082 char *salt_buf
= input_buf
+ 32 + 1;
14084 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14086 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14088 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14090 salt
->salt_len
= salt_len
;
14092 return (PARSER_OK
);
14095 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14097 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14099 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
14103 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
14106 u32
*digest
= (u32
*) hash_buf
->digest
;
14108 salt_t
*salt
= hash_buf
->salt
;
14110 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14111 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14112 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14113 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14114 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14116 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14118 uint salt_len
= input_len
- 40 - 1;
14120 char *salt_buf
= input_buf
+ 40 + 1;
14122 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14124 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14126 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14128 salt
->salt_len
= salt_len
;
14130 return (PARSER_OK
);
14133 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14135 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14137 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14141 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14144 u32
*digest
= (u32
*) hash_buf
->digest
;
14146 salt_t
*salt
= hash_buf
->salt
;
14148 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14149 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14150 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14151 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14152 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14153 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14154 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14155 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14157 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14159 uint salt_len
= input_len
- 64 - 1;
14161 char *salt_buf
= input_buf
+ 64 + 1;
14163 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14165 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14167 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14169 salt
->salt_len
= salt_len
;
14171 return (PARSER_OK
);
14174 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14176 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14178 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14182 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14185 u64
*digest
= (u64
*) hash_buf
->digest
;
14187 salt_t
*salt
= hash_buf
->salt
;
14189 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14190 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14191 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14192 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14193 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14194 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14195 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14196 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14198 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14200 uint salt_len
= input_len
- 128 - 1;
14202 char *salt_buf
= input_buf
+ 128 + 1;
14204 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14206 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14208 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14210 salt
->salt_len
= salt_len
;
14212 return (PARSER_OK
);
14215 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14217 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14219 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14221 u32
*digest
= (u32
*) hash_buf
->digest
;
14223 salt_t
*salt
= hash_buf
->salt
;
14225 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14231 char *user_pos
= input_buf
+ 10 + 1;
14233 char *realm_pos
= strchr (user_pos
, '$');
14235 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14237 uint user_len
= realm_pos
- user_pos
;
14239 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14243 char *salt_pos
= strchr (realm_pos
, '$');
14245 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14247 uint realm_len
= salt_pos
- realm_pos
;
14249 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14253 char *data_pos
= strchr (salt_pos
, '$');
14255 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14257 uint salt_len
= data_pos
- salt_pos
;
14259 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14263 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14265 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14271 memcpy (krb5pa
->user
, user_pos
, user_len
);
14272 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14273 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14275 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14277 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14279 const char p0
= data_pos
[i
+ 0];
14280 const char p1
= data_pos
[i
+ 1];
14282 *timestamp_ptr
++ = hex_convert (p1
) << 0
14283 | hex_convert (p0
) << 4;
14286 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14288 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14290 const char p0
= data_pos
[i
+ 0];
14291 const char p1
= data_pos
[i
+ 1];
14293 *checksum_ptr
++ = hex_convert (p1
) << 0
14294 | hex_convert (p0
) << 4;
14298 * copy some data to generic buffers to make sorting happy
14301 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14302 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14303 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14304 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14305 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14306 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14307 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14308 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14309 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14311 salt
->salt_len
= 36;
14313 digest
[0] = krb5pa
->checksum
[0];
14314 digest
[1] = krb5pa
->checksum
[1];
14315 digest
[2] = krb5pa
->checksum
[2];
14316 digest
[3] = krb5pa
->checksum
[3];
14318 return (PARSER_OK
);
14321 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14323 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14325 u32
*digest
= (u32
*) hash_buf
->digest
;
14327 salt_t
*salt
= hash_buf
->salt
;
14333 char *salt_pos
= input_buf
;
14335 char *hash_pos
= strchr (salt_pos
, '$');
14337 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14339 uint salt_len
= hash_pos
- salt_pos
;
14341 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14345 uint hash_len
= input_len
- 1 - salt_len
;
14347 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14355 for (uint i
= 0; i
< salt_len
; i
++)
14357 if (salt_pos
[i
] == ' ') continue;
14362 // SAP user names cannot be longer than 12 characters
14363 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14365 // SAP user name cannot start with ! or ?
14366 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14372 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14374 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14376 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14378 salt
->salt_len
= salt_len
;
14380 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14381 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14385 digest
[0] = byte_swap_32 (digest
[0]);
14386 digest
[1] = byte_swap_32 (digest
[1]);
14388 return (PARSER_OK
);
14391 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14393 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14395 u32
*digest
= (u32
*) hash_buf
->digest
;
14397 salt_t
*salt
= hash_buf
->salt
;
14403 char *salt_pos
= input_buf
;
14405 char *hash_pos
= strchr (salt_pos
, '$');
14407 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14409 uint salt_len
= hash_pos
- salt_pos
;
14411 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14415 uint hash_len
= input_len
- 1 - salt_len
;
14417 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14425 for (uint i
= 0; i
< salt_len
; i
++)
14427 if (salt_pos
[i
] == ' ') continue;
14432 // SAP user names cannot be longer than 12 characters
14433 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14434 // so far nobody complained so we stay with this because it helps in optimization
14435 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14437 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14439 // SAP user name cannot start with ! or ?
14440 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14446 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14448 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14450 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14452 salt
->salt_len
= salt_len
;
14454 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14455 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14456 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14457 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14458 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14460 return (PARSER_OK
);
14463 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14465 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14467 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14469 u64
*digest
= (u64
*) hash_buf
->digest
;
14471 salt_t
*salt
= hash_buf
->salt
;
14473 char *iter_pos
= input_buf
+ 3;
14475 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14477 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14479 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14481 salt
->salt_iter
= salt_iter
;
14483 char *salt_pos
= iter_pos
+ 1;
14487 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14489 salt
->salt_len
= salt_len
;
14491 char *hash_pos
= salt_pos
+ salt_len
;
14493 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14497 char *tmp
= (char *) salt
->salt_buf_pc
;
14499 tmp
[0] = hash_pos
[42];
14503 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14504 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14505 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14506 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14512 return (PARSER_OK
);
14515 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14517 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14519 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14521 u32
*digest
= (u32
*) hash_buf
->digest
;
14523 salt_t
*salt
= hash_buf
->salt
;
14525 char *salt_buf
= input_buf
+ 6;
14527 uint salt_len
= 16;
14529 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14531 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14533 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14535 salt
->salt_len
= salt_len
;
14537 char *hash_pos
= input_buf
+ 6 + 16;
14539 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14540 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14541 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14542 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14543 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14544 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14545 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14546 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14548 return (PARSER_OK
);
14551 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14553 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14555 u32
*digest
= (u32
*) hash_buf
->digest
;
14557 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14558 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14562 return (PARSER_OK
);
14565 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14567 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14569 u32
*digest
= (u32
*) hash_buf
->digest
;
14571 salt_t
*salt
= hash_buf
->salt
;
14573 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14575 char *saltbuf_pos
= input_buf
;
14577 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14579 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14581 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14583 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14584 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14586 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14590 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14592 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14594 char *salt_ptr
= (char *) saltbuf_pos
;
14595 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14600 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14602 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14605 rakp_ptr
[j
] = 0x80;
14607 rakp
->salt_len
= j
;
14609 for (i
= 0; i
< 64; i
++)
14611 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14614 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14615 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14616 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14617 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14618 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14619 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14620 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14621 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14623 salt
->salt_len
= 32; // muss min. 32 haben
14625 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14626 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14627 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14628 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14629 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14631 return (PARSER_OK
);
14634 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14636 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14638 u32
*digest
= (u32
*) hash_buf
->digest
;
14640 salt_t
*salt
= hash_buf
->salt
;
14642 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14644 char *salt_pos
= input_buf
+ 1;
14646 memcpy (salt
->salt_buf
, salt_pos
, 8);
14648 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14649 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14651 salt
->salt_len
= 8;
14653 char *hash_pos
= salt_pos
+ 8;
14655 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14656 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14657 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14658 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14659 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14661 digest
[0] -= SHA1M_A
;
14662 digest
[1] -= SHA1M_B
;
14663 digest
[2] -= SHA1M_C
;
14664 digest
[3] -= SHA1M_D
;
14665 digest
[4] -= SHA1M_E
;
14667 return (PARSER_OK
);
14670 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14672 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14674 u32
*digest
= (u32
*) hash_buf
->digest
;
14676 salt_t
*salt
= hash_buf
->salt
;
14678 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14679 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14680 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14681 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14683 digest
[0] = byte_swap_32 (digest
[0]);
14684 digest
[1] = byte_swap_32 (digest
[1]);
14685 digest
[2] = byte_swap_32 (digest
[2]);
14686 digest
[3] = byte_swap_32 (digest
[3]);
14688 digest
[0] -= MD5M_A
;
14689 digest
[1] -= MD5M_B
;
14690 digest
[2] -= MD5M_C
;
14691 digest
[3] -= MD5M_D
;
14693 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14695 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14697 u32
*salt_buf
= salt
->salt_buf
;
14699 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14700 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14701 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14702 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14704 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14705 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14706 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14707 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14709 salt
->salt_len
= 16 + 1;
14711 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14713 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14715 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14717 return (PARSER_OK
);
14720 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14722 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14724 u32
*digest
= (u32
*) hash_buf
->digest
;
14726 salt_t
*salt
= hash_buf
->salt
;
14728 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14734 char *hashbuf_pos
= input_buf
;
14736 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14738 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14740 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14742 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14746 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14748 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14750 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14752 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14756 char *databuf_pos
= strchr (iteration_pos
, ':');
14758 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14760 const uint iteration_len
= databuf_pos
- iteration_pos
;
14762 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14763 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14765 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14767 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14768 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14774 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14775 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14776 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14777 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14778 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14779 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14780 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14781 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14785 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14787 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14789 const char p0
= saltbuf_pos
[i
+ 0];
14790 const char p1
= saltbuf_pos
[i
+ 1];
14792 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14793 | hex_convert (p0
) << 4;
14796 salt
->salt_buf
[4] = 0x01000000;
14797 salt
->salt_buf
[5] = 0x80;
14799 salt
->salt_len
= saltbuf_len
/ 2;
14803 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14807 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14809 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14811 const char p0
= databuf_pos
[i
+ 0];
14812 const char p1
= databuf_pos
[i
+ 1];
14814 *databuf_ptr
++ = hex_convert (p1
) << 0
14815 | hex_convert (p0
) << 4;
14818 *databuf_ptr
++ = 0x80;
14820 for (uint i
= 0; i
< 512; i
++)
14822 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14825 cloudkey
->data_len
= databuf_len
/ 2;
14827 return (PARSER_OK
);
14830 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14832 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14834 u32
*digest
= (u32
*) hash_buf
->digest
;
14836 salt_t
*salt
= hash_buf
->salt
;
14842 char *hashbuf_pos
= input_buf
;
14844 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14846 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14848 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14850 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14854 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14856 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14858 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14860 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14862 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14866 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14868 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14870 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14872 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14874 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14878 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14880 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14881 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14883 // ok, the plan for this algorithm is the following:
14884 // we have 2 salts here, the domain-name and a random salt
14885 // while both are used in the initial transformation,
14886 // only the random salt is used in the following iterations
14887 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14888 // and one that includes only the real salt (stored into salt_buf[]).
14889 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14891 u8 tmp_buf
[100] = { 0 };
14893 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14895 memcpy (digest
, tmp_buf
, 20);
14897 digest
[0] = byte_swap_32 (digest
[0]);
14898 digest
[1] = byte_swap_32 (digest
[1]);
14899 digest
[2] = byte_swap_32 (digest
[2]);
14900 digest
[3] = byte_swap_32 (digest
[3]);
14901 digest
[4] = byte_swap_32 (digest
[4]);
14905 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14907 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14909 char *len_ptr
= NULL
;
14911 for (uint i
= 0; i
< domainbuf_len
; i
++)
14913 if (salt_buf_pc_ptr
[i
] == '.')
14915 len_ptr
= &salt_buf_pc_ptr
[i
];
14925 salt
->salt_buf_pc
[7] = domainbuf_len
;
14929 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14931 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14933 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14935 salt
->salt_len
= salt_len
;
14939 salt
->salt_iter
= atoi (iteration_pos
);
14941 return (PARSER_OK
);
14944 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14946 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14948 u32
*digest
= (u32
*) hash_buf
->digest
;
14950 salt_t
*salt
= hash_buf
->salt
;
14952 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14953 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14954 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14955 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14956 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14958 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14960 uint salt_len
= input_len
- 40 - 1;
14962 char *salt_buf
= input_buf
+ 40 + 1;
14964 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14966 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14968 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14970 salt
->salt_len
= salt_len
;
14972 return (PARSER_OK
);
14975 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14977 const u8 ascii_to_ebcdic
[] =
14979 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14980 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14981 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14982 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14983 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14984 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14985 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14986 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14987 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14988 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14989 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14990 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14991 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14992 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14993 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14994 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14997 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14999 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15001 u32
*digest
= (u32
*) hash_buf
->digest
;
15003 salt_t
*salt
= hash_buf
->salt
;
15005 char *salt_pos
= input_buf
+ 6 + 1;
15007 char *digest_pos
= strchr (salt_pos
, '*');
15009 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15011 uint salt_len
= digest_pos
- salt_pos
;
15013 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
15015 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
15017 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
15021 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15022 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
15024 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
15026 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15028 salt
->salt_len
= salt_len
;
15030 for (uint i
= 0; i
< salt_len
; i
++)
15032 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
15034 for (uint i
= salt_len
; i
< 8; i
++)
15036 salt_buf_pc_ptr
[i
] = 0x40;
15041 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
15043 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
15044 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
15046 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
15047 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
15049 digest
[0] = byte_swap_32 (digest
[0]);
15050 digest
[1] = byte_swap_32 (digest
[1]);
15052 IP (digest
[0], digest
[1], tt
);
15054 digest
[0] = rotr32 (digest
[0], 29);
15055 digest
[1] = rotr32 (digest
[1], 29);
15059 return (PARSER_OK
);
15062 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15064 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
15066 u32
*digest
= (u32
*) hash_buf
->digest
;
15068 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15069 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15070 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15071 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15073 digest
[0] = byte_swap_32 (digest
[0]);
15074 digest
[1] = byte_swap_32 (digest
[1]);
15075 digest
[2] = byte_swap_32 (digest
[2]);
15076 digest
[3] = byte_swap_32 (digest
[3]);
15078 return (PARSER_OK
);
15081 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15083 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
15085 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15087 u32
*digest
= (u32
*) hash_buf
->digest
;
15089 salt_t
*salt
= hash_buf
->salt
;
15091 u8 tmp_buf
[120] = { 0 };
15093 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15095 tmp_buf
[3] += -4; // dont ask!
15097 memcpy (salt
->salt_buf
, tmp_buf
, 5);
15099 salt
->salt_len
= 5;
15101 memcpy (digest
, tmp_buf
+ 5, 9);
15103 // yes, only 9 byte are needed to crack, but 10 to display
15105 salt
->salt_buf_pc
[7] = input_buf
[20];
15107 return (PARSER_OK
);
15110 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15112 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
15114 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15116 u32
*digest
= (u32
*) hash_buf
->digest
;
15118 salt_t
*salt
= hash_buf
->salt
;
15120 u8 tmp_buf
[120] = { 0 };
15122 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15124 tmp_buf
[3] += -4; // dont ask!
15128 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15130 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)
15134 char tmp_iter_buf
[11] = { 0 };
15136 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15138 tmp_iter_buf
[10] = 0;
15140 salt
->salt_iter
= atoi (tmp_iter_buf
);
15142 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15144 return (PARSER_SALT_ITERATION
);
15147 salt
->salt_iter
--; // first round in init
15149 // 2 additional bytes for display only
15151 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15152 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15156 memcpy (digest
, tmp_buf
+ 28, 8);
15158 digest
[0] = byte_swap_32 (digest
[0]);
15159 digest
[1] = byte_swap_32 (digest
[1]);
15163 return (PARSER_OK
);
15166 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15168 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15170 u32
*digest
= (u32
*) hash_buf
->digest
;
15172 salt_t
*salt
= hash_buf
->salt
;
15174 char *salt_buf_pos
= input_buf
;
15176 char *hash_buf_pos
= salt_buf_pos
+ 6;
15178 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15179 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15180 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15181 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15182 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15183 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15184 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15185 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15187 digest
[0] -= SHA256M_A
;
15188 digest
[1] -= SHA256M_B
;
15189 digest
[2] -= SHA256M_C
;
15190 digest
[3] -= SHA256M_D
;
15191 digest
[4] -= SHA256M_E
;
15192 digest
[5] -= SHA256M_F
;
15193 digest
[6] -= SHA256M_G
;
15194 digest
[7] -= SHA256M_H
;
15196 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15198 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15200 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15202 salt
->salt_len
= salt_len
;
15204 return (PARSER_OK
);
15207 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15209 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15211 u32
*digest
= (u32
*) hash_buf
->digest
;
15213 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15215 salt_t
*salt
= hash_buf
->salt
;
15217 char *salt_buf
= input_buf
+ 6;
15219 char *digest_buf
= strchr (salt_buf
, '$');
15221 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15223 uint salt_len
= digest_buf
- salt_buf
;
15225 digest_buf
++; // skip the '$' symbol
15227 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15229 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15231 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15233 salt
->salt_len
= salt_len
;
15235 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15236 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15237 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15238 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15240 digest
[0] = byte_swap_32 (digest
[0]);
15241 digest
[1] = byte_swap_32 (digest
[1]);
15242 digest
[2] = byte_swap_32 (digest
[2]);
15243 digest
[3] = byte_swap_32 (digest
[3]);
15245 digest
[0] -= MD5M_A
;
15246 digest
[1] -= MD5M_B
;
15247 digest
[2] -= MD5M_C
;
15248 digest
[3] -= MD5M_D
;
15250 return (PARSER_OK
);
15253 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15255 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15257 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15259 u32
*digest
= (u32
*) hash_buf
->digest
;
15261 salt_t
*salt
= hash_buf
->salt
;
15263 char *salt_buf
= input_buf
+ 3;
15265 char *digest_buf
= strchr (salt_buf
, '$');
15267 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15269 uint salt_len
= digest_buf
- salt_buf
;
15271 digest_buf
++; // skip the '$' symbol
15273 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15275 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15277 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15279 salt_buf_ptr
[salt_len
] = 0x2d;
15281 salt
->salt_len
= salt_len
+ 1;
15283 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15284 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15285 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15286 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15288 digest
[0] = byte_swap_32 (digest
[0]);
15289 digest
[1] = byte_swap_32 (digest
[1]);
15290 digest
[2] = byte_swap_32 (digest
[2]);
15291 digest
[3] = byte_swap_32 (digest
[3]);
15293 digest
[0] -= MD5M_A
;
15294 digest
[1] -= MD5M_B
;
15295 digest
[2] -= MD5M_C
;
15296 digest
[3] -= MD5M_D
;
15298 return (PARSER_OK
);
15301 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15303 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15305 u32
*digest
= (u32
*) hash_buf
->digest
;
15307 salt_t
*salt
= hash_buf
->salt
;
15309 u8 tmp_buf
[100] = { 0 };
15311 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15313 memcpy (digest
, tmp_buf
, 20);
15315 digest
[0] = byte_swap_32 (digest
[0]);
15316 digest
[1] = byte_swap_32 (digest
[1]);
15317 digest
[2] = byte_swap_32 (digest
[2]);
15318 digest
[3] = byte_swap_32 (digest
[3]);
15319 digest
[4] = byte_swap_32 (digest
[4]);
15321 digest
[0] -= SHA1M_A
;
15322 digest
[1] -= SHA1M_B
;
15323 digest
[2] -= SHA1M_C
;
15324 digest
[3] -= SHA1M_D
;
15325 digest
[4] -= SHA1M_E
;
15327 salt
->salt_buf
[0] = 0x80;
15329 salt
->salt_len
= 0;
15331 return (PARSER_OK
);
15334 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15336 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15338 u32
*digest
= (u32
*) hash_buf
->digest
;
15340 salt_t
*salt
= hash_buf
->salt
;
15342 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15343 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15344 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15345 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15347 digest
[0] = byte_swap_32 (digest
[0]);
15348 digest
[1] = byte_swap_32 (digest
[1]);
15349 digest
[2] = byte_swap_32 (digest
[2]);
15350 digest
[3] = byte_swap_32 (digest
[3]);
15352 digest
[0] -= MD5M_A
;
15353 digest
[1] -= MD5M_B
;
15354 digest
[2] -= MD5M_C
;
15355 digest
[3] -= MD5M_D
;
15357 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15359 uint salt_len
= input_len
- 32 - 1;
15361 char *salt_buf
= input_buf
+ 32 + 1;
15363 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15365 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15367 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15370 * add static "salt" part
15373 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15377 salt
->salt_len
= salt_len
;
15379 return (PARSER_OK
);
15382 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15384 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15386 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15388 u32
*digest
= (u32
*) hash_buf
->digest
;
15390 salt_t
*salt
= hash_buf
->salt
;
15392 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15398 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15400 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15402 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15404 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15406 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15410 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15412 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15414 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15416 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15420 char *keybuf_pos
= strchr (keylen_pos
, '$');
15422 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15424 uint keylen_len
= keybuf_pos
- keylen_pos
;
15426 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15430 char *databuf_pos
= strchr (keybuf_pos
, '$');
15432 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15434 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15436 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15440 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15442 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15448 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15449 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15450 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15451 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15453 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15454 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15455 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15456 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15458 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15459 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15460 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15461 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15463 salt
->salt_len
= 16;
15464 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15466 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15468 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15471 return (PARSER_OK
);
15474 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15476 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15478 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15480 u32
*digest
= (u32
*) hash_buf
->digest
;
15482 salt_t
*salt
= hash_buf
->salt
;
15488 // first is the N salt parameter
15490 char *N_pos
= input_buf
+ 6;
15492 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15496 salt
->scrypt_N
= atoi (N_pos
);
15500 char *r_pos
= strchr (N_pos
, ':');
15502 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15506 salt
->scrypt_r
= atoi (r_pos
);
15510 char *p_pos
= strchr (r_pos
, ':');
15512 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15516 salt
->scrypt_p
= atoi (p_pos
);
15520 char *saltbuf_pos
= strchr (p_pos
, ':');
15522 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15526 char *hash_pos
= strchr (saltbuf_pos
, ':');
15528 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15534 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15536 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15538 u8 tmp_buf
[33] = { 0 };
15540 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15542 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15544 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15546 salt
->salt_len
= tmp_len
;
15547 salt
->salt_iter
= 1;
15549 // digest - base64 decode
15551 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15553 tmp_len
= input_len
- (hash_pos
- input_buf
);
15555 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15557 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15559 memcpy (digest
, tmp_buf
, 32);
15561 return (PARSER_OK
);
15564 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15566 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15568 u32
*digest
= (u32
*) hash_buf
->digest
;
15570 salt_t
*salt
= hash_buf
->salt
;
15576 char decrypted
[76] = { 0 }; // iv + hash
15578 juniper_decrypt_hash (input_buf
, decrypted
);
15580 char *md5crypt_hash
= decrypted
+ 12;
15582 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15584 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15586 char *salt_pos
= md5crypt_hash
+ 3;
15588 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15590 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15592 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15596 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15598 return (PARSER_OK
);
15601 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15603 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15605 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15607 u32
*digest
= (u32
*) hash_buf
->digest
;
15609 salt_t
*salt
= hash_buf
->salt
;
15611 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15617 // first is *raw* salt
15619 char *salt_pos
= input_buf
+ 3;
15621 char *hash_pos
= strchr (salt_pos
, '$');
15623 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15625 uint salt_len
= hash_pos
- salt_pos
;
15627 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15631 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15633 memcpy (salt_buf_ptr
, salt_pos
, 14);
15635 salt_buf_ptr
[17] = 0x01;
15636 salt_buf_ptr
[18] = 0x80;
15638 // add some stuff to normal salt to make sorted happy
15640 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15641 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15642 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15643 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15645 salt
->salt_len
= salt_len
;
15646 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15648 // base64 decode hash
15650 u8 tmp_buf
[100] = { 0 };
15652 uint hash_len
= input_len
- 3 - salt_len
- 1;
15654 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15656 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15658 memcpy (digest
, tmp_buf
, 32);
15660 digest
[0] = byte_swap_32 (digest
[0]);
15661 digest
[1] = byte_swap_32 (digest
[1]);
15662 digest
[2] = byte_swap_32 (digest
[2]);
15663 digest
[3] = byte_swap_32 (digest
[3]);
15664 digest
[4] = byte_swap_32 (digest
[4]);
15665 digest
[5] = byte_swap_32 (digest
[5]);
15666 digest
[6] = byte_swap_32 (digest
[6]);
15667 digest
[7] = byte_swap_32 (digest
[7]);
15669 return (PARSER_OK
);
15672 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15674 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15676 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15678 u32
*digest
= (u32
*) hash_buf
->digest
;
15680 salt_t
*salt
= hash_buf
->salt
;
15686 // first is *raw* salt
15688 char *salt_pos
= input_buf
+ 3;
15690 char *hash_pos
= strchr (salt_pos
, '$');
15692 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15694 uint salt_len
= hash_pos
- salt_pos
;
15696 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15698 salt
->salt_len
= salt_len
;
15701 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15703 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15704 salt_buf_ptr
[salt_len
] = 0;
15706 // base64 decode hash
15708 u8 tmp_buf
[100] = { 0 };
15710 uint hash_len
= input_len
- 3 - salt_len
- 1;
15712 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15714 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15716 memcpy (digest
, tmp_buf
, 32);
15719 salt
->scrypt_N
= 16384;
15720 salt
->scrypt_r
= 1;
15721 salt
->scrypt_p
= 1;
15722 salt
->salt_iter
= 1;
15724 return (PARSER_OK
);
15727 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15729 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15731 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15733 u32
*digest
= (u32
*) hash_buf
->digest
;
15735 salt_t
*salt
= hash_buf
->salt
;
15737 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15743 char *version_pos
= input_buf
+ 8 + 1;
15745 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15747 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15749 u32 version_len
= verifierHashSize_pos
- version_pos
;
15751 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15753 verifierHashSize_pos
++;
15755 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15757 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15759 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15761 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15765 char *saltSize_pos
= strchr (keySize_pos
, '*');
15767 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15769 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15771 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15775 char *osalt_pos
= strchr (saltSize_pos
, '*');
15777 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15779 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15781 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15785 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15787 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15789 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15791 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15793 encryptedVerifier_pos
++;
15795 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15797 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15799 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15801 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15803 encryptedVerifierHash_pos
++;
15805 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;
15807 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15809 const uint version
= atoi (version_pos
);
15811 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15813 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15815 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15817 const uint keySize
= atoi (keySize_pos
);
15819 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15821 office2007
->keySize
= keySize
;
15823 const uint saltSize
= atoi (saltSize_pos
);
15825 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15831 salt
->salt_len
= 16;
15832 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15834 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15835 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15836 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15837 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15843 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15844 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15845 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15846 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15848 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15849 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15850 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15851 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15852 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15858 digest
[0] = office2007
->encryptedVerifierHash
[0];
15859 digest
[1] = office2007
->encryptedVerifierHash
[1];
15860 digest
[2] = office2007
->encryptedVerifierHash
[2];
15861 digest
[3] = office2007
->encryptedVerifierHash
[3];
15863 return (PARSER_OK
);
15866 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15868 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15870 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15872 u32
*digest
= (u32
*) hash_buf
->digest
;
15874 salt_t
*salt
= hash_buf
->salt
;
15876 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15882 char *version_pos
= input_buf
+ 8 + 1;
15884 char *spinCount_pos
= strchr (version_pos
, '*');
15886 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15888 u32 version_len
= spinCount_pos
- version_pos
;
15890 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15894 char *keySize_pos
= strchr (spinCount_pos
, '*');
15896 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15898 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15900 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15904 char *saltSize_pos
= strchr (keySize_pos
, '*');
15906 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15908 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15910 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15914 char *osalt_pos
= strchr (saltSize_pos
, '*');
15916 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15918 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15920 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15924 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15926 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15928 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15930 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15932 encryptedVerifier_pos
++;
15934 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15936 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15938 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15940 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15942 encryptedVerifierHash_pos
++;
15944 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;
15946 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15948 const uint version
= atoi (version_pos
);
15950 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15952 const uint spinCount
= atoi (spinCount_pos
);
15954 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15956 const uint keySize
= atoi (keySize_pos
);
15958 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15960 const uint saltSize
= atoi (saltSize_pos
);
15962 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15968 salt
->salt_len
= 16;
15969 salt
->salt_iter
= spinCount
;
15971 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15972 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15973 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15974 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15980 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15981 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15982 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15983 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15985 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15986 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15987 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15988 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15989 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15990 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15991 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15992 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15998 digest
[0] = office2010
->encryptedVerifierHash
[0];
15999 digest
[1] = office2010
->encryptedVerifierHash
[1];
16000 digest
[2] = office2010
->encryptedVerifierHash
[2];
16001 digest
[3] = office2010
->encryptedVerifierHash
[3];
16003 return (PARSER_OK
);
16006 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16008 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
16010 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
16012 u32
*digest
= (u32
*) hash_buf
->digest
;
16014 salt_t
*salt
= hash_buf
->salt
;
16016 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
16022 char *version_pos
= input_buf
+ 8 + 1;
16024 char *spinCount_pos
= strchr (version_pos
, '*');
16026 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16028 u32 version_len
= spinCount_pos
- version_pos
;
16030 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
16034 char *keySize_pos
= strchr (spinCount_pos
, '*');
16036 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16038 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
16040 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
16044 char *saltSize_pos
= strchr (keySize_pos
, '*');
16046 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16048 u32 keySize_len
= saltSize_pos
- keySize_pos
;
16050 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
16054 char *osalt_pos
= strchr (saltSize_pos
, '*');
16056 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16058 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
16060 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
16064 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16066 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16068 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16070 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16072 encryptedVerifier_pos
++;
16074 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16076 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16078 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16080 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16082 encryptedVerifierHash_pos
++;
16084 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;
16086 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
16088 const uint version
= atoi (version_pos
);
16090 if (version
!= 2013) return (PARSER_SALT_VALUE
);
16092 const uint spinCount
= atoi (spinCount_pos
);
16094 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
16096 const uint keySize
= atoi (keySize_pos
);
16098 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
16100 const uint saltSize
= atoi (saltSize_pos
);
16102 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
16108 salt
->salt_len
= 16;
16109 salt
->salt_iter
= spinCount
;
16111 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16112 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16113 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16114 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16120 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16121 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16122 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16123 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16125 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16126 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16127 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16128 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16129 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16130 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16131 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16132 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16138 digest
[0] = office2013
->encryptedVerifierHash
[0];
16139 digest
[1] = office2013
->encryptedVerifierHash
[1];
16140 digest
[2] = office2013
->encryptedVerifierHash
[2];
16141 digest
[3] = office2013
->encryptedVerifierHash
[3];
16143 return (PARSER_OK
);
16146 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16148 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16150 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16152 u32
*digest
= (u32
*) hash_buf
->digest
;
16154 salt_t
*salt
= hash_buf
->salt
;
16156 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16162 char *version_pos
= input_buf
+ 11;
16164 char *osalt_pos
= strchr (version_pos
, '*');
16166 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16168 u32 version_len
= osalt_pos
- version_pos
;
16170 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16174 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16176 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16178 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16180 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16182 encryptedVerifier_pos
++;
16184 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16186 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16188 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16190 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16192 encryptedVerifierHash_pos
++;
16194 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16196 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16198 const uint version
= *version_pos
- 0x30;
16200 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16206 oldoffice01
->version
= version
;
16208 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16209 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16210 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16211 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16213 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16214 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16215 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16216 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16218 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16219 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16220 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16221 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16223 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16224 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16225 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16226 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16232 salt
->salt_len
= 16;
16234 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16235 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16236 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16237 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16239 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16240 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16241 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16242 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16244 // this is a workaround as office produces multiple documents with the same salt
16246 salt
->salt_len
+= 32;
16248 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16249 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16250 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16251 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16252 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16253 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16254 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16255 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16261 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16262 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16263 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16264 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16266 return (PARSER_OK
);
16269 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16271 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16274 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16276 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16278 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16280 u32
*digest
= (u32
*) hash_buf
->digest
;
16282 salt_t
*salt
= hash_buf
->salt
;
16284 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16290 char *version_pos
= input_buf
+ 11;
16292 char *osalt_pos
= strchr (version_pos
, '*');
16294 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16296 u32 version_len
= osalt_pos
- version_pos
;
16298 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16302 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16304 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16306 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16308 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16310 encryptedVerifier_pos
++;
16312 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16314 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16316 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16318 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16320 encryptedVerifierHash_pos
++;
16322 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16324 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16326 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16328 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16332 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16334 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16336 const uint version
= *version_pos
- 0x30;
16338 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16344 oldoffice01
->version
= version
;
16346 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16347 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16348 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16349 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16351 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16352 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16353 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16354 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16356 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16357 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16358 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16359 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16361 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16362 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16363 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16364 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16366 oldoffice01
->rc4key
[1] = 0;
16367 oldoffice01
->rc4key
[0] = 0;
16369 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16370 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16371 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16372 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16373 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16374 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16375 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16376 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16377 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16378 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16380 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16381 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16387 salt
->salt_len
= 16;
16389 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16390 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16391 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16392 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16394 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16395 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16396 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16397 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16399 // this is a workaround as office produces multiple documents with the same salt
16401 salt
->salt_len
+= 32;
16403 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16404 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16405 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16406 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16407 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16408 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16409 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16410 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16416 digest
[0] = oldoffice01
->rc4key
[0];
16417 digest
[1] = oldoffice01
->rc4key
[1];
16421 return (PARSER_OK
);
16424 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16426 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16428 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16430 u32
*digest
= (u32
*) hash_buf
->digest
;
16432 salt_t
*salt
= hash_buf
->salt
;
16434 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16440 char *version_pos
= input_buf
+ 11;
16442 char *osalt_pos
= strchr (version_pos
, '*');
16444 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16446 u32 version_len
= osalt_pos
- version_pos
;
16448 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16452 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16454 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16456 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16458 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16460 encryptedVerifier_pos
++;
16462 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16464 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16466 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16468 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16470 encryptedVerifierHash_pos
++;
16472 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16474 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16476 const uint version
= *version_pos
- 0x30;
16478 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16484 oldoffice34
->version
= version
;
16486 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16487 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16488 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16489 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16491 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16492 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16493 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16494 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16496 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16497 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16498 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16499 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16500 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16502 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16503 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16504 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16505 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16506 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16512 salt
->salt_len
= 16;
16514 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16515 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16516 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16517 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16519 // this is a workaround as office produces multiple documents with the same salt
16521 salt
->salt_len
+= 32;
16523 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16524 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16525 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16526 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16527 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16528 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16529 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16530 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16536 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16537 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16538 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16539 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16541 return (PARSER_OK
);
16544 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16546 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16548 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16551 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16553 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16555 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16557 u32
*digest
= (u32
*) hash_buf
->digest
;
16559 salt_t
*salt
= hash_buf
->salt
;
16561 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16567 char *version_pos
= input_buf
+ 11;
16569 char *osalt_pos
= strchr (version_pos
, '*');
16571 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16573 u32 version_len
= osalt_pos
- version_pos
;
16575 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16579 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16581 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16583 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16585 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16587 encryptedVerifier_pos
++;
16589 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16591 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16593 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16595 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16597 encryptedVerifierHash_pos
++;
16599 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16601 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16603 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16605 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16609 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16611 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16613 const uint version
= *version_pos
- 0x30;
16615 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16621 oldoffice34
->version
= version
;
16623 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16624 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16625 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16626 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16628 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16629 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16630 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16631 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16633 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16634 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16635 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16636 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16637 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16639 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16640 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16641 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16642 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16643 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16645 oldoffice34
->rc4key
[1] = 0;
16646 oldoffice34
->rc4key
[0] = 0;
16648 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16649 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16650 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16651 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16652 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16653 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16654 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16655 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16656 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16657 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16659 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16660 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16666 salt
->salt_len
= 16;
16668 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16669 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16670 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16671 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16673 // this is a workaround as office produces multiple documents with the same salt
16675 salt
->salt_len
+= 32;
16677 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16678 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16679 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16680 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16681 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16682 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16683 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16684 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16690 digest
[0] = oldoffice34
->rc4key
[0];
16691 digest
[1] = oldoffice34
->rc4key
[1];
16695 return (PARSER_OK
);
16698 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16700 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16702 u32
*digest
= (u32
*) hash_buf
->digest
;
16704 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16705 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16706 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16707 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16709 digest
[0] = byte_swap_32 (digest
[0]);
16710 digest
[1] = byte_swap_32 (digest
[1]);
16711 digest
[2] = byte_swap_32 (digest
[2]);
16712 digest
[3] = byte_swap_32 (digest
[3]);
16714 return (PARSER_OK
);
16717 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16719 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16721 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16723 u32
*digest
= (u32
*) hash_buf
->digest
;
16725 salt_t
*salt
= hash_buf
->salt
;
16727 char *signature_pos
= input_buf
;
16729 char *salt_pos
= strchr (signature_pos
, '$');
16731 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16733 u32 signature_len
= salt_pos
- signature_pos
;
16735 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16739 char *hash_pos
= strchr (salt_pos
, '$');
16741 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16743 u32 salt_len
= hash_pos
- salt_pos
;
16745 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16749 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16751 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16753 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16754 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16755 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16756 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16757 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16759 digest
[0] -= SHA1M_A
;
16760 digest
[1] -= SHA1M_B
;
16761 digest
[2] -= SHA1M_C
;
16762 digest
[3] -= SHA1M_D
;
16763 digest
[4] -= SHA1M_E
;
16765 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16767 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16769 salt
->salt_len
= salt_len
;
16771 return (PARSER_OK
);
16774 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16776 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16778 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16780 u32
*digest
= (u32
*) hash_buf
->digest
;
16782 salt_t
*salt
= hash_buf
->salt
;
16784 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16790 char *iter_pos
= input_buf
+ 14;
16792 const int iter
= atoi (iter_pos
);
16794 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16796 salt
->salt_iter
= iter
- 1;
16798 char *salt_pos
= strchr (iter_pos
, '$');
16800 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16804 char *hash_pos
= strchr (salt_pos
, '$');
16806 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16808 const uint salt_len
= hash_pos
- salt_pos
;
16812 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16814 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16816 salt
->salt_len
= salt_len
;
16818 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16819 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16821 // add some stuff to normal salt to make sorted happy
16823 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16824 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16825 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16826 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16827 salt
->salt_buf
[4] = salt
->salt_iter
;
16829 // base64 decode hash
16831 u8 tmp_buf
[100] = { 0 };
16833 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16835 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16837 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16839 memcpy (digest
, tmp_buf
, 32);
16841 digest
[0] = byte_swap_32 (digest
[0]);
16842 digest
[1] = byte_swap_32 (digest
[1]);
16843 digest
[2] = byte_swap_32 (digest
[2]);
16844 digest
[3] = byte_swap_32 (digest
[3]);
16845 digest
[4] = byte_swap_32 (digest
[4]);
16846 digest
[5] = byte_swap_32 (digest
[5]);
16847 digest
[6] = byte_swap_32 (digest
[6]);
16848 digest
[7] = byte_swap_32 (digest
[7]);
16850 return (PARSER_OK
);
16853 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16855 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16857 u32
*digest
= (u32
*) hash_buf
->digest
;
16859 salt_t
*salt
= hash_buf
->salt
;
16861 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16862 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16866 digest
[0] = byte_swap_32 (digest
[0]);
16867 digest
[1] = byte_swap_32 (digest
[1]);
16869 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16870 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16871 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16873 char iter_c
= input_buf
[17];
16874 char iter_d
= input_buf
[19];
16876 // atm only defaults, let's see if there's more request
16877 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16878 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16880 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16882 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16883 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16884 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16885 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16887 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16888 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16889 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16890 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16892 salt
->salt_len
= 16;
16894 return (PARSER_OK
);
16897 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16899 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16901 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16903 u32
*digest
= (u32
*) hash_buf
->digest
;
16905 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16907 salt_t
*salt
= hash_buf
->salt
;
16909 char *salt_pos
= input_buf
+ 10;
16911 char *hash_pos
= strchr (salt_pos
, '$');
16913 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16915 uint salt_len
= hash_pos
- salt_pos
;
16919 uint hash_len
= input_len
- 10 - salt_len
- 1;
16921 // base64 decode salt
16923 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16925 u8 tmp_buf
[100] = { 0 };
16927 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16929 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16931 tmp_buf
[salt_len
] = 0x80;
16933 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16935 salt
->salt_len
= salt_len
;
16937 // base64 decode hash
16939 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16941 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16943 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16945 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16947 uint user_len
= hash_len
- 32;
16949 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16951 user_len
--; // skip the trailing space
16953 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16954 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16955 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16956 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16958 digest
[0] = byte_swap_32 (digest
[0]);
16959 digest
[1] = byte_swap_32 (digest
[1]);
16960 digest
[2] = byte_swap_32 (digest
[2]);
16961 digest
[3] = byte_swap_32 (digest
[3]);
16963 // store username for host only (output hash if cracked)
16965 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16966 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16968 return (PARSER_OK
);
16971 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16973 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16975 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16977 u32
*digest
= (u32
*) hash_buf
->digest
;
16979 salt_t
*salt
= hash_buf
->salt
;
16981 char *iter_pos
= input_buf
+ 10;
16983 u32 iter
= atoi (iter_pos
);
16987 return (PARSER_SALT_ITERATION
);
16990 iter
--; // first iteration is special
16992 salt
->salt_iter
= iter
;
16994 char *base64_pos
= strchr (iter_pos
, '}');
16996 if (base64_pos
== NULL
)
16998 return (PARSER_SIGNATURE_UNMATCHED
);
17003 // base64 decode salt
17005 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
17007 u8 tmp_buf
[100] = { 0 };
17009 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
17011 if (decoded_len
< 24)
17013 return (PARSER_SALT_LENGTH
);
17018 uint salt_len
= decoded_len
- 20;
17020 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
17021 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
17023 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
17025 salt
->salt_len
= salt_len
;
17029 u32
*digest_ptr
= (u32
*) tmp_buf
;
17031 digest
[0] = byte_swap_32 (digest_ptr
[0]);
17032 digest
[1] = byte_swap_32 (digest_ptr
[1]);
17033 digest
[2] = byte_swap_32 (digest_ptr
[2]);
17034 digest
[3] = byte_swap_32 (digest_ptr
[3]);
17035 digest
[4] = byte_swap_32 (digest_ptr
[4]);
17037 return (PARSER_OK
);
17040 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17042 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
17044 u32
*digest
= (u32
*) hash_buf
->digest
;
17046 salt_t
*salt
= hash_buf
->salt
;
17048 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17049 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17050 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17051 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17052 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
17054 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17056 uint salt_len
= input_len
- 40 - 1;
17058 char *salt_buf
= input_buf
+ 40 + 1;
17060 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17062 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17064 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
17066 salt
->salt_len
= salt_len
;
17068 return (PARSER_OK
);
17071 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17073 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
17075 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17077 u32
*digest
= (u32
*) hash_buf
->digest
;
17079 salt_t
*salt
= hash_buf
->salt
;
17081 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17087 char *V_pos
= input_buf
+ 5;
17089 char *R_pos
= strchr (V_pos
, '*');
17091 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17093 u32 V_len
= R_pos
- V_pos
;
17097 char *bits_pos
= strchr (R_pos
, '*');
17099 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17101 u32 R_len
= bits_pos
- R_pos
;
17105 char *P_pos
= strchr (bits_pos
, '*');
17107 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17109 u32 bits_len
= P_pos
- bits_pos
;
17113 char *enc_md_pos
= strchr (P_pos
, '*');
17115 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17117 u32 P_len
= enc_md_pos
- P_pos
;
17121 char *id_len_pos
= strchr (enc_md_pos
, '*');
17123 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17125 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17129 char *id_buf_pos
= strchr (id_len_pos
, '*');
17131 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17133 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17137 char *u_len_pos
= strchr (id_buf_pos
, '*');
17139 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17141 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17143 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17147 char *u_buf_pos
= strchr (u_len_pos
, '*');
17149 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17151 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17155 char *o_len_pos
= strchr (u_buf_pos
, '*');
17157 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17159 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17161 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17165 char *o_buf_pos
= strchr (o_len_pos
, '*');
17167 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17169 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17173 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;
17175 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17179 const int V
= atoi (V_pos
);
17180 const int R
= atoi (R_pos
);
17181 const int P
= atoi (P_pos
);
17183 if (V
!= 1) return (PARSER_SALT_VALUE
);
17184 if (R
!= 2) return (PARSER_SALT_VALUE
);
17186 const int enc_md
= atoi (enc_md_pos
);
17188 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17190 const int id_len
= atoi (id_len_pos
);
17191 const int u_len
= atoi (u_len_pos
);
17192 const int o_len
= atoi (o_len_pos
);
17194 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17195 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17196 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17198 const int bits
= atoi (bits_pos
);
17200 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17202 // copy data to esalt
17208 pdf
->enc_md
= enc_md
;
17210 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17211 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17212 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17213 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17214 pdf
->id_len
= id_len
;
17216 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17217 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17218 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17219 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17220 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17221 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17222 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17223 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17224 pdf
->u_len
= u_len
;
17226 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17227 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17228 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17229 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17230 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17231 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17232 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17233 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17234 pdf
->o_len
= o_len
;
17236 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17237 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17238 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17239 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17241 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17242 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17243 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17244 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17245 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17246 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17247 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17248 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17250 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17251 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17252 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17253 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17254 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17255 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17256 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17257 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17259 // we use ID for salt, maybe needs to change, we will see...
17261 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17262 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17263 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17264 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17265 salt
->salt_len
= pdf
->id_len
;
17267 digest
[0] = pdf
->u_buf
[0];
17268 digest
[1] = pdf
->u_buf
[1];
17269 digest
[2] = pdf
->u_buf
[2];
17270 digest
[3] = pdf
->u_buf
[3];
17272 return (PARSER_OK
);
17275 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17277 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17280 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17282 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17284 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17286 u32
*digest
= (u32
*) hash_buf
->digest
;
17288 salt_t
*salt
= hash_buf
->salt
;
17290 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17296 char *V_pos
= input_buf
+ 5;
17298 char *R_pos
= strchr (V_pos
, '*');
17300 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17302 u32 V_len
= R_pos
- V_pos
;
17306 char *bits_pos
= strchr (R_pos
, '*');
17308 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17310 u32 R_len
= bits_pos
- R_pos
;
17314 char *P_pos
= strchr (bits_pos
, '*');
17316 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17318 u32 bits_len
= P_pos
- bits_pos
;
17322 char *enc_md_pos
= strchr (P_pos
, '*');
17324 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17326 u32 P_len
= enc_md_pos
- P_pos
;
17330 char *id_len_pos
= strchr (enc_md_pos
, '*');
17332 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17334 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17338 char *id_buf_pos
= strchr (id_len_pos
, '*');
17340 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17342 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17346 char *u_len_pos
= strchr (id_buf_pos
, '*');
17348 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17350 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17352 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17356 char *u_buf_pos
= strchr (u_len_pos
, '*');
17358 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17360 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17364 char *o_len_pos
= strchr (u_buf_pos
, '*');
17366 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17368 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17370 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17374 char *o_buf_pos
= strchr (o_len_pos
, '*');
17376 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17378 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17382 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17384 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17386 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17388 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17392 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;
17394 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17398 const int V
= atoi (V_pos
);
17399 const int R
= atoi (R_pos
);
17400 const int P
= atoi (P_pos
);
17402 if (V
!= 1) return (PARSER_SALT_VALUE
);
17403 if (R
!= 2) return (PARSER_SALT_VALUE
);
17405 const int enc_md
= atoi (enc_md_pos
);
17407 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17409 const int id_len
= atoi (id_len_pos
);
17410 const int u_len
= atoi (u_len_pos
);
17411 const int o_len
= atoi (o_len_pos
);
17413 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17414 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17415 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17417 const int bits
= atoi (bits_pos
);
17419 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17421 // copy data to esalt
17427 pdf
->enc_md
= enc_md
;
17429 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17430 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17431 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17432 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17433 pdf
->id_len
= id_len
;
17435 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17436 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17437 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17438 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17439 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17440 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17441 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17442 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17443 pdf
->u_len
= u_len
;
17445 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17446 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17447 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17448 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17449 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17450 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17451 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17452 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17453 pdf
->o_len
= o_len
;
17455 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17456 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17457 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17458 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17460 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17461 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17462 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17463 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17464 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17465 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17466 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17467 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17469 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17470 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17471 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17472 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17473 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17474 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17475 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17476 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17478 pdf
->rc4key
[1] = 0;
17479 pdf
->rc4key
[0] = 0;
17481 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17482 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17483 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17484 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17485 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17486 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17487 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17488 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17489 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17490 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17492 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17493 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17495 // we use ID for salt, maybe needs to change, we will see...
17497 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17498 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17499 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17500 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17501 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17502 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17503 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17504 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17505 salt
->salt_len
= pdf
->id_len
+ 16;
17507 digest
[0] = pdf
->rc4key
[0];
17508 digest
[1] = pdf
->rc4key
[1];
17512 return (PARSER_OK
);
17515 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17517 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17519 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17521 u32
*digest
= (u32
*) hash_buf
->digest
;
17523 salt_t
*salt
= hash_buf
->salt
;
17525 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17531 char *V_pos
= input_buf
+ 5;
17533 char *R_pos
= strchr (V_pos
, '*');
17535 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17537 u32 V_len
= R_pos
- V_pos
;
17541 char *bits_pos
= strchr (R_pos
, '*');
17543 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17545 u32 R_len
= bits_pos
- R_pos
;
17549 char *P_pos
= strchr (bits_pos
, '*');
17551 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17553 u32 bits_len
= P_pos
- bits_pos
;
17557 char *enc_md_pos
= strchr (P_pos
, '*');
17559 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17561 u32 P_len
= enc_md_pos
- P_pos
;
17565 char *id_len_pos
= strchr (enc_md_pos
, '*');
17567 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17569 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17573 char *id_buf_pos
= strchr (id_len_pos
, '*');
17575 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17577 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17581 char *u_len_pos
= strchr (id_buf_pos
, '*');
17583 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17585 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17587 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17591 char *u_buf_pos
= strchr (u_len_pos
, '*');
17593 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17595 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17599 char *o_len_pos
= strchr (u_buf_pos
, '*');
17601 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17603 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17605 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17609 char *o_buf_pos
= strchr (o_len_pos
, '*');
17611 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17613 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17617 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;
17619 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17623 const int V
= atoi (V_pos
);
17624 const int R
= atoi (R_pos
);
17625 const int P
= atoi (P_pos
);
17629 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17630 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17632 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17634 const int id_len
= atoi (id_len_pos
);
17635 const int u_len
= atoi (u_len_pos
);
17636 const int o_len
= atoi (o_len_pos
);
17638 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17640 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17641 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17643 const int bits
= atoi (bits_pos
);
17645 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17651 enc_md
= atoi (enc_md_pos
);
17654 // copy data to esalt
17660 pdf
->enc_md
= enc_md
;
17662 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17663 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17664 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17665 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17669 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17670 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17671 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17672 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17675 pdf
->id_len
= id_len
;
17677 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17678 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17679 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17680 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17681 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17682 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17683 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17684 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17685 pdf
->u_len
= u_len
;
17687 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17688 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17689 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17690 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17691 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17692 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17693 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17694 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17695 pdf
->o_len
= o_len
;
17697 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17698 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17699 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17700 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17704 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17705 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17706 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17707 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17710 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17711 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17712 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17713 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17714 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17715 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17716 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17717 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17719 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17720 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17721 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17722 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17723 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17724 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17725 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17726 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17728 // precompute rc4 data for later use
17744 uint salt_pc_block
[32] = { 0 };
17746 char *salt_pc_ptr
= (char *) salt_pc_block
;
17748 memcpy (salt_pc_ptr
, padding
, 32);
17749 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17751 uint salt_pc_digest
[4] = { 0 };
17753 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17755 pdf
->rc4data
[0] = salt_pc_digest
[0];
17756 pdf
->rc4data
[1] = salt_pc_digest
[1];
17758 // we use ID for salt, maybe needs to change, we will see...
17760 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17761 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17762 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17763 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17764 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17765 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17766 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17767 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17768 salt
->salt_len
= pdf
->id_len
+ 16;
17770 salt
->salt_iter
= ROUNDS_PDF14
;
17772 digest
[0] = pdf
->u_buf
[0];
17773 digest
[1] = pdf
->u_buf
[1];
17777 return (PARSER_OK
);
17780 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17782 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17784 if (ret
!= PARSER_OK
)
17789 u32
*digest
= (u32
*) hash_buf
->digest
;
17791 salt_t
*salt
= hash_buf
->salt
;
17793 digest
[0] -= SHA256M_A
;
17794 digest
[1] -= SHA256M_B
;
17795 digest
[2] -= SHA256M_C
;
17796 digest
[3] -= SHA256M_D
;
17797 digest
[4] -= SHA256M_E
;
17798 digest
[5] -= SHA256M_F
;
17799 digest
[6] -= SHA256M_G
;
17800 digest
[7] -= SHA256M_H
;
17802 salt
->salt_buf
[2] = 0x80;
17804 return (PARSER_OK
);
17807 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17809 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17811 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17813 u32
*digest
= (u32
*) hash_buf
->digest
;
17815 salt_t
*salt
= hash_buf
->salt
;
17817 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17823 char *V_pos
= input_buf
+ 5;
17825 char *R_pos
= strchr (V_pos
, '*');
17827 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17829 u32 V_len
= R_pos
- V_pos
;
17833 char *bits_pos
= strchr (R_pos
, '*');
17835 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17837 u32 R_len
= bits_pos
- R_pos
;
17841 char *P_pos
= strchr (bits_pos
, '*');
17843 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17845 u32 bits_len
= P_pos
- bits_pos
;
17849 char *enc_md_pos
= strchr (P_pos
, '*');
17851 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17853 u32 P_len
= enc_md_pos
- P_pos
;
17857 char *id_len_pos
= strchr (enc_md_pos
, '*');
17859 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17861 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17865 char *id_buf_pos
= strchr (id_len_pos
, '*');
17867 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17869 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17873 char *u_len_pos
= strchr (id_buf_pos
, '*');
17875 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17877 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17881 char *u_buf_pos
= strchr (u_len_pos
, '*');
17883 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17885 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17889 char *o_len_pos
= strchr (u_buf_pos
, '*');
17891 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17893 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17897 char *o_buf_pos
= strchr (o_len_pos
, '*');
17899 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17901 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17905 char *last
= strchr (o_buf_pos
, '*');
17907 if (last
== NULL
) last
= input_buf
+ input_len
;
17909 u32 o_buf_len
= last
- o_buf_pos
;
17913 const int V
= atoi (V_pos
);
17914 const int R
= atoi (R_pos
);
17918 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17919 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17921 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17923 const int bits
= atoi (bits_pos
);
17925 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17927 int enc_md
= atoi (enc_md_pos
);
17929 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17931 const uint id_len
= atoi (id_len_pos
);
17932 const uint u_len
= atoi (u_len_pos
);
17933 const uint o_len
= atoi (o_len_pos
);
17935 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17936 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17937 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17938 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17939 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17940 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17941 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17942 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17944 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17945 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17946 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17948 // copy data to esalt
17950 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17952 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17954 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17957 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17958 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17960 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17961 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17963 salt
->salt_len
= 8;
17964 salt
->salt_iter
= ROUNDS_PDF17L8
;
17966 digest
[0] = pdf
->u_buf
[0];
17967 digest
[1] = pdf
->u_buf
[1];
17968 digest
[2] = pdf
->u_buf
[2];
17969 digest
[3] = pdf
->u_buf
[3];
17970 digest
[4] = pdf
->u_buf
[4];
17971 digest
[5] = pdf
->u_buf
[5];
17972 digest
[6] = pdf
->u_buf
[6];
17973 digest
[7] = pdf
->u_buf
[7];
17975 return (PARSER_OK
);
17978 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17980 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17982 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17984 u32
*digest
= (u32
*) hash_buf
->digest
;
17986 salt_t
*salt
= hash_buf
->salt
;
17988 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17996 char *iter_pos
= input_buf
+ 7;
17998 u32 iter
= atoi (iter_pos
);
18000 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18001 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18003 // first is *raw* salt
18005 char *salt_pos
= strchr (iter_pos
, ':');
18007 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18011 char *hash_pos
= strchr (salt_pos
, ':');
18013 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18015 u32 salt_len
= hash_pos
- salt_pos
;
18017 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18021 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18023 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18027 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
18029 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18031 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18033 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18034 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18036 salt
->salt_len
= salt_len
;
18037 salt
->salt_iter
= iter
- 1;
18041 u8 tmp_buf
[100] = { 0 };
18043 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18045 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18047 memcpy (digest
, tmp_buf
, 16);
18049 digest
[0] = byte_swap_32 (digest
[0]);
18050 digest
[1] = byte_swap_32 (digest
[1]);
18051 digest
[2] = byte_swap_32 (digest
[2]);
18052 digest
[3] = byte_swap_32 (digest
[3]);
18054 // add some stuff to normal salt to make sorted happy
18056 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
18057 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
18058 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
18059 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
18060 salt
->salt_buf
[4] = salt
->salt_iter
;
18062 return (PARSER_OK
);
18065 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18067 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
18069 u32
*digest
= (u32
*) hash_buf
->digest
;
18071 salt_t
*salt
= hash_buf
->salt
;
18073 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18074 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18075 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18076 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18078 digest
[0] = byte_swap_32 (digest
[0]);
18079 digest
[1] = byte_swap_32 (digest
[1]);
18080 digest
[2] = byte_swap_32 (digest
[2]);
18081 digest
[3] = byte_swap_32 (digest
[3]);
18083 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18085 uint salt_len
= input_len
- 32 - 1;
18087 char *salt_buf
= input_buf
+ 32 + 1;
18089 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18091 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18093 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18095 salt
->salt_len
= salt_len
;
18097 return (PARSER_OK
);
18100 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18102 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
18104 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18106 u32
*digest
= (u32
*) hash_buf
->digest
;
18108 salt_t
*salt
= hash_buf
->salt
;
18110 char *user_pos
= input_buf
+ 10;
18112 char *salt_pos
= strchr (user_pos
, '*');
18114 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18118 char *hash_pos
= strchr (salt_pos
, '*');
18122 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18124 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18126 uint user_len
= salt_pos
- user_pos
- 1;
18128 uint salt_len
= hash_pos
- salt_pos
- 1;
18130 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18136 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18137 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18138 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18139 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18141 digest
[0] = byte_swap_32 (digest
[0]);
18142 digest
[1] = byte_swap_32 (digest
[1]);
18143 digest
[2] = byte_swap_32 (digest
[2]);
18144 digest
[3] = byte_swap_32 (digest
[3]);
18146 digest
[0] -= MD5M_A
;
18147 digest
[1] -= MD5M_B
;
18148 digest
[2] -= MD5M_C
;
18149 digest
[3] -= MD5M_D
;
18155 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18157 // first 4 bytes are the "challenge"
18159 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18160 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18161 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18162 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18164 // append the user name
18166 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18168 salt
->salt_len
= 4 + user_len
;
18170 return (PARSER_OK
);
18173 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18175 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18177 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18179 u32
*digest
= (u32
*) hash_buf
->digest
;
18181 salt_t
*salt
= hash_buf
->salt
;
18183 char *salt_pos
= input_buf
+ 9;
18185 char *hash_pos
= strchr (salt_pos
, '*');
18187 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18191 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18193 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18195 uint salt_len
= hash_pos
- salt_pos
- 1;
18197 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18203 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18204 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18205 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18206 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18207 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18213 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18215 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18217 salt
->salt_len
= salt_len
;
18219 return (PARSER_OK
);
18222 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18224 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18226 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18228 u32
*digest
= (u32
*) hash_buf
->digest
;
18230 salt_t
*salt
= hash_buf
->salt
;
18232 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18238 char *cry_master_len_pos
= input_buf
+ 9;
18240 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18242 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18244 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18246 cry_master_buf_pos
++;
18248 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18250 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18252 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18254 cry_salt_len_pos
++;
18256 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18258 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18260 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18262 cry_salt_buf_pos
++;
18264 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18266 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18268 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18272 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18274 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18276 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18280 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18282 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18284 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18288 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18290 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18292 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18294 public_key_len_pos
++;
18296 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18298 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18300 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18302 public_key_buf_pos
++;
18304 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;
18306 const uint cry_master_len
= atoi (cry_master_len_pos
);
18307 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18308 const uint ckey_len
= atoi (ckey_len_pos
);
18309 const uint public_key_len
= atoi (public_key_len_pos
);
18311 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18312 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18313 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18314 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18316 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18318 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18320 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18323 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18325 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18327 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18330 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18332 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18334 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18337 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18338 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18339 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18342 * store digest (should be unique enought, hopefully)
18345 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18346 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18347 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18348 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18354 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18356 const uint cry_rounds
= atoi (cry_rounds_pos
);
18358 salt
->salt_iter
= cry_rounds
- 1;
18360 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18362 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18364 salt
->salt_len
= salt_len
;
18366 return (PARSER_OK
);
18369 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18371 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18373 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18375 u32
*digest
= (u32
*) hash_buf
->digest
;
18377 salt_t
*salt
= hash_buf
->salt
;
18379 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18381 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18383 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18385 memcpy (temp_input_buf
, input_buf
, input_len
);
18389 char *URI_server_pos
= temp_input_buf
+ 6;
18391 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18393 if (URI_client_pos
== NULL
)
18395 myfree (temp_input_buf
);
18397 return (PARSER_SEPARATOR_UNMATCHED
);
18400 URI_client_pos
[0] = 0;
18403 uint URI_server_len
= strlen (URI_server_pos
);
18405 if (URI_server_len
> 512)
18407 myfree (temp_input_buf
);
18409 return (PARSER_SALT_LENGTH
);
18414 char *user_pos
= strchr (URI_client_pos
, '*');
18416 if (user_pos
== NULL
)
18418 myfree (temp_input_buf
);
18420 return (PARSER_SEPARATOR_UNMATCHED
);
18426 uint URI_client_len
= strlen (URI_client_pos
);
18428 if (URI_client_len
> 512)
18430 myfree (temp_input_buf
);
18432 return (PARSER_SALT_LENGTH
);
18437 char *realm_pos
= strchr (user_pos
, '*');
18439 if (realm_pos
== NULL
)
18441 myfree (temp_input_buf
);
18443 return (PARSER_SEPARATOR_UNMATCHED
);
18449 uint user_len
= strlen (user_pos
);
18451 if (user_len
> 116)
18453 myfree (temp_input_buf
);
18455 return (PARSER_SALT_LENGTH
);
18460 char *method_pos
= strchr (realm_pos
, '*');
18462 if (method_pos
== NULL
)
18464 myfree (temp_input_buf
);
18466 return (PARSER_SEPARATOR_UNMATCHED
);
18472 uint realm_len
= strlen (realm_pos
);
18474 if (realm_len
> 116)
18476 myfree (temp_input_buf
);
18478 return (PARSER_SALT_LENGTH
);
18483 char *URI_prefix_pos
= strchr (method_pos
, '*');
18485 if (URI_prefix_pos
== NULL
)
18487 myfree (temp_input_buf
);
18489 return (PARSER_SEPARATOR_UNMATCHED
);
18492 URI_prefix_pos
[0] = 0;
18495 uint method_len
= strlen (method_pos
);
18497 if (method_len
> 246)
18499 myfree (temp_input_buf
);
18501 return (PARSER_SALT_LENGTH
);
18506 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18508 if (URI_resource_pos
== NULL
)
18510 myfree (temp_input_buf
);
18512 return (PARSER_SEPARATOR_UNMATCHED
);
18515 URI_resource_pos
[0] = 0;
18516 URI_resource_pos
++;
18518 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18520 if (URI_prefix_len
> 245)
18522 myfree (temp_input_buf
);
18524 return (PARSER_SALT_LENGTH
);
18529 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18531 if (URI_suffix_pos
== NULL
)
18533 myfree (temp_input_buf
);
18535 return (PARSER_SEPARATOR_UNMATCHED
);
18538 URI_suffix_pos
[0] = 0;
18541 uint URI_resource_len
= strlen (URI_resource_pos
);
18543 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18545 myfree (temp_input_buf
);
18547 return (PARSER_SALT_LENGTH
);
18552 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18554 if (nonce_pos
== NULL
)
18556 myfree (temp_input_buf
);
18558 return (PARSER_SEPARATOR_UNMATCHED
);
18564 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18566 if (URI_suffix_len
> 245)
18568 myfree (temp_input_buf
);
18570 return (PARSER_SALT_LENGTH
);
18575 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18577 if (nonce_client_pos
== NULL
)
18579 myfree (temp_input_buf
);
18581 return (PARSER_SEPARATOR_UNMATCHED
);
18584 nonce_client_pos
[0] = 0;
18585 nonce_client_pos
++;
18587 uint nonce_len
= strlen (nonce_pos
);
18589 if (nonce_len
< 1 || nonce_len
> 50)
18591 myfree (temp_input_buf
);
18593 return (PARSER_SALT_LENGTH
);
18598 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18600 if (nonce_count_pos
== NULL
)
18602 myfree (temp_input_buf
);
18604 return (PARSER_SEPARATOR_UNMATCHED
);
18607 nonce_count_pos
[0] = 0;
18610 uint nonce_client_len
= strlen (nonce_client_pos
);
18612 if (nonce_client_len
> 50)
18614 myfree (temp_input_buf
);
18616 return (PARSER_SALT_LENGTH
);
18621 char *qop_pos
= strchr (nonce_count_pos
, '*');
18623 if (qop_pos
== NULL
)
18625 myfree (temp_input_buf
);
18627 return (PARSER_SEPARATOR_UNMATCHED
);
18633 uint nonce_count_len
= strlen (nonce_count_pos
);
18635 if (nonce_count_len
> 50)
18637 myfree (temp_input_buf
);
18639 return (PARSER_SALT_LENGTH
);
18644 char *directive_pos
= strchr (qop_pos
, '*');
18646 if (directive_pos
== NULL
)
18648 myfree (temp_input_buf
);
18650 return (PARSER_SEPARATOR_UNMATCHED
);
18653 directive_pos
[0] = 0;
18656 uint qop_len
= strlen (qop_pos
);
18660 myfree (temp_input_buf
);
18662 return (PARSER_SALT_LENGTH
);
18667 char *digest_pos
= strchr (directive_pos
, '*');
18669 if (digest_pos
== NULL
)
18671 myfree (temp_input_buf
);
18673 return (PARSER_SEPARATOR_UNMATCHED
);
18679 uint directive_len
= strlen (directive_pos
);
18681 if (directive_len
!= 3)
18683 myfree (temp_input_buf
);
18685 return (PARSER_SALT_LENGTH
);
18688 if (memcmp (directive_pos
, "MD5", 3))
18690 log_info ("ERROR: Only the MD5 directive is currently supported\n");
18692 myfree (temp_input_buf
);
18694 return (PARSER_SIP_AUTH_DIRECTIVE
);
18698 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18703 uint md5_max_len
= 4 * 64;
18705 uint md5_remaining_len
= md5_max_len
;
18707 uint tmp_md5_buf
[64] = { 0 };
18709 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18711 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18713 md5_len
+= method_len
+ 1;
18714 tmp_md5_ptr
+= method_len
+ 1;
18716 if (URI_prefix_len
> 0)
18718 md5_remaining_len
= md5_max_len
- md5_len
;
18720 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18722 md5_len
+= URI_prefix_len
+ 1;
18723 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18726 md5_remaining_len
= md5_max_len
- md5_len
;
18728 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18730 md5_len
+= URI_resource_len
;
18731 tmp_md5_ptr
+= URI_resource_len
;
18733 if (URI_suffix_len
> 0)
18735 md5_remaining_len
= md5_max_len
- md5_len
;
18737 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18739 md5_len
+= 1 + URI_suffix_len
;
18742 uint tmp_digest
[4] = { 0 };
18744 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18746 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18747 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18748 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18749 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18755 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18757 uint esalt_len
= 0;
18759 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18761 // there are 2 possibilities for the esalt:
18763 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18765 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18767 if (esalt_len
> max_esalt_len
)
18769 myfree (temp_input_buf
);
18771 return (PARSER_SALT_LENGTH
);
18774 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18786 esalt_len
= 1 + nonce_len
+ 1 + 32;
18788 if (esalt_len
> max_esalt_len
)
18790 myfree (temp_input_buf
);
18792 return (PARSER_SALT_LENGTH
);
18795 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18803 // add 0x80 to esalt
18805 esalt_buf_ptr
[esalt_len
] = 0x80;
18807 sip
->esalt_len
= esalt_len
;
18813 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18815 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18817 uint max_salt_len
= 119;
18819 if (salt_len
> max_salt_len
)
18821 myfree (temp_input_buf
);
18823 return (PARSER_SALT_LENGTH
);
18826 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18828 sip
->salt_len
= salt_len
;
18831 * fake salt (for sorting)
18834 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18838 uint fake_salt_len
= salt_len
;
18840 if (fake_salt_len
> max_salt_len
)
18842 fake_salt_len
= max_salt_len
;
18845 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18847 salt
->salt_len
= fake_salt_len
;
18853 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18854 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18855 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18856 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18858 digest
[0] = byte_swap_32 (digest
[0]);
18859 digest
[1] = byte_swap_32 (digest
[1]);
18860 digest
[2] = byte_swap_32 (digest
[2]);
18861 digest
[3] = byte_swap_32 (digest
[3]);
18863 myfree (temp_input_buf
);
18865 return (PARSER_OK
);
18868 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18870 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18872 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18874 u32
*digest
= (u32
*) hash_buf
->digest
;
18876 salt_t
*salt
= hash_buf
->salt
;
18880 char *digest_pos
= input_buf
;
18882 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18889 char *salt_buf
= input_buf
+ 8 + 1;
18893 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18895 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18897 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18899 salt
->salt_len
= salt_len
;
18901 return (PARSER_OK
);
18904 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18906 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18908 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18910 u32
*digest
= (u32
*) hash_buf
->digest
;
18912 salt_t
*salt
= hash_buf
->salt
;
18914 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18920 char *p_buf_pos
= input_buf
+ 4;
18922 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18924 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18926 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18928 NumCyclesPower_pos
++;
18930 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18932 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18934 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18938 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18940 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18942 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18946 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18948 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18950 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18954 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18956 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18958 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18962 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18964 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18966 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18970 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18972 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18974 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18978 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18980 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18982 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18986 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18988 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18990 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18994 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;
18996 const uint iter
= atoi (NumCyclesPower_pos
);
18997 const uint crc
= atoi (crc_buf_pos
);
18998 const uint p_buf
= atoi (p_buf_pos
);
18999 const uint salt_len
= atoi (salt_len_pos
);
19000 const uint iv_len
= atoi (iv_len_pos
);
19001 const uint unpack_size
= atoi (unpack_size_pos
);
19002 const uint data_len
= atoi (data_len_pos
);
19008 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
19009 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
19011 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
19013 if (data_len
> 384) return (PARSER_SALT_VALUE
);
19015 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
19021 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
19022 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
19023 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
19024 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
19026 seven_zip
->iv_len
= iv_len
;
19028 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
19030 seven_zip
->salt_len
= 0;
19032 seven_zip
->crc
= crc
;
19034 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
19036 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
19038 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
19041 seven_zip
->data_len
= data_len
;
19043 seven_zip
->unpack_size
= unpack_size
;
19047 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
19048 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
19049 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
19050 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
19052 salt
->salt_len
= 16;
19054 salt
->salt_sign
[0] = iter
;
19056 salt
->salt_iter
= 1 << iter
;
19067 return (PARSER_OK
);
19070 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19072 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
19074 u32
*digest
= (u32
*) hash_buf
->digest
;
19076 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19077 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19078 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19079 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19080 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19081 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19082 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19083 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19085 digest
[0] = byte_swap_32 (digest
[0]);
19086 digest
[1] = byte_swap_32 (digest
[1]);
19087 digest
[2] = byte_swap_32 (digest
[2]);
19088 digest
[3] = byte_swap_32 (digest
[3]);
19089 digest
[4] = byte_swap_32 (digest
[4]);
19090 digest
[5] = byte_swap_32 (digest
[5]);
19091 digest
[6] = byte_swap_32 (digest
[6]);
19092 digest
[7] = byte_swap_32 (digest
[7]);
19094 return (PARSER_OK
);
19097 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19099 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
19101 u32
*digest
= (u32
*) hash_buf
->digest
;
19103 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19104 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19105 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
19106 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
19107 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
19108 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
19109 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
19110 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
19111 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
19112 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
19113 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
19114 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
19115 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
19116 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
19117 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
19118 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
19120 digest
[ 0] = byte_swap_32 (digest
[ 0]);
19121 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19122 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19123 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19124 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19125 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19126 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19127 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19128 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19129 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19130 digest
[10] = byte_swap_32 (digest
[10]);
19131 digest
[11] = byte_swap_32 (digest
[11]);
19132 digest
[12] = byte_swap_32 (digest
[12]);
19133 digest
[13] = byte_swap_32 (digest
[13]);
19134 digest
[14] = byte_swap_32 (digest
[14]);
19135 digest
[15] = byte_swap_32 (digest
[15]);
19137 return (PARSER_OK
);
19140 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19142 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19144 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19146 u32
*digest
= (u32
*) hash_buf
->digest
;
19148 salt_t
*salt
= hash_buf
->salt
;
19150 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19158 char *iter_pos
= input_buf
+ 4;
19160 u32 iter
= atoi (iter_pos
);
19162 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19163 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19165 // first is *raw* salt
19167 char *salt_pos
= strchr (iter_pos
, ':');
19169 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19173 char *hash_pos
= strchr (salt_pos
, ':');
19175 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19177 u32 salt_len
= hash_pos
- salt_pos
;
19179 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19183 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19185 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19189 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19191 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19193 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19195 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19196 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19198 salt
->salt_len
= salt_len
;
19199 salt
->salt_iter
= iter
- 1;
19203 u8 tmp_buf
[100] = { 0 };
19205 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19207 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19209 memcpy (digest
, tmp_buf
, 16);
19211 // add some stuff to normal salt to make sorted happy
19213 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19214 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19215 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19216 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19217 salt
->salt_buf
[4] = salt
->salt_iter
;
19219 return (PARSER_OK
);
19222 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19224 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19226 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19228 u32
*digest
= (u32
*) hash_buf
->digest
;
19230 salt_t
*salt
= hash_buf
->salt
;
19232 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19240 char *iter_pos
= input_buf
+ 5;
19242 u32 iter
= atoi (iter_pos
);
19244 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19245 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19247 // first is *raw* salt
19249 char *salt_pos
= strchr (iter_pos
, ':');
19251 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19255 char *hash_pos
= strchr (salt_pos
, ':');
19257 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19259 u32 salt_len
= hash_pos
- salt_pos
;
19261 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19265 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19267 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19271 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19273 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19275 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19277 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19278 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19280 salt
->salt_len
= salt_len
;
19281 salt
->salt_iter
= iter
- 1;
19285 u8 tmp_buf
[100] = { 0 };
19287 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19289 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19291 memcpy (digest
, tmp_buf
, 16);
19293 digest
[0] = byte_swap_32 (digest
[0]);
19294 digest
[1] = byte_swap_32 (digest
[1]);
19295 digest
[2] = byte_swap_32 (digest
[2]);
19296 digest
[3] = byte_swap_32 (digest
[3]);
19298 // add some stuff to normal salt to make sorted happy
19300 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19301 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19302 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19303 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19304 salt
->salt_buf
[4] = salt
->salt_iter
;
19306 return (PARSER_OK
);
19309 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19311 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19313 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19315 u64
*digest
= (u64
*) hash_buf
->digest
;
19317 salt_t
*salt
= hash_buf
->salt
;
19319 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19327 char *iter_pos
= input_buf
+ 7;
19329 u32 iter
= atoi (iter_pos
);
19331 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19332 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19334 // first is *raw* salt
19336 char *salt_pos
= strchr (iter_pos
, ':');
19338 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19342 char *hash_pos
= strchr (salt_pos
, ':');
19344 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19346 u32 salt_len
= hash_pos
- salt_pos
;
19348 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19352 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19354 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19358 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19360 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19362 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19364 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19365 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19367 salt
->salt_len
= salt_len
;
19368 salt
->salt_iter
= iter
- 1;
19372 u8 tmp_buf
[100] = { 0 };
19374 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19376 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19378 memcpy (digest
, tmp_buf
, 64);
19380 digest
[0] = byte_swap_64 (digest
[0]);
19381 digest
[1] = byte_swap_64 (digest
[1]);
19382 digest
[2] = byte_swap_64 (digest
[2]);
19383 digest
[3] = byte_swap_64 (digest
[3]);
19384 digest
[4] = byte_swap_64 (digest
[4]);
19385 digest
[5] = byte_swap_64 (digest
[5]);
19386 digest
[6] = byte_swap_64 (digest
[6]);
19387 digest
[7] = byte_swap_64 (digest
[7]);
19389 // add some stuff to normal salt to make sorted happy
19391 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19392 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19393 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19394 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19395 salt
->salt_buf
[4] = salt
->salt_iter
;
19397 return (PARSER_OK
);
19400 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19402 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19404 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19406 uint
*digest
= (uint
*) hash_buf
->digest
;
19408 salt_t
*salt
= hash_buf
->salt
;
19414 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19416 char *hash_pos
= strchr (salt_pos
, '$');
19418 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19420 u32 salt_len
= hash_pos
- salt_pos
;
19422 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19426 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19428 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19432 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19433 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19451 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19452 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19454 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19455 salt
->salt_len
= 8;
19457 return (PARSER_OK
);
19460 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19462 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19464 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19466 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19468 if (c19
& 3) return (PARSER_HASH_VALUE
);
19470 salt_t
*salt
= hash_buf
->salt
;
19472 u32
*digest
= (u32
*) hash_buf
->digest
;
19476 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19477 | itoa64_to_int (input_buf
[2]) << 6
19478 | itoa64_to_int (input_buf
[3]) << 12
19479 | itoa64_to_int (input_buf
[4]) << 18;
19483 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19484 | itoa64_to_int (input_buf
[6]) << 6
19485 | itoa64_to_int (input_buf
[7]) << 12
19486 | itoa64_to_int (input_buf
[8]) << 18;
19488 salt
->salt_len
= 4;
19490 u8 tmp_buf
[100] = { 0 };
19492 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19494 memcpy (digest
, tmp_buf
, 8);
19498 IP (digest
[0], digest
[1], tt
);
19500 digest
[0] = rotr32 (digest
[0], 31);
19501 digest
[1] = rotr32 (digest
[1], 31);
19505 return (PARSER_OK
);
19508 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19510 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19512 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19514 u32
*digest
= (u32
*) hash_buf
->digest
;
19516 salt_t
*salt
= hash_buf
->salt
;
19522 char *type_pos
= input_buf
+ 6 + 1;
19524 char *salt_pos
= strchr (type_pos
, '*');
19526 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19528 u32 type_len
= salt_pos
- type_pos
;
19530 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19534 char *crypted_pos
= strchr (salt_pos
, '*');
19536 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19538 u32 salt_len
= crypted_pos
- salt_pos
;
19540 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19544 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19546 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19552 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19553 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19555 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19556 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19558 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19559 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19560 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19561 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19563 salt
->salt_len
= 24;
19564 salt
->salt_iter
= ROUNDS_RAR3
;
19566 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19567 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19569 digest
[0] = 0xc43d7b00;
19570 digest
[1] = 0x40070000;
19574 return (PARSER_OK
);
19577 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19579 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19581 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19583 u32
*digest
= (u32
*) hash_buf
->digest
;
19585 salt_t
*salt
= hash_buf
->salt
;
19587 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19593 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19595 char *param1_pos
= strchr (param0_pos
, '$');
19597 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19599 u32 param0_len
= param1_pos
- param0_pos
;
19603 char *param2_pos
= strchr (param1_pos
, '$');
19605 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19607 u32 param1_len
= param2_pos
- param1_pos
;
19611 char *param3_pos
= strchr (param2_pos
, '$');
19613 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19615 u32 param2_len
= param3_pos
- param2_pos
;
19619 char *param4_pos
= strchr (param3_pos
, '$');
19621 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19623 u32 param3_len
= param4_pos
- param3_pos
;
19627 char *param5_pos
= strchr (param4_pos
, '$');
19629 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19631 u32 param4_len
= param5_pos
- param4_pos
;
19635 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19637 char *salt_buf
= param1_pos
;
19638 char *iv
= param3_pos
;
19639 char *pswcheck
= param5_pos
;
19641 const uint salt_len
= atoi (param0_pos
);
19642 const uint iterations
= atoi (param2_pos
);
19643 const uint pswcheck_len
= atoi (param4_pos
);
19649 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19650 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19651 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19653 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19654 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19655 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19661 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19662 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19663 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19664 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19666 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19667 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19668 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19669 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19671 salt
->salt_len
= 16;
19673 salt
->salt_sign
[0] = iterations
;
19675 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19681 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19682 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19686 return (PARSER_OK
);
19689 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19691 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19693 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19695 u32
*digest
= (u32
*) hash_buf
->digest
;
19697 salt_t
*salt
= hash_buf
->salt
;
19699 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19706 char *account_pos
= input_buf
+ 11 + 1;
19712 if (account_pos
[0] == '*')
19716 data_pos
= strchr (account_pos
, '*');
19721 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19723 uint account_len
= data_pos
- account_pos
+ 1;
19725 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19730 data_len
= input_len
- 11 - 1 - account_len
- 2;
19732 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19736 /* assume $krb5tgs$23$checksum$edata2 */
19737 data_pos
= account_pos
;
19739 memcpy (krb5tgs
->account_info
, "**", 3);
19741 data_len
= input_len
- 11 - 1 - 1;
19744 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19746 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19748 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19750 const char p0
= data_pos
[i
+ 0];
19751 const char p1
= data_pos
[i
+ 1];
19753 *checksum_ptr
++ = hex_convert (p1
) << 0
19754 | hex_convert (p0
) << 4;
19757 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19759 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19762 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19764 const char p0
= data_pos
[i
+ 0];
19765 const char p1
= data_pos
[i
+ 1];
19766 *edata_ptr
++ = hex_convert (p1
) << 0
19767 | hex_convert (p0
) << 4;
19770 /* this is needed for hmac_md5 */
19771 *edata_ptr
++ = 0x80;
19773 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19774 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19775 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19776 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19778 salt
->salt_len
= 32;
19780 digest
[0] = krb5tgs
->checksum
[0];
19781 digest
[1] = krb5tgs
->checksum
[1];
19782 digest
[2] = krb5tgs
->checksum
[2];
19783 digest
[3] = krb5tgs
->checksum
[3];
19785 return (PARSER_OK
);
19788 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19790 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19792 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19794 u32
*digest
= (u32
*) hash_buf
->digest
;
19796 salt_t
*salt
= hash_buf
->salt
;
19803 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19807 char *wrapped_key_pos
;
19811 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19813 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19815 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19817 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19822 data_pos
= salt_pos
;
19824 wrapped_key_pos
= strchr (salt_pos
, '*');
19826 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19828 uint salt_len
= wrapped_key_pos
- salt_pos
;
19830 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19835 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19837 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19839 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19840 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19841 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19842 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19846 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19847 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19848 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19849 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19850 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19851 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19853 salt
->salt_len
= 40;
19855 digest
[0] = salt
->salt_buf
[0];
19856 digest
[1] = salt
->salt_buf
[1];
19857 digest
[2] = salt
->salt_buf
[2];
19858 digest
[3] = salt
->salt_buf
[3];
19860 return (PARSER_OK
);
19863 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19865 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19867 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19869 u32
*digest
= (u32
*) hash_buf
->digest
;
19871 salt_t
*salt
= hash_buf
->salt
;
19873 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19883 char *algorithm_pos
;
19885 char *final_random_seed_pos
;
19886 u32 final_random_seed_len
;
19888 char *transf_random_seed_pos
;
19889 u32 transf_random_seed_len
;
19894 /* default is no keyfile provided */
19895 char *keyfile_len_pos
;
19896 u32 keyfile_len
= 0;
19897 u32 is_keyfile_present
= 0;
19898 char *keyfile_inline_pos
;
19901 /* specific to version 1 */
19902 char *contents_len_pos
;
19904 char *contents_pos
;
19906 /* specific to version 2 */
19907 char *expected_bytes_pos
;
19908 u32 expected_bytes_len
;
19910 char *contents_hash_pos
;
19911 u32 contents_hash_len
;
19913 version_pos
= input_buf
+ 8 + 1 + 1;
19915 keepass
->version
= atoi (version_pos
);
19917 rounds_pos
= strchr (version_pos
, '*');
19919 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19923 salt
->salt_iter
= (atoi (rounds_pos
));
19925 algorithm_pos
= strchr (rounds_pos
, '*');
19927 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19931 keepass
->algorithm
= atoi (algorithm_pos
);
19933 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19935 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19937 final_random_seed_pos
++;
19939 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19940 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19941 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19942 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19944 if (keepass
->version
== 2)
19946 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19947 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19948 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19949 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19952 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19954 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19956 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19958 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19959 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19961 transf_random_seed_pos
++;
19963 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19964 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19965 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19966 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19967 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19968 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19969 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19970 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19972 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19974 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19976 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19978 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19982 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19983 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19984 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19985 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19987 if (keepass
->version
== 1)
19989 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19991 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19993 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19995 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19997 contents_hash_pos
++;
19999 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
20000 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
20001 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
20002 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20003 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20004 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20005 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20006 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20008 /* get length of contents following */
20009 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
20011 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20013 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
20015 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20019 u32 inline_flag
= atoi (inline_flag_pos
);
20021 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
20023 contents_len_pos
= strchr (inline_flag_pos
, '*');
20025 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20027 contents_len_pos
++;
20029 contents_len
= atoi (contents_len_pos
);
20031 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
20033 contents_pos
= strchr (contents_len_pos
, '*');
20035 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20041 keepass
->contents_len
= contents_len
;
20043 contents_len
= contents_len
/ 4;
20045 keyfile_inline_pos
= strchr (contents_pos
, '*');
20047 u32 real_contents_len
;
20049 if (keyfile_inline_pos
== NULL
)
20050 real_contents_len
= input_len
- (contents_pos
- input_buf
);
20053 real_contents_len
= keyfile_inline_pos
- contents_pos
;
20054 keyfile_inline_pos
++;
20055 is_keyfile_present
= 1;
20058 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
20060 for (i
= 0; i
< contents_len
; i
++)
20061 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
20063 else if (keepass
->version
== 2)
20065 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
20067 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20069 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
20071 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
20073 expected_bytes_pos
++;
20075 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
20076 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
20077 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
20078 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
20079 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
20080 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
20081 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
20082 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
20084 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
20086 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20088 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
20090 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
20092 contents_hash_pos
++;
20094 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
20095 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
20096 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
20097 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20098 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20099 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20100 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20101 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20103 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
20105 if (keyfile_inline_pos
== NULL
)
20106 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
20109 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
20110 keyfile_inline_pos
++;
20111 is_keyfile_present
= 1;
20113 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20116 if (is_keyfile_present
!= 0)
20118 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20122 keyfile_len
= atoi (keyfile_len_pos
);
20124 keepass
->keyfile_len
= keyfile_len
;
20126 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20128 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20130 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20134 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20136 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20138 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20139 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20140 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20141 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20142 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20143 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20144 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20145 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20148 digest
[0] = keepass
->enc_iv
[0];
20149 digest
[1] = keepass
->enc_iv
[1];
20150 digest
[2] = keepass
->enc_iv
[2];
20151 digest
[3] = keepass
->enc_iv
[3];
20153 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20154 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20155 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20156 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20157 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20158 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20159 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20160 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20162 return (PARSER_OK
);
20165 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20167 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20169 u32
*digest
= (u32
*) hash_buf
->digest
;
20171 salt_t
*salt
= hash_buf
->salt
;
20173 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20174 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20175 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20176 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20177 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20178 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20179 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20180 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20182 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20184 uint salt_len
= input_len
- 64 - 1;
20186 char *salt_buf
= input_buf
+ 64 + 1;
20188 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20190 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20192 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20194 salt
->salt_len
= salt_len
;
20197 * we can precompute the first sha256 transform
20200 uint w
[16] = { 0 };
20202 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20203 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20204 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20205 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20206 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20207 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20208 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20209 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20210 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20211 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20212 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20213 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20214 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20215 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20216 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20217 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20219 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20221 sha256_64 (w
, pc256
);
20223 salt
->salt_buf_pc
[0] = pc256
[0];
20224 salt
->salt_buf_pc
[1] = pc256
[1];
20225 salt
->salt_buf_pc
[2] = pc256
[2];
20226 salt
->salt_buf_pc
[3] = pc256
[3];
20227 salt
->salt_buf_pc
[4] = pc256
[4];
20228 salt
->salt_buf_pc
[5] = pc256
[5];
20229 salt
->salt_buf_pc
[6] = pc256
[6];
20230 salt
->salt_buf_pc
[7] = pc256
[7];
20232 digest
[0] -= pc256
[0];
20233 digest
[1] -= pc256
[1];
20234 digest
[2] -= pc256
[2];
20235 digest
[3] -= pc256
[3];
20236 digest
[4] -= pc256
[4];
20237 digest
[5] -= pc256
[5];
20238 digest
[6] -= pc256
[6];
20239 digest
[7] -= pc256
[7];
20241 return (PARSER_OK
);
20244 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20246 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20248 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20250 u32
*digest
= (u32
*) hash_buf
->digest
;
20252 salt_t
*salt
= hash_buf
->salt
;
20258 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20260 char *data_buf_pos
= strchr (data_len_pos
, '$');
20262 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20264 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20266 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20267 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20271 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20273 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20275 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20277 u32 data_len
= atoi (data_len_pos
);
20279 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20285 char *salt_pos
= data_buf_pos
;
20287 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20288 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20289 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20290 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20292 // this is actually the CT, which is also the hash later (if matched)
20294 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20295 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20296 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20297 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20299 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20301 salt
->salt_iter
= 10 - 1;
20307 digest
[0] = salt
->salt_buf
[4];
20308 digest
[1] = salt
->salt_buf
[5];
20309 digest
[2] = salt
->salt_buf
[6];
20310 digest
[3] = salt
->salt_buf
[7];
20312 return (PARSER_OK
);
20315 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20317 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20319 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20321 u32
*digest
= (u32
*) hash_buf
->digest
;
20323 salt_t
*salt
= hash_buf
->salt
;
20329 char *salt_pos
= input_buf
+ 11 + 1;
20331 char *iter_pos
= strchr (salt_pos
, ',');
20333 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20335 u32 salt_len
= iter_pos
- salt_pos
;
20337 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20341 char *hash_pos
= strchr (iter_pos
, ',');
20343 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20345 u32 iter_len
= hash_pos
- iter_pos
;
20347 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20351 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20353 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20359 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20360 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20361 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20362 salt
->salt_buf
[3] = 0x00018000;
20364 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20365 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20366 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20367 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20369 salt
->salt_len
= salt_len
/ 2;
20371 salt
->salt_iter
= atoi (iter_pos
) - 1;
20377 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20378 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20379 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20380 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20381 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20382 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20383 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20384 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20386 return (PARSER_OK
);
20389 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20391 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20393 u32
*digest
= (u32
*) hash_buf
->digest
;
20395 salt_t
*salt
= hash_buf
->salt
;
20401 char *hash_pos
= input_buf
+ 64;
20402 char *salt1_pos
= input_buf
+ 128;
20403 char *salt2_pos
= input_buf
;
20409 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20410 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20411 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20412 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20414 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20415 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20416 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20417 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20419 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20420 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20421 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20422 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20424 salt
->salt_len
= 48;
20426 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20432 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20433 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20434 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20435 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20436 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20437 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20438 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20439 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20441 return (PARSER_OK
);
20444 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20446 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20448 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20449 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20451 u32
*digest
= (u32
*) hash_buf
->digest
;
20453 salt_t
*salt
= hash_buf
->salt
;
20455 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20461 char *param0_pos
= input_buf
+ 6 + 1;
20463 char *param1_pos
= strchr (param0_pos
, '*');
20465 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20467 u32 param0_len
= param1_pos
- param0_pos
;
20471 char *param2_pos
= strchr (param1_pos
, '*');
20473 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20475 u32 param1_len
= param2_pos
- param1_pos
;
20479 char *param3_pos
= strchr (param2_pos
, '*');
20481 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20483 u32 param2_len
= param3_pos
- param2_pos
;
20487 char *param4_pos
= strchr (param3_pos
, '*');
20489 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20491 u32 param3_len
= param4_pos
- param3_pos
;
20495 char *param5_pos
= strchr (param4_pos
, '*');
20497 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20499 u32 param4_len
= param5_pos
- param4_pos
;
20503 char *param6_pos
= strchr (param5_pos
, '*');
20505 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20507 u32 param5_len
= param6_pos
- param5_pos
;
20511 char *param7_pos
= strchr (param6_pos
, '*');
20513 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20515 u32 param6_len
= param7_pos
- param6_pos
;
20519 char *param8_pos
= strchr (param7_pos
, '*');
20521 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20523 u32 param7_len
= param8_pos
- param7_pos
;
20527 const uint type
= atoi (param0_pos
);
20528 const uint mode
= atoi (param1_pos
);
20529 const uint magic
= atoi (param2_pos
);
20531 char *salt_buf
= param3_pos
;
20533 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20535 const uint compress_length
= atoi (param5_pos
);
20537 char *data_buf
= param6_pos
;
20538 char *auth
= param7_pos
;
20544 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20546 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20548 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20550 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20552 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20554 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20556 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20558 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20560 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20562 if (type
!= 0) return (PARSER_SALT_VALUE
);
20564 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20566 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20568 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20576 zip2
->magic
= magic
;
20580 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20581 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20582 zip2
->salt_buf
[2] = 0;
20583 zip2
->salt_buf
[3] = 0;
20585 zip2
->salt_len
= 8;
20587 else if (mode
== 2)
20589 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20590 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20591 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20592 zip2
->salt_buf
[3] = 0;
20594 zip2
->salt_len
= 12;
20596 else if (mode
== 3)
20598 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20599 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20600 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20601 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20603 zip2
->salt_len
= 16;
20606 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20607 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20608 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20609 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20611 zip2
->verify_bytes
= verify_bytes
;
20613 zip2
->compress_length
= compress_length
;
20615 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20617 for (uint i
= 0; i
< param6_len
; i
+= 2)
20619 const char p0
= data_buf
[i
+ 0];
20620 const char p1
= data_buf
[i
+ 1];
20622 *data_buf_ptr
++ = hex_convert (p1
) << 0
20623 | hex_convert (p0
) << 4;
20628 *data_buf_ptr
= 0x80;
20630 char *auth_ptr
= (char *) zip2
->auth_buf
;
20632 for (uint i
= 0; i
< param7_len
; i
+= 2)
20634 const char p0
= auth
[i
+ 0];
20635 const char p1
= auth
[i
+ 1];
20637 *auth_ptr
++ = hex_convert (p1
) << 0
20638 | hex_convert (p0
) << 4;
20647 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20648 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20649 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20650 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20651 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20652 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20653 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20654 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20656 salt
->salt_len
= 32;
20658 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20661 * digest buf (fake)
20664 digest
[0] = zip2
->auth_buf
[0];
20665 digest
[1] = zip2
->auth_buf
[1];
20666 digest
[2] = zip2
->auth_buf
[2];
20667 digest
[3] = zip2
->auth_buf
[3];
20669 return (PARSER_OK
);
20672 int win8phone_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20674 if ((input_len
< DISPLAY_LEN_MIN_13800
) || (input_len
> DISPLAY_LEN_MAX_13800
)) return (PARSER_GLOBAL_LENGTH
);
20676 u32
*digest
= (u32
*) hash_buf
->digest
;
20678 salt_t
*salt
= hash_buf
->salt
;
20680 win8phone_t
*esalt
= hash_buf
->esalt
;
20682 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20683 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20684 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20685 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20686 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20687 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20688 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20689 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20691 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20693 char *salt_buf_ptr
= input_buf
+ 64 + 1;
20695 u32
*salt_buf
= esalt
->salt_buf
;
20697 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
20699 salt_buf
[i
] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[j
]);
20702 salt
->salt_buf
[0] = salt_buf
[0];
20703 salt
->salt_buf
[1] = salt_buf
[1];
20704 salt
->salt_buf
[2] = salt_buf
[2];
20705 salt
->salt_buf
[3] = salt_buf
[3];
20706 salt
->salt_buf
[4] = salt_buf
[4];
20707 salt
->salt_buf
[5] = salt_buf
[5];
20708 salt
->salt_buf
[6] = salt_buf
[6];
20709 salt
->salt_buf
[7] = salt_buf
[7];
20711 salt
->salt_len
= 64;
20713 return (PARSER_OK
);
20717 * parallel running threads
20722 BOOL WINAPI
sigHandler_default (DWORD sig
)
20726 case CTRL_CLOSE_EVENT
:
20729 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20730 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20731 * function otherwise it is too late (e.g. after returning from this function)
20736 SetConsoleCtrlHandler (NULL
, TRUE
);
20743 case CTRL_LOGOFF_EVENT
:
20744 case CTRL_SHUTDOWN_EVENT
:
20748 SetConsoleCtrlHandler (NULL
, TRUE
);
20756 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20760 case CTRL_CLOSE_EVENT
:
20764 SetConsoleCtrlHandler (NULL
, TRUE
);
20771 case CTRL_LOGOFF_EVENT
:
20772 case CTRL_SHUTDOWN_EVENT
:
20776 SetConsoleCtrlHandler (NULL
, TRUE
);
20784 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20786 if (callback
== NULL
)
20788 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20792 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20798 void sigHandler_default (int sig
)
20802 signal (sig
, NULL
);
20805 void sigHandler_benchmark (int sig
)
20809 signal (sig
, NULL
);
20812 void hc_signal (void (callback
) (int))
20814 if (callback
== NULL
) callback
= SIG_DFL
;
20816 signal (SIGINT
, callback
);
20817 signal (SIGTERM
, callback
);
20818 signal (SIGABRT
, callback
);
20823 void status_display ();
20825 void *thread_keypress (void *p
)
20827 uint quiet
= data
.quiet
;
20831 while (data
.shutdown_outer
== 0)
20833 int ch
= tty_getchar();
20835 if (ch
== -1) break;
20837 if (ch
== 0) continue;
20839 //https://github.com/hashcat/hashcat/issues/302
20844 hc_thread_mutex_lock (mux_display
);
20860 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20861 if (quiet
== 0) fflush (stdout
);
20873 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20874 if (quiet
== 0) fflush (stdout
);
20886 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20887 if (quiet
== 0) fflush (stdout
);
20899 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20900 if (quiet
== 0) fflush (stdout
);
20908 stop_at_checkpoint ();
20912 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20913 if (quiet
== 0) fflush (stdout
);
20926 //https://github.com/hashcat/hashcat/issues/302
20931 hc_thread_mutex_unlock (mux_display
);
20943 bool class_num (const u8 c
)
20945 return ((c
>= '0') && (c
<= '9'));
20948 bool class_lower (const u8 c
)
20950 return ((c
>= 'a') && (c
<= 'z'));
20953 bool class_upper (const u8 c
)
20955 return ((c
>= 'A') && (c
<= 'Z'));
20958 bool class_alpha (const u8 c
)
20960 return (class_lower (c
) || class_upper (c
));
20963 int conv_ctoi (const u8 c
)
20969 else if (class_upper (c
))
20971 return c
- 'A' + 10;
20977 int conv_itoc (const u8 c
)
20985 return c
+ 'A' - 10;
20995 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20996 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20997 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20998 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20999 #define MAX_KERNEL_RULES 255
21000 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
21001 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
21002 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
21004 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
21005 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
21006 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
21007 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
21009 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
21014 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21016 switch (rule_buf
[rule_pos
])
21022 case RULE_OP_MANGLE_NOOP
:
21023 SET_NAME (rule
, rule_buf
[rule_pos
]);
21026 case RULE_OP_MANGLE_LREST
:
21027 SET_NAME (rule
, rule_buf
[rule_pos
]);
21030 case RULE_OP_MANGLE_UREST
:
21031 SET_NAME (rule
, rule_buf
[rule_pos
]);
21034 case RULE_OP_MANGLE_LREST_UFIRST
:
21035 SET_NAME (rule
, rule_buf
[rule_pos
]);
21038 case RULE_OP_MANGLE_UREST_LFIRST
:
21039 SET_NAME (rule
, rule_buf
[rule_pos
]);
21042 case RULE_OP_MANGLE_TREST
:
21043 SET_NAME (rule
, rule_buf
[rule_pos
]);
21046 case RULE_OP_MANGLE_TOGGLE_AT
:
21047 SET_NAME (rule
, rule_buf
[rule_pos
]);
21048 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21051 case RULE_OP_MANGLE_REVERSE
:
21052 SET_NAME (rule
, rule_buf
[rule_pos
]);
21055 case RULE_OP_MANGLE_DUPEWORD
:
21056 SET_NAME (rule
, rule_buf
[rule_pos
]);
21059 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21060 SET_NAME (rule
, rule_buf
[rule_pos
]);
21061 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21064 case RULE_OP_MANGLE_REFLECT
:
21065 SET_NAME (rule
, rule_buf
[rule_pos
]);
21068 case RULE_OP_MANGLE_ROTATE_LEFT
:
21069 SET_NAME (rule
, rule_buf
[rule_pos
]);
21072 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21073 SET_NAME (rule
, rule_buf
[rule_pos
]);
21076 case RULE_OP_MANGLE_APPEND
:
21077 SET_NAME (rule
, rule_buf
[rule_pos
]);
21078 SET_P0 (rule
, rule_buf
[rule_pos
]);
21081 case RULE_OP_MANGLE_PREPEND
:
21082 SET_NAME (rule
, rule_buf
[rule_pos
]);
21083 SET_P0 (rule
, rule_buf
[rule_pos
]);
21086 case RULE_OP_MANGLE_DELETE_FIRST
:
21087 SET_NAME (rule
, rule_buf
[rule_pos
]);
21090 case RULE_OP_MANGLE_DELETE_LAST
:
21091 SET_NAME (rule
, rule_buf
[rule_pos
]);
21094 case RULE_OP_MANGLE_DELETE_AT
:
21095 SET_NAME (rule
, rule_buf
[rule_pos
]);
21096 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21099 case RULE_OP_MANGLE_EXTRACT
:
21100 SET_NAME (rule
, rule_buf
[rule_pos
]);
21101 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21102 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21105 case RULE_OP_MANGLE_OMIT
:
21106 SET_NAME (rule
, rule_buf
[rule_pos
]);
21107 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21108 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21111 case RULE_OP_MANGLE_INSERT
:
21112 SET_NAME (rule
, rule_buf
[rule_pos
]);
21113 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21114 SET_P1 (rule
, rule_buf
[rule_pos
]);
21117 case RULE_OP_MANGLE_OVERSTRIKE
:
21118 SET_NAME (rule
, rule_buf
[rule_pos
]);
21119 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21120 SET_P1 (rule
, rule_buf
[rule_pos
]);
21123 case RULE_OP_MANGLE_TRUNCATE_AT
:
21124 SET_NAME (rule
, rule_buf
[rule_pos
]);
21125 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21128 case RULE_OP_MANGLE_REPLACE
:
21129 SET_NAME (rule
, rule_buf
[rule_pos
]);
21130 SET_P0 (rule
, rule_buf
[rule_pos
]);
21131 SET_P1 (rule
, rule_buf
[rule_pos
]);
21134 case RULE_OP_MANGLE_PURGECHAR
:
21138 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21142 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21143 SET_NAME (rule
, rule_buf
[rule_pos
]);
21144 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21147 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21148 SET_NAME (rule
, rule_buf
[rule_pos
]);
21149 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21152 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21153 SET_NAME (rule
, rule_buf
[rule_pos
]);
21156 case RULE_OP_MANGLE_SWITCH_FIRST
:
21157 SET_NAME (rule
, rule_buf
[rule_pos
]);
21160 case RULE_OP_MANGLE_SWITCH_LAST
:
21161 SET_NAME (rule
, rule_buf
[rule_pos
]);
21164 case RULE_OP_MANGLE_SWITCH_AT
:
21165 SET_NAME (rule
, rule_buf
[rule_pos
]);
21166 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21167 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21170 case RULE_OP_MANGLE_CHR_SHIFTL
:
21171 SET_NAME (rule
, rule_buf
[rule_pos
]);
21172 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21175 case RULE_OP_MANGLE_CHR_SHIFTR
:
21176 SET_NAME (rule
, rule_buf
[rule_pos
]);
21177 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21180 case RULE_OP_MANGLE_CHR_INCR
:
21181 SET_NAME (rule
, rule_buf
[rule_pos
]);
21182 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21185 case RULE_OP_MANGLE_CHR_DECR
:
21186 SET_NAME (rule
, rule_buf
[rule_pos
]);
21187 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21190 case RULE_OP_MANGLE_REPLACE_NP1
:
21191 SET_NAME (rule
, rule_buf
[rule_pos
]);
21192 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21195 case RULE_OP_MANGLE_REPLACE_NM1
:
21196 SET_NAME (rule
, rule_buf
[rule_pos
]);
21197 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21200 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21201 SET_NAME (rule
, rule_buf
[rule_pos
]);
21202 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21205 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21206 SET_NAME (rule
, rule_buf
[rule_pos
]);
21207 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21210 case RULE_OP_MANGLE_TITLE
:
21211 SET_NAME (rule
, rule_buf
[rule_pos
]);
21220 if (rule_pos
< rule_len
) return (-1);
21225 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21229 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21233 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21237 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21241 case RULE_OP_MANGLE_NOOP
:
21242 rule_buf
[rule_pos
] = rule_cmd
;
21245 case RULE_OP_MANGLE_LREST
:
21246 rule_buf
[rule_pos
] = rule_cmd
;
21249 case RULE_OP_MANGLE_UREST
:
21250 rule_buf
[rule_pos
] = rule_cmd
;
21253 case RULE_OP_MANGLE_LREST_UFIRST
:
21254 rule_buf
[rule_pos
] = rule_cmd
;
21257 case RULE_OP_MANGLE_UREST_LFIRST
:
21258 rule_buf
[rule_pos
] = rule_cmd
;
21261 case RULE_OP_MANGLE_TREST
:
21262 rule_buf
[rule_pos
] = rule_cmd
;
21265 case RULE_OP_MANGLE_TOGGLE_AT
:
21266 rule_buf
[rule_pos
] = rule_cmd
;
21267 GET_P0_CONV (rule
);
21270 case RULE_OP_MANGLE_REVERSE
:
21271 rule_buf
[rule_pos
] = rule_cmd
;
21274 case RULE_OP_MANGLE_DUPEWORD
:
21275 rule_buf
[rule_pos
] = rule_cmd
;
21278 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21279 rule_buf
[rule_pos
] = rule_cmd
;
21280 GET_P0_CONV (rule
);
21283 case RULE_OP_MANGLE_REFLECT
:
21284 rule_buf
[rule_pos
] = rule_cmd
;
21287 case RULE_OP_MANGLE_ROTATE_LEFT
:
21288 rule_buf
[rule_pos
] = rule_cmd
;
21291 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21292 rule_buf
[rule_pos
] = rule_cmd
;
21295 case RULE_OP_MANGLE_APPEND
:
21296 rule_buf
[rule_pos
] = rule_cmd
;
21300 case RULE_OP_MANGLE_PREPEND
:
21301 rule_buf
[rule_pos
] = rule_cmd
;
21305 case RULE_OP_MANGLE_DELETE_FIRST
:
21306 rule_buf
[rule_pos
] = rule_cmd
;
21309 case RULE_OP_MANGLE_DELETE_LAST
:
21310 rule_buf
[rule_pos
] = rule_cmd
;
21313 case RULE_OP_MANGLE_DELETE_AT
:
21314 rule_buf
[rule_pos
] = rule_cmd
;
21315 GET_P0_CONV (rule
);
21318 case RULE_OP_MANGLE_EXTRACT
:
21319 rule_buf
[rule_pos
] = rule_cmd
;
21320 GET_P0_CONV (rule
);
21321 GET_P1_CONV (rule
);
21324 case RULE_OP_MANGLE_OMIT
:
21325 rule_buf
[rule_pos
] = rule_cmd
;
21326 GET_P0_CONV (rule
);
21327 GET_P1_CONV (rule
);
21330 case RULE_OP_MANGLE_INSERT
:
21331 rule_buf
[rule_pos
] = rule_cmd
;
21332 GET_P0_CONV (rule
);
21336 case RULE_OP_MANGLE_OVERSTRIKE
:
21337 rule_buf
[rule_pos
] = rule_cmd
;
21338 GET_P0_CONV (rule
);
21342 case RULE_OP_MANGLE_TRUNCATE_AT
:
21343 rule_buf
[rule_pos
] = rule_cmd
;
21344 GET_P0_CONV (rule
);
21347 case RULE_OP_MANGLE_REPLACE
:
21348 rule_buf
[rule_pos
] = rule_cmd
;
21353 case RULE_OP_MANGLE_PURGECHAR
:
21357 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21361 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21362 rule_buf
[rule_pos
] = rule_cmd
;
21363 GET_P0_CONV (rule
);
21366 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21367 rule_buf
[rule_pos
] = rule_cmd
;
21368 GET_P0_CONV (rule
);
21371 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21372 rule_buf
[rule_pos
] = rule_cmd
;
21375 case RULE_OP_MANGLE_SWITCH_FIRST
:
21376 rule_buf
[rule_pos
] = rule_cmd
;
21379 case RULE_OP_MANGLE_SWITCH_LAST
:
21380 rule_buf
[rule_pos
] = rule_cmd
;
21383 case RULE_OP_MANGLE_SWITCH_AT
:
21384 rule_buf
[rule_pos
] = rule_cmd
;
21385 GET_P0_CONV (rule
);
21386 GET_P1_CONV (rule
);
21389 case RULE_OP_MANGLE_CHR_SHIFTL
:
21390 rule_buf
[rule_pos
] = rule_cmd
;
21391 GET_P0_CONV (rule
);
21394 case RULE_OP_MANGLE_CHR_SHIFTR
:
21395 rule_buf
[rule_pos
] = rule_cmd
;
21396 GET_P0_CONV (rule
);
21399 case RULE_OP_MANGLE_CHR_INCR
:
21400 rule_buf
[rule_pos
] = rule_cmd
;
21401 GET_P0_CONV (rule
);
21404 case RULE_OP_MANGLE_CHR_DECR
:
21405 rule_buf
[rule_pos
] = rule_cmd
;
21406 GET_P0_CONV (rule
);
21409 case RULE_OP_MANGLE_REPLACE_NP1
:
21410 rule_buf
[rule_pos
] = rule_cmd
;
21411 GET_P0_CONV (rule
);
21414 case RULE_OP_MANGLE_REPLACE_NM1
:
21415 rule_buf
[rule_pos
] = rule_cmd
;
21416 GET_P0_CONV (rule
);
21419 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21420 rule_buf
[rule_pos
] = rule_cmd
;
21421 GET_P0_CONV (rule
);
21424 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21425 rule_buf
[rule_pos
] = rule_cmd
;
21426 GET_P0_CONV (rule
);
21429 case RULE_OP_MANGLE_TITLE
:
21430 rule_buf
[rule_pos
] = rule_cmd
;
21434 return rule_pos
- 1;
21452 * CPU rules : this is from hashcat sources, cpu based rules
21455 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21456 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21458 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21459 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21460 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21462 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21463 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21464 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21466 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21470 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21475 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21479 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21484 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21488 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21493 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21498 for (l
= 0; l
< arr_len
; l
++)
21500 r
= arr_len
- 1 - l
;
21504 MANGLE_SWITCH (arr
, l
, r
);
21510 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21512 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21514 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21516 return (arr_len
* 2);
21519 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21521 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21523 int orig_len
= arr_len
;
21527 for (i
= 0; i
< times
; i
++)
21529 memcpy (&arr
[arr_len
], arr
, orig_len
);
21531 arr_len
+= orig_len
;
21537 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21539 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21541 mangle_double (arr
, arr_len
);
21543 mangle_reverse (arr
+ arr_len
, arr_len
);
21545 return (arr_len
* 2);
21548 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21553 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21555 MANGLE_SWITCH (arr
, l
, r
);
21561 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21566 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21568 MANGLE_SWITCH (arr
, l
, r
);
21574 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21576 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21580 return (arr_len
+ 1);
21583 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21585 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21589 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21591 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21596 return (arr_len
+ 1);
21599 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21601 if (upos
>= arr_len
) return (arr_len
);
21605 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21607 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21610 return (arr_len
- 1);
21613 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21615 if (upos
>= arr_len
) return (arr_len
);
21617 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21621 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21623 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21629 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21631 if (upos
>= arr_len
) return (arr_len
);
21633 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21637 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21639 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21642 return (arr_len
- ulen
);
21645 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21647 if (upos
>= arr_len
) return (arr_len
);
21649 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21653 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21655 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21660 return (arr_len
+ 1);
21663 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
)
21665 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21667 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21669 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21671 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21673 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21675 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21677 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21679 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21681 return (arr_len
+ arr2_cpy
);
21684 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21686 if (upos
>= arr_len
) return (arr_len
);
21693 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21695 if (upos
>= arr_len
) return (arr_len
);
21697 memset (arr
+ upos
, 0, arr_len
- upos
);
21702 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21706 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21708 if (arr
[arr_pos
] != oldc
) continue;
21710 arr
[arr_pos
] = newc
;
21716 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21722 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21724 if (arr
[arr_pos
] == c
) continue;
21726 arr
[ret_len
] = arr
[arr_pos
];
21734 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21736 if (ulen
> arr_len
) return (arr_len
);
21738 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21740 char cs
[100] = { 0 };
21742 memcpy (cs
, arr
, ulen
);
21746 for (i
= 0; i
< ulen
; i
++)
21750 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21756 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21758 if (ulen
> arr_len
) return (arr_len
);
21760 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21762 int upos
= arr_len
- ulen
;
21766 for (i
= 0; i
< ulen
; i
++)
21768 char c
= arr
[upos
+ i
];
21770 arr_len
= mangle_append (arr
, arr_len
, c
);
21776 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21778 if ( arr_len
== 0) return (arr_len
);
21779 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21781 char c
= arr
[upos
];
21785 for (i
= 0; i
< ulen
; i
++)
21787 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21793 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21795 if ( arr_len
== 0) return (arr_len
);
21796 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21800 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21802 int new_pos
= arr_pos
* 2;
21804 arr
[new_pos
] = arr
[arr_pos
];
21806 arr
[new_pos
+ 1] = arr
[arr_pos
];
21809 return (arr_len
* 2);
21812 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21814 if (upos
>= arr_len
) return (arr_len
);
21815 if (upos2
>= arr_len
) return (arr_len
);
21817 MANGLE_SWITCH (arr
, upos
, upos2
);
21822 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21824 MANGLE_SWITCH (arr
, upos
, upos2
);
21829 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21831 if (upos
>= arr_len
) return (arr_len
);
21838 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21840 if (upos
>= arr_len
) return (arr_len
);
21847 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21849 if (upos
>= arr_len
) return (arr_len
);
21856 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21858 if (upos
>= arr_len
) return (arr_len
);
21865 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21867 int upper_next
= 1;
21871 for (pos
= 0; pos
< arr_len
; pos
++)
21873 if (arr
[pos
] == ' ')
21884 MANGLE_UPPER_AT (arr
, pos
);
21888 MANGLE_LOWER_AT (arr
, pos
);
21895 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21897 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21903 for (j
= 0; j
< rp_gen_num
; j
++)
21910 switch ((char) get_random_num (0, 9))
21913 r
= get_random_num (0, sizeof (grp_op_nop
));
21914 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21918 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21919 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21920 p1
= get_random_num (0, sizeof (grp_pos
));
21921 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21925 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21926 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21927 p1
= get_random_num (1, 6);
21928 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21932 r
= get_random_num (0, sizeof (grp_op_chr
));
21933 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21934 p1
= get_random_num (0x20, 0x7e);
21935 rule_buf
[rule_pos
++] = (char) p1
;
21939 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21940 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21941 p1
= get_random_num (0x20, 0x7e);
21942 rule_buf
[rule_pos
++] = (char) p1
;
21943 p2
= get_random_num (0x20, 0x7e);
21945 p2
= get_random_num (0x20, 0x7e);
21946 rule_buf
[rule_pos
++] = (char) p2
;
21950 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21951 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21952 p1
= get_random_num (0, sizeof (grp_pos
));
21953 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21954 p2
= get_random_num (0x20, 0x7e);
21955 rule_buf
[rule_pos
++] = (char) p2
;
21959 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21960 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21961 p1
= get_random_num (0, sizeof (grp_pos
));
21962 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21963 p2
= get_random_num (0, sizeof (grp_pos
));
21965 p2
= get_random_num (0, sizeof (grp_pos
));
21966 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21970 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21971 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21972 p1
= get_random_num (0, sizeof (grp_pos
));
21973 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21974 p2
= get_random_num (1, sizeof (grp_pos
));
21976 p2
= get_random_num (1, sizeof (grp_pos
));
21977 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21981 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21982 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21983 p1
= get_random_num (0, sizeof (grp_pos
));
21984 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21985 p2
= get_random_num (1, sizeof (grp_pos
));
21986 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21987 p3
= get_random_num (0, sizeof (grp_pos
));
21988 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21996 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21998 char mem
[BLOCK_SIZE
] = { 0 };
22000 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
22002 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
22004 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22006 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
22008 int out_len
= in_len
;
22009 int mem_len
= in_len
;
22011 memcpy (out
, in
, out_len
);
22015 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
22020 switch (rule
[rule_pos
])
22025 case RULE_OP_MANGLE_NOOP
:
22028 case RULE_OP_MANGLE_LREST
:
22029 out_len
= mangle_lrest (out
, out_len
);
22032 case RULE_OP_MANGLE_UREST
:
22033 out_len
= mangle_urest (out
, out_len
);
22036 case RULE_OP_MANGLE_LREST_UFIRST
:
22037 out_len
= mangle_lrest (out
, out_len
);
22038 if (out_len
) MANGLE_UPPER_AT (out
, 0);
22041 case RULE_OP_MANGLE_UREST_LFIRST
:
22042 out_len
= mangle_urest (out
, out_len
);
22043 if (out_len
) MANGLE_LOWER_AT (out
, 0);
22046 case RULE_OP_MANGLE_TREST
:
22047 out_len
= mangle_trest (out
, out_len
);
22050 case RULE_OP_MANGLE_TOGGLE_AT
:
22051 NEXT_RULEPOS (rule_pos
);
22052 NEXT_RPTOI (rule
, rule_pos
, upos
);
22053 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
22056 case RULE_OP_MANGLE_REVERSE
:
22057 out_len
= mangle_reverse (out
, out_len
);
22060 case RULE_OP_MANGLE_DUPEWORD
:
22061 out_len
= mangle_double (out
, out_len
);
22064 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
22065 NEXT_RULEPOS (rule_pos
);
22066 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22067 out_len
= mangle_double_times (out
, out_len
, ulen
);
22070 case RULE_OP_MANGLE_REFLECT
:
22071 out_len
= mangle_reflect (out
, out_len
);
22074 case RULE_OP_MANGLE_ROTATE_LEFT
:
22075 mangle_rotate_left (out
, out_len
);
22078 case RULE_OP_MANGLE_ROTATE_RIGHT
:
22079 mangle_rotate_right (out
, out_len
);
22082 case RULE_OP_MANGLE_APPEND
:
22083 NEXT_RULEPOS (rule_pos
);
22084 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
22087 case RULE_OP_MANGLE_PREPEND
:
22088 NEXT_RULEPOS (rule_pos
);
22089 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
22092 case RULE_OP_MANGLE_DELETE_FIRST
:
22093 out_len
= mangle_delete_at (out
, out_len
, 0);
22096 case RULE_OP_MANGLE_DELETE_LAST
:
22097 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
22100 case RULE_OP_MANGLE_DELETE_AT
:
22101 NEXT_RULEPOS (rule_pos
);
22102 NEXT_RPTOI (rule
, rule_pos
, upos
);
22103 out_len
= mangle_delete_at (out
, out_len
, upos
);
22106 case RULE_OP_MANGLE_EXTRACT
:
22107 NEXT_RULEPOS (rule_pos
);
22108 NEXT_RPTOI (rule
, rule_pos
, upos
);
22109 NEXT_RULEPOS (rule_pos
);
22110 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22111 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
22114 case RULE_OP_MANGLE_OMIT
:
22115 NEXT_RULEPOS (rule_pos
);
22116 NEXT_RPTOI (rule
, rule_pos
, upos
);
22117 NEXT_RULEPOS (rule_pos
);
22118 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22119 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
22122 case RULE_OP_MANGLE_INSERT
:
22123 NEXT_RULEPOS (rule_pos
);
22124 NEXT_RPTOI (rule
, rule_pos
, upos
);
22125 NEXT_RULEPOS (rule_pos
);
22126 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22129 case RULE_OP_MANGLE_OVERSTRIKE
:
22130 NEXT_RULEPOS (rule_pos
);
22131 NEXT_RPTOI (rule
, rule_pos
, upos
);
22132 NEXT_RULEPOS (rule_pos
);
22133 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22136 case RULE_OP_MANGLE_TRUNCATE_AT
:
22137 NEXT_RULEPOS (rule_pos
);
22138 NEXT_RPTOI (rule
, rule_pos
, upos
);
22139 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22142 case RULE_OP_MANGLE_REPLACE
:
22143 NEXT_RULEPOS (rule_pos
);
22144 NEXT_RULEPOS (rule_pos
);
22145 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22148 case RULE_OP_MANGLE_PURGECHAR
:
22149 NEXT_RULEPOS (rule_pos
);
22150 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22153 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22157 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22158 NEXT_RULEPOS (rule_pos
);
22159 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22160 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22163 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22164 NEXT_RULEPOS (rule_pos
);
22165 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22166 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22169 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22170 out_len
= mangle_dupechar (out
, out_len
);
22173 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22174 NEXT_RULEPOS (rule_pos
);
22175 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22176 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22179 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22180 NEXT_RULEPOS (rule_pos
);
22181 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22182 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22185 case RULE_OP_MANGLE_SWITCH_FIRST
:
22186 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22189 case RULE_OP_MANGLE_SWITCH_LAST
:
22190 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22193 case RULE_OP_MANGLE_SWITCH_AT
:
22194 NEXT_RULEPOS (rule_pos
);
22195 NEXT_RPTOI (rule
, rule_pos
, upos
);
22196 NEXT_RULEPOS (rule_pos
);
22197 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22198 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22201 case RULE_OP_MANGLE_CHR_SHIFTL
:
22202 NEXT_RULEPOS (rule_pos
);
22203 NEXT_RPTOI (rule
, rule_pos
, upos
);
22204 mangle_chr_shiftl (out
, out_len
, upos
);
22207 case RULE_OP_MANGLE_CHR_SHIFTR
:
22208 NEXT_RULEPOS (rule_pos
);
22209 NEXT_RPTOI (rule
, rule_pos
, upos
);
22210 mangle_chr_shiftr (out
, out_len
, upos
);
22213 case RULE_OP_MANGLE_CHR_INCR
:
22214 NEXT_RULEPOS (rule_pos
);
22215 NEXT_RPTOI (rule
, rule_pos
, upos
);
22216 mangle_chr_incr (out
, out_len
, upos
);
22219 case RULE_OP_MANGLE_CHR_DECR
:
22220 NEXT_RULEPOS (rule_pos
);
22221 NEXT_RPTOI (rule
, rule_pos
, upos
);
22222 mangle_chr_decr (out
, out_len
, upos
);
22225 case RULE_OP_MANGLE_REPLACE_NP1
:
22226 NEXT_RULEPOS (rule_pos
);
22227 NEXT_RPTOI (rule
, rule_pos
, upos
);
22228 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22231 case RULE_OP_MANGLE_REPLACE_NM1
:
22232 NEXT_RULEPOS (rule_pos
);
22233 NEXT_RPTOI (rule
, rule_pos
, upos
);
22234 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22237 case RULE_OP_MANGLE_TITLE
:
22238 out_len
= mangle_title (out
, out_len
);
22241 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22242 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22243 NEXT_RULEPOS (rule_pos
);
22244 NEXT_RPTOI (rule
, rule_pos
, upos
);
22245 NEXT_RULEPOS (rule_pos
);
22246 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22247 NEXT_RULEPOS (rule_pos
);
22248 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22249 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22252 case RULE_OP_MANGLE_APPEND_MEMORY
:
22253 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22254 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22255 memcpy (out
+ out_len
, mem
, mem_len
);
22256 out_len
+= mem_len
;
22259 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22260 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22261 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22262 memcpy (mem
+ mem_len
, out
, out_len
);
22263 out_len
+= mem_len
;
22264 memcpy (out
, mem
, out_len
);
22267 case RULE_OP_MEMORIZE_WORD
:
22268 memcpy (mem
, out
, out_len
);
22272 case RULE_OP_REJECT_LESS
:
22273 NEXT_RULEPOS (rule_pos
);
22274 NEXT_RPTOI (rule
, rule_pos
, upos
);
22275 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22278 case RULE_OP_REJECT_GREATER
:
22279 NEXT_RULEPOS (rule_pos
);
22280 NEXT_RPTOI (rule
, rule_pos
, upos
);
22281 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22284 case RULE_OP_REJECT_CONTAIN
:
22285 NEXT_RULEPOS (rule_pos
);
22286 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22289 case RULE_OP_REJECT_NOT_CONTAIN
:
22290 NEXT_RULEPOS (rule_pos
);
22291 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22294 case RULE_OP_REJECT_EQUAL_FIRST
:
22295 NEXT_RULEPOS (rule_pos
);
22296 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22299 case RULE_OP_REJECT_EQUAL_LAST
:
22300 NEXT_RULEPOS (rule_pos
);
22301 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22304 case RULE_OP_REJECT_EQUAL_AT
:
22305 NEXT_RULEPOS (rule_pos
);
22306 NEXT_RPTOI (rule
, rule_pos
, upos
);
22307 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22308 NEXT_RULEPOS (rule_pos
);
22309 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22312 case RULE_OP_REJECT_CONTAINS
:
22313 NEXT_RULEPOS (rule_pos
);
22314 NEXT_RPTOI (rule
, rule_pos
, upos
);
22315 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22316 NEXT_RULEPOS (rule_pos
);
22317 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22318 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22321 case RULE_OP_REJECT_MEMORY
:
22322 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22326 return (RULE_RC_SYNTAX_ERROR
);
22331 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);