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(__APPLE__) || 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
)
5803 memset (&e
, 0, sizeof (e
));
5805 struct dirent
*de
= NULL
;
5807 if (readdir_r (d
, &e
, &de
) != 0)
5809 log_error ("ERROR: readdir_r() failed");
5814 if (de
== NULL
) break;
5820 while ((de
= readdir (d
)) != NULL
)
5825 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5827 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5829 char *path_file
= (char *) mymalloc (path_size
+ 1);
5831 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5833 path_file
[path_size
] = 0;
5837 if ((d_test
= opendir (path_file
)) != NULL
)
5845 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5849 files
[num_files
- 1] = path_file
;
5855 else if (errno
== ENOTDIR
)
5857 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5861 files
[num_files
- 1] = mystrdup (path
);
5864 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5868 files
[num_files
- 1] = NULL
;
5875 int count_dictionaries (char **dictionary_files
)
5877 if (dictionary_files
== NULL
) return 0;
5881 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5889 char *stroptitype (const uint opti_type
)
5893 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5894 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5895 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5896 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5897 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5898 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5899 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5900 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5901 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5902 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5903 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5904 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5905 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5906 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5907 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5908 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5909 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5910 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5911 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5917 char *strparser (const uint parser_status
)
5919 switch (parser_status
)
5921 case PARSER_OK
: return ((char *) PA_000
); break;
5922 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5923 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5924 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5925 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5926 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5927 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5928 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5929 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5930 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5931 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5932 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5933 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5934 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5935 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5936 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5937 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5940 return ((char *) PA_255
);
5943 char *strhashtype (const uint hash_mode
)
5947 case 0: return ((char *) HT_00000
); break;
5948 case 10: return ((char *) HT_00010
); break;
5949 case 11: return ((char *) HT_00011
); break;
5950 case 12: return ((char *) HT_00012
); break;
5951 case 20: return ((char *) HT_00020
); break;
5952 case 21: return ((char *) HT_00021
); break;
5953 case 22: return ((char *) HT_00022
); break;
5954 case 23: return ((char *) HT_00023
); break;
5955 case 30: return ((char *) HT_00030
); break;
5956 case 40: return ((char *) HT_00040
); break;
5957 case 50: return ((char *) HT_00050
); break;
5958 case 60: return ((char *) HT_00060
); break;
5959 case 100: return ((char *) HT_00100
); break;
5960 case 101: return ((char *) HT_00101
); break;
5961 case 110: return ((char *) HT_00110
); break;
5962 case 111: return ((char *) HT_00111
); break;
5963 case 112: return ((char *) HT_00112
); break;
5964 case 120: return ((char *) HT_00120
); break;
5965 case 121: return ((char *) HT_00121
); break;
5966 case 122: return ((char *) HT_00122
); break;
5967 case 124: return ((char *) HT_00124
); break;
5968 case 125: return ((char *) HT_00125
); break;
5969 case 130: return ((char *) HT_00130
); break;
5970 case 131: return ((char *) HT_00131
); break;
5971 case 132: return ((char *) HT_00132
); break;
5972 case 133: return ((char *) HT_00133
); break;
5973 case 140: return ((char *) HT_00140
); break;
5974 case 141: return ((char *) HT_00141
); break;
5975 case 150: return ((char *) HT_00150
); break;
5976 case 160: return ((char *) HT_00160
); break;
5977 case 200: return ((char *) HT_00200
); break;
5978 case 300: return ((char *) HT_00300
); break;
5979 case 400: return ((char *) HT_00400
); break;
5980 case 500: return ((char *) HT_00500
); break;
5981 case 501: return ((char *) HT_00501
); break;
5982 case 900: return ((char *) HT_00900
); break;
5983 case 910: return ((char *) HT_00910
); break;
5984 case 1000: return ((char *) HT_01000
); break;
5985 case 1100: return ((char *) HT_01100
); break;
5986 case 1400: return ((char *) HT_01400
); break;
5987 case 1410: return ((char *) HT_01410
); break;
5988 case 1420: return ((char *) HT_01420
); break;
5989 case 1421: return ((char *) HT_01421
); break;
5990 case 1430: return ((char *) HT_01430
); break;
5991 case 1440: return ((char *) HT_01440
); break;
5992 case 1441: return ((char *) HT_01441
); break;
5993 case 1450: return ((char *) HT_01450
); break;
5994 case 1460: return ((char *) HT_01460
); break;
5995 case 1500: return ((char *) HT_01500
); break;
5996 case 1600: return ((char *) HT_01600
); break;
5997 case 1700: return ((char *) HT_01700
); break;
5998 case 1710: return ((char *) HT_01710
); break;
5999 case 1711: return ((char *) HT_01711
); break;
6000 case 1720: return ((char *) HT_01720
); break;
6001 case 1722: return ((char *) HT_01722
); break;
6002 case 1730: return ((char *) HT_01730
); break;
6003 case 1731: return ((char *) HT_01731
); break;
6004 case 1740: return ((char *) HT_01740
); break;
6005 case 1750: return ((char *) HT_01750
); break;
6006 case 1760: return ((char *) HT_01760
); break;
6007 case 1800: return ((char *) HT_01800
); break;
6008 case 2100: return ((char *) HT_02100
); break;
6009 case 2400: return ((char *) HT_02400
); break;
6010 case 2410: return ((char *) HT_02410
); break;
6011 case 2500: return ((char *) HT_02500
); break;
6012 case 2600: return ((char *) HT_02600
); break;
6013 case 2611: return ((char *) HT_02611
); break;
6014 case 2612: return ((char *) HT_02612
); break;
6015 case 2711: return ((char *) HT_02711
); break;
6016 case 2811: return ((char *) HT_02811
); break;
6017 case 3000: return ((char *) HT_03000
); break;
6018 case 3100: return ((char *) HT_03100
); break;
6019 case 3200: return ((char *) HT_03200
); break;
6020 case 3710: return ((char *) HT_03710
); break;
6021 case 3711: return ((char *) HT_03711
); break;
6022 case 3800: return ((char *) HT_03800
); break;
6023 case 4300: return ((char *) HT_04300
); break;
6024 case 4400: return ((char *) HT_04400
); break;
6025 case 4500: return ((char *) HT_04500
); break;
6026 case 4700: return ((char *) HT_04700
); break;
6027 case 4800: return ((char *) HT_04800
); break;
6028 case 4900: return ((char *) HT_04900
); break;
6029 case 5000: return ((char *) HT_05000
); break;
6030 case 5100: return ((char *) HT_05100
); break;
6031 case 5200: return ((char *) HT_05200
); break;
6032 case 5300: return ((char *) HT_05300
); break;
6033 case 5400: return ((char *) HT_05400
); break;
6034 case 5500: return ((char *) HT_05500
); break;
6035 case 5600: return ((char *) HT_05600
); break;
6036 case 5700: return ((char *) HT_05700
); break;
6037 case 5800: return ((char *) HT_05800
); break;
6038 case 6000: return ((char *) HT_06000
); break;
6039 case 6100: return ((char *) HT_06100
); break;
6040 case 6211: return ((char *) HT_06211
); break;
6041 case 6212: return ((char *) HT_06212
); break;
6042 case 6213: return ((char *) HT_06213
); break;
6043 case 6221: return ((char *) HT_06221
); break;
6044 case 6222: return ((char *) HT_06222
); break;
6045 case 6223: return ((char *) HT_06223
); break;
6046 case 6231: return ((char *) HT_06231
); break;
6047 case 6232: return ((char *) HT_06232
); break;
6048 case 6233: return ((char *) HT_06233
); break;
6049 case 6241: return ((char *) HT_06241
); break;
6050 case 6242: return ((char *) HT_06242
); break;
6051 case 6243: return ((char *) HT_06243
); break;
6052 case 6300: return ((char *) HT_06300
); break;
6053 case 6400: return ((char *) HT_06400
); break;
6054 case 6500: return ((char *) HT_06500
); break;
6055 case 6600: return ((char *) HT_06600
); break;
6056 case 6700: return ((char *) HT_06700
); break;
6057 case 6800: return ((char *) HT_06800
); break;
6058 case 6900: return ((char *) HT_06900
); break;
6059 case 7100: return ((char *) HT_07100
); break;
6060 case 7200: return ((char *) HT_07200
); break;
6061 case 7300: return ((char *) HT_07300
); break;
6062 case 7400: return ((char *) HT_07400
); break;
6063 case 7500: return ((char *) HT_07500
); break;
6064 case 7600: return ((char *) HT_07600
); break;
6065 case 7700: return ((char *) HT_07700
); break;
6066 case 7800: return ((char *) HT_07800
); break;
6067 case 7900: return ((char *) HT_07900
); break;
6068 case 8000: return ((char *) HT_08000
); break;
6069 case 8100: return ((char *) HT_08100
); break;
6070 case 8200: return ((char *) HT_08200
); break;
6071 case 8300: return ((char *) HT_08300
); break;
6072 case 8400: return ((char *) HT_08400
); break;
6073 case 8500: return ((char *) HT_08500
); break;
6074 case 8600: return ((char *) HT_08600
); break;
6075 case 8700: return ((char *) HT_08700
); break;
6076 case 8800: return ((char *) HT_08800
); break;
6077 case 8900: return ((char *) HT_08900
); break;
6078 case 9000: return ((char *) HT_09000
); break;
6079 case 9100: return ((char *) HT_09100
); break;
6080 case 9200: return ((char *) HT_09200
); break;
6081 case 9300: return ((char *) HT_09300
); break;
6082 case 9400: return ((char *) HT_09400
); break;
6083 case 9500: return ((char *) HT_09500
); break;
6084 case 9600: return ((char *) HT_09600
); break;
6085 case 9700: return ((char *) HT_09700
); break;
6086 case 9710: return ((char *) HT_09710
); break;
6087 case 9720: return ((char *) HT_09720
); break;
6088 case 9800: return ((char *) HT_09800
); break;
6089 case 9810: return ((char *) HT_09810
); break;
6090 case 9820: return ((char *) HT_09820
); break;
6091 case 9900: return ((char *) HT_09900
); break;
6092 case 10000: return ((char *) HT_10000
); break;
6093 case 10100: return ((char *) HT_10100
); break;
6094 case 10200: return ((char *) HT_10200
); break;
6095 case 10300: return ((char *) HT_10300
); break;
6096 case 10400: return ((char *) HT_10400
); break;
6097 case 10410: return ((char *) HT_10410
); break;
6098 case 10420: return ((char *) HT_10420
); break;
6099 case 10500: return ((char *) HT_10500
); break;
6100 case 10600: return ((char *) HT_10600
); break;
6101 case 10700: return ((char *) HT_10700
); break;
6102 case 10800: return ((char *) HT_10800
); break;
6103 case 10900: return ((char *) HT_10900
); break;
6104 case 11000: return ((char *) HT_11000
); break;
6105 case 11100: return ((char *) HT_11100
); break;
6106 case 11200: return ((char *) HT_11200
); break;
6107 case 11300: return ((char *) HT_11300
); break;
6108 case 11400: return ((char *) HT_11400
); break;
6109 case 11500: return ((char *) HT_11500
); break;
6110 case 11600: return ((char *) HT_11600
); break;
6111 case 11700: return ((char *) HT_11700
); break;
6112 case 11800: return ((char *) HT_11800
); break;
6113 case 11900: return ((char *) HT_11900
); break;
6114 case 12000: return ((char *) HT_12000
); break;
6115 case 12100: return ((char *) HT_12100
); break;
6116 case 12200: return ((char *) HT_12200
); break;
6117 case 12300: return ((char *) HT_12300
); break;
6118 case 12400: return ((char *) HT_12400
); break;
6119 case 12500: return ((char *) HT_12500
); break;
6120 case 12600: return ((char *) HT_12600
); break;
6121 case 12700: return ((char *) HT_12700
); break;
6122 case 12800: return ((char *) HT_12800
); break;
6123 case 12900: return ((char *) HT_12900
); break;
6124 case 13000: return ((char *) HT_13000
); break;
6125 case 13100: return ((char *) HT_13100
); break;
6126 case 13200: return ((char *) HT_13200
); break;
6127 case 13300: return ((char *) HT_13300
); break;
6128 case 13400: return ((char *) HT_13400
); break;
6129 case 13500: return ((char *) HT_13500
); break;
6130 case 13600: return ((char *) HT_13600
); break;
6131 case 13711: return ((char *) HT_13711
); break;
6132 case 13712: return ((char *) HT_13712
); break;
6133 case 13713: return ((char *) HT_13713
); break;
6134 case 13721: return ((char *) HT_13721
); break;
6135 case 13722: return ((char *) HT_13722
); break;
6136 case 13723: return ((char *) HT_13723
); break;
6137 case 13731: return ((char *) HT_13731
); break;
6138 case 13732: return ((char *) HT_13732
); break;
6139 case 13733: return ((char *) HT_13733
); break;
6140 case 13741: return ((char *) HT_13741
); break;
6141 case 13742: return ((char *) HT_13742
); break;
6142 case 13743: return ((char *) HT_13743
); break;
6143 case 13751: return ((char *) HT_13751
); break;
6144 case 13752: return ((char *) HT_13752
); break;
6145 case 13753: return ((char *) HT_13753
); break;
6146 case 13761: return ((char *) HT_13761
); break;
6147 case 13762: return ((char *) HT_13762
); break;
6148 case 13763: return ((char *) HT_13763
); break;
6149 case 13800: return ((char *) HT_13800
); break;
6152 return ((char *) "Unknown");
6155 char *strstatus (const uint devices_status
)
6157 switch (devices_status
)
6159 case STATUS_INIT
: return ((char *) ST_0000
); break;
6160 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6161 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6162 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6163 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6164 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6165 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6166 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6167 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6168 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6169 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6172 return ((char *) "Unknown");
6175 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6177 uint hash_type
= data
.hash_type
;
6178 uint hash_mode
= data
.hash_mode
;
6179 uint salt_type
= data
.salt_type
;
6180 uint opts_type
= data
.opts_type
;
6181 uint opti_type
= data
.opti_type
;
6182 uint dgst_size
= data
.dgst_size
;
6184 char *hashfile
= data
.hashfile
;
6188 u8 datax
[256] = { 0 };
6190 u64
*digest_buf64
= (u64
*) datax
;
6191 u32
*digest_buf
= (u32
*) datax
;
6193 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6195 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6197 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6203 case HASH_TYPE_DESCRYPT
:
6204 FP (digest_buf
[1], digest_buf
[0], tt
);
6207 case HASH_TYPE_DESRACF
:
6208 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6209 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6211 FP (digest_buf
[1], digest_buf
[0], tt
);
6215 FP (digest_buf
[1], digest_buf
[0], tt
);
6218 case HASH_TYPE_NETNTLM
:
6219 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6220 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6221 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6222 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6224 FP (digest_buf
[1], digest_buf
[0], tt
);
6225 FP (digest_buf
[3], digest_buf
[2], tt
);
6228 case HASH_TYPE_BSDICRYPT
:
6229 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6230 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6232 FP (digest_buf
[1], digest_buf
[0], tt
);
6237 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6242 digest_buf
[0] += MD4M_A
;
6243 digest_buf
[1] += MD4M_B
;
6244 digest_buf
[2] += MD4M_C
;
6245 digest_buf
[3] += MD4M_D
;
6249 digest_buf
[0] += MD5M_A
;
6250 digest_buf
[1] += MD5M_B
;
6251 digest_buf
[2] += MD5M_C
;
6252 digest_buf
[3] += MD5M_D
;
6255 case HASH_TYPE_SHA1
:
6256 digest_buf
[0] += SHA1M_A
;
6257 digest_buf
[1] += SHA1M_B
;
6258 digest_buf
[2] += SHA1M_C
;
6259 digest_buf
[3] += SHA1M_D
;
6260 digest_buf
[4] += SHA1M_E
;
6263 case HASH_TYPE_SHA256
:
6264 digest_buf
[0] += SHA256M_A
;
6265 digest_buf
[1] += SHA256M_B
;
6266 digest_buf
[2] += SHA256M_C
;
6267 digest_buf
[3] += SHA256M_D
;
6268 digest_buf
[4] += SHA256M_E
;
6269 digest_buf
[5] += SHA256M_F
;
6270 digest_buf
[6] += SHA256M_G
;
6271 digest_buf
[7] += SHA256M_H
;
6274 case HASH_TYPE_SHA384
:
6275 digest_buf64
[0] += SHA384M_A
;
6276 digest_buf64
[1] += SHA384M_B
;
6277 digest_buf64
[2] += SHA384M_C
;
6278 digest_buf64
[3] += SHA384M_D
;
6279 digest_buf64
[4] += SHA384M_E
;
6280 digest_buf64
[5] += SHA384M_F
;
6281 digest_buf64
[6] += 0;
6282 digest_buf64
[7] += 0;
6285 case HASH_TYPE_SHA512
:
6286 digest_buf64
[0] += SHA512M_A
;
6287 digest_buf64
[1] += SHA512M_B
;
6288 digest_buf64
[2] += SHA512M_C
;
6289 digest_buf64
[3] += SHA512M_D
;
6290 digest_buf64
[4] += SHA512M_E
;
6291 digest_buf64
[5] += SHA512M_F
;
6292 digest_buf64
[6] += SHA512M_G
;
6293 digest_buf64
[7] += SHA512M_H
;
6298 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6300 if (dgst_size
== DGST_SIZE_4_2
)
6302 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6304 else if (dgst_size
== DGST_SIZE_4_4
)
6306 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6308 else if (dgst_size
== DGST_SIZE_4_5
)
6310 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6312 else if (dgst_size
== DGST_SIZE_4_6
)
6314 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6316 else if (dgst_size
== DGST_SIZE_4_8
)
6318 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6320 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6322 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6324 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6326 else if (hash_type
== HASH_TYPE_SHA384
)
6328 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6330 else if (hash_type
== HASH_TYPE_SHA512
)
6332 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6334 else if (hash_type
== HASH_TYPE_GOST
)
6336 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6339 else if (dgst_size
== DGST_SIZE_4_64
)
6341 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6343 else if (dgst_size
== DGST_SIZE_8_25
)
6345 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6349 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6350 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6351 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6357 memset (&salt
, 0, sizeof (salt_t
));
6359 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6361 char *ptr
= (char *) salt
.salt_buf
;
6363 uint len
= salt
.salt_len
;
6365 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6371 case HASH_TYPE_NETNTLM
:
6373 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6374 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6376 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6382 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6384 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6392 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6394 uint max
= salt
.salt_len
/ 4;
6398 for (uint i
= 0; i
< max
; i
++)
6400 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6404 if (opts_type
& OPTS_TYPE_ST_HEX
)
6406 char tmp
[64] = { 0 };
6408 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6410 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6415 memcpy (ptr
, tmp
, len
);
6418 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6420 memset (ptr
+ len
, 0, memset_size
);
6422 salt
.salt_len
= len
;
6426 // some modes require special encoding
6429 uint out_buf_plain
[256] = { 0 };
6430 uint out_buf_salt
[256] = { 0 };
6432 char tmp_buf
[1024] = { 0 };
6434 char *ptr_plain
= (char *) out_buf_plain
;
6435 char *ptr_salt
= (char *) out_buf_salt
;
6437 if (hash_mode
== 22)
6439 char username
[30] = { 0 };
6441 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6443 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6445 u16
*ptr
= (u16
*) digest_buf
;
6447 tmp_buf
[ 0] = sig
[0];
6448 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6449 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6450 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6451 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6452 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6453 tmp_buf
[ 6] = sig
[1];
6454 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6455 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6456 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6457 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6458 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6459 tmp_buf
[12] = sig
[2];
6460 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6461 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6462 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6463 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6464 tmp_buf
[17] = sig
[3];
6465 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6466 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6467 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6468 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6469 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6470 tmp_buf
[23] = sig
[4];
6471 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6472 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6473 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6474 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6475 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6476 tmp_buf
[29] = sig
[5];
6478 snprintf (out_buf
, len
-1, "%s:%s",
6482 else if (hash_mode
== 23)
6484 // do not show the skyper part in output
6486 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6488 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6490 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6497 else if (hash_mode
== 101)
6499 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6501 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6502 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6503 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6504 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6505 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6507 memcpy (tmp_buf
, digest_buf
, 20);
6509 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6511 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6513 else if (hash_mode
== 111)
6515 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6517 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6518 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6519 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6520 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6521 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6523 memcpy (tmp_buf
, digest_buf
, 20);
6524 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6526 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6528 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6530 else if ((hash_mode
== 122) || (hash_mode
== 125))
6532 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6533 (char *) salt
.salt_buf
,
6540 else if (hash_mode
== 124)
6542 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6543 (char *) salt
.salt_buf
,
6550 else if (hash_mode
== 131)
6552 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6553 (char *) salt
.salt_buf
,
6561 else if (hash_mode
== 132)
6563 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6564 (char *) salt
.salt_buf
,
6571 else if (hash_mode
== 133)
6573 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6575 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6576 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6577 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6578 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6579 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6581 memcpy (tmp_buf
, digest_buf
, 20);
6583 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6585 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6587 else if (hash_mode
== 141)
6589 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6591 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6593 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6595 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6597 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6598 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6599 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6600 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6601 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6603 memcpy (tmp_buf
, digest_buf
, 20);
6605 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6609 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6611 else if (hash_mode
== 400)
6613 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6615 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6616 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6617 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6618 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6620 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6622 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6624 else if (hash_mode
== 500)
6626 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6628 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6629 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6630 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6631 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6633 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6635 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6637 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6641 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6644 else if (hash_mode
== 501)
6646 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6648 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6649 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6651 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6653 else if (hash_mode
== 1421)
6655 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6657 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6673 else if (hash_mode
== 1441)
6675 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6677 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6679 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6681 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6683 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6684 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6685 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6686 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6687 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6688 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6689 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6690 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6692 memcpy (tmp_buf
, digest_buf
, 32);
6694 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6698 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6700 else if (hash_mode
== 1500)
6702 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6703 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6704 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6705 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6706 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6708 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6710 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6712 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6713 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6715 memcpy (tmp_buf
, digest_buf
, 8);
6717 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6719 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6723 else if (hash_mode
== 1600)
6725 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6727 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6728 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6729 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6730 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6732 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6734 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6736 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6740 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6743 else if (hash_mode
== 1711)
6745 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6747 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6748 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6749 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6750 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6751 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6752 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6753 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6754 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6756 memcpy (tmp_buf
, digest_buf
, 64);
6757 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6759 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6761 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6763 else if (hash_mode
== 1722)
6765 uint
*ptr
= digest_buf
;
6767 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6768 (unsigned char *) salt
.salt_buf
,
6778 else if (hash_mode
== 1731)
6780 uint
*ptr
= digest_buf
;
6782 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6783 (unsigned char *) salt
.salt_buf
,
6793 else if (hash_mode
== 1800)
6797 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6798 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6799 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6800 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6801 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6802 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6803 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6804 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6806 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6808 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6810 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6814 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6817 else if (hash_mode
== 2100)
6821 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6823 salt
.salt_iter
+ 1);
6825 uint signature_len
= strlen (out_buf
);
6827 pos
+= signature_len
;
6828 len
-= signature_len
;
6830 char *salt_ptr
= (char *) salt
.salt_buf
;
6832 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6834 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6835 byte_swap_32 (digest_buf
[0]),
6836 byte_swap_32 (digest_buf
[1]),
6837 byte_swap_32 (digest_buf
[2]),
6838 byte_swap_32 (digest_buf
[3]));
6840 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6842 memcpy (tmp_buf
, digest_buf
, 16);
6844 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6846 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6847 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6848 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6849 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6851 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6852 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6853 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6854 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6856 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6857 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6858 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6859 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6861 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6862 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6863 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6864 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6866 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6867 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6868 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6869 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6873 else if (hash_mode
== 2500)
6875 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6877 wpa_t
*wpa
= &wpas
[salt_pos
];
6879 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6880 (char *) salt
.salt_buf
,
6894 else if (hash_mode
== 4400)
6896 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6897 byte_swap_32 (digest_buf
[0]),
6898 byte_swap_32 (digest_buf
[1]),
6899 byte_swap_32 (digest_buf
[2]),
6900 byte_swap_32 (digest_buf
[3]));
6902 else if (hash_mode
== 4700)
6904 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6905 byte_swap_32 (digest_buf
[0]),
6906 byte_swap_32 (digest_buf
[1]),
6907 byte_swap_32 (digest_buf
[2]),
6908 byte_swap_32 (digest_buf
[3]),
6909 byte_swap_32 (digest_buf
[4]));
6911 else if (hash_mode
== 4800)
6913 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6915 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6920 byte_swap_32 (salt
.salt_buf
[0]),
6921 byte_swap_32 (salt
.salt_buf
[1]),
6922 byte_swap_32 (salt
.salt_buf
[2]),
6923 byte_swap_32 (salt
.salt_buf
[3]),
6926 else if (hash_mode
== 4900)
6928 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6929 byte_swap_32 (digest_buf
[0]),
6930 byte_swap_32 (digest_buf
[1]),
6931 byte_swap_32 (digest_buf
[2]),
6932 byte_swap_32 (digest_buf
[3]),
6933 byte_swap_32 (digest_buf
[4]));
6935 else if (hash_mode
== 5100)
6937 snprintf (out_buf
, len
-1, "%08x%08x",
6941 else if (hash_mode
== 5200)
6943 snprintf (out_buf
, len
-1, "%s", hashfile
);
6945 else if (hash_mode
== 5300)
6947 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6949 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6951 int buf_len
= len
-1;
6955 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6957 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6959 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6961 snprintf (out_buf
, buf_len
, ":");
6967 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6975 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6977 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6979 if ((i
== 0) || (i
== 5))
6981 snprintf (out_buf
, buf_len
, ":");
6987 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6995 for (uint i
= 0; i
< 4; i
++)
6999 snprintf (out_buf
, buf_len
, ":");
7005 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
7011 else if (hash_mode
== 5400)
7013 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
7015 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
7017 int buf_len
= len
-1;
7021 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
7023 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
7025 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
7027 snprintf (out_buf
, buf_len
, ":");
7033 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
7041 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
7043 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
7045 if ((i
== 0) || (i
== 5))
7047 snprintf (out_buf
, buf_len
, ":");
7053 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
7061 for (uint i
= 0; i
< 5; i
++)
7065 snprintf (out_buf
, buf_len
, ":");
7071 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
7077 else if (hash_mode
== 5500)
7079 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7081 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7083 char user_buf
[64] = { 0 };
7084 char domain_buf
[64] = { 0 };
7085 char srvchall_buf
[1024] = { 0 };
7086 char clichall_buf
[1024] = { 0 };
7088 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7090 char *ptr
= (char *) netntlm
->userdomain_buf
;
7092 user_buf
[i
] = ptr
[j
];
7095 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7097 char *ptr
= (char *) netntlm
->userdomain_buf
;
7099 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7102 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7104 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7106 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7109 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7111 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7113 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7116 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7124 byte_swap_32 (salt
.salt_buf_pc
[0]),
7125 byte_swap_32 (salt
.salt_buf_pc
[1]),
7128 else if (hash_mode
== 5600)
7130 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7132 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7134 char user_buf
[64] = { 0 };
7135 char domain_buf
[64] = { 0 };
7136 char srvchall_buf
[1024] = { 0 };
7137 char clichall_buf
[1024] = { 0 };
7139 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7141 char *ptr
= (char *) netntlm
->userdomain_buf
;
7143 user_buf
[i
] = ptr
[j
];
7146 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7148 char *ptr
= (char *) netntlm
->userdomain_buf
;
7150 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7153 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7155 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7157 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7160 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7162 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7164 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7167 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7177 else if (hash_mode
== 5700)
7179 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7181 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7182 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7183 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7184 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7185 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7186 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7187 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7188 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7190 memcpy (tmp_buf
, digest_buf
, 32);
7192 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7196 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7198 else if (hash_mode
== 5800)
7200 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7201 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7202 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7203 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7204 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7206 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7213 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7215 snprintf (out_buf
, len
-1, "%s", hashfile
);
7217 else if (hash_mode
== 6300)
7219 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7221 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7222 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7223 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7224 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7226 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7228 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7230 else if (hash_mode
== 6400)
7232 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7234 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7236 else if (hash_mode
== 6500)
7238 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7240 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7242 else if (hash_mode
== 6600)
7244 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7246 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7248 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7249 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7251 uint buf_len
= len
- 1;
7253 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7256 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7258 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7263 else if (hash_mode
== 6700)
7265 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7267 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7269 else if (hash_mode
== 6800)
7271 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7273 else if (hash_mode
== 7100)
7275 uint
*ptr
= digest_buf
;
7277 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7279 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7281 uint esalt
[8] = { 0 };
7283 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7284 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7285 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7286 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7287 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7288 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7289 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7290 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7292 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",
7293 SIGNATURE_SHA512OSX
,
7295 esalt
[ 0], esalt
[ 1],
7296 esalt
[ 2], esalt
[ 3],
7297 esalt
[ 4], esalt
[ 5],
7298 esalt
[ 6], esalt
[ 7],
7306 ptr
[15], ptr
[14]);
7308 else if (hash_mode
== 7200)
7310 uint
*ptr
= digest_buf
;
7312 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7314 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7318 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7320 len_used
= strlen (out_buf
);
7322 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7324 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7326 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7329 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",
7337 ptr
[15], ptr
[14]);
7339 else if (hash_mode
== 7300)
7341 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7343 rakp_t
*rakp
= &rakps
[salt_pos
];
7345 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7347 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7350 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7357 else if (hash_mode
== 7400)
7359 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7361 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7362 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7363 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7364 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7365 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7366 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7367 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7368 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7370 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7372 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7374 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7378 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7381 else if (hash_mode
== 7500)
7383 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7385 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7387 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7388 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7390 char data
[128] = { 0 };
7392 char *ptr_data
= data
;
7394 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7396 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7399 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7401 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7406 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7408 (char *) krb5pa
->user
,
7409 (char *) krb5pa
->realm
,
7410 (char *) krb5pa
->salt
,
7413 else if (hash_mode
== 7700)
7415 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7416 (char *) salt
.salt_buf
,
7420 else if (hash_mode
== 7800)
7422 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7423 (char *) salt
.salt_buf
,
7430 else if (hash_mode
== 7900)
7432 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7436 char *tmp
= (char *) salt
.salt_buf_pc
;
7438 ptr_plain
[42] = tmp
[0];
7444 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7446 else if (hash_mode
== 8000)
7448 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7449 (unsigned char *) salt
.salt_buf
,
7459 else if (hash_mode
== 8100)
7461 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7462 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7464 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7465 (unsigned char *) salt
.salt_buf
,
7472 else if (hash_mode
== 8200)
7474 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7476 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7478 char data_buf
[4096] = { 0 };
7480 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7482 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7485 data_buf
[cloudkey
->data_len
* 2] = 0;
7487 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7488 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7489 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7490 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7491 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7492 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7493 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7494 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7496 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7497 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7498 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7499 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7501 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7517 else if (hash_mode
== 8300)
7519 char digest_buf_c
[34] = { 0 };
7521 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7522 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7523 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7524 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7525 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7527 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7529 digest_buf_c
[32] = 0;
7533 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7535 char domain_buf_c
[33] = { 0 };
7537 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7539 for (uint i
= 0; i
< salt_pc_len
; i
++)
7541 const char next
= domain_buf_c
[i
];
7543 domain_buf_c
[i
] = '.';
7548 domain_buf_c
[salt_pc_len
] = 0;
7552 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7554 else if (hash_mode
== 8500)
7556 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7558 else if (hash_mode
== 2612)
7560 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7562 (char *) salt
.salt_buf
,
7568 else if (hash_mode
== 3711)
7570 char *salt_ptr
= (char *) salt
.salt_buf
;
7572 salt_ptr
[salt
.salt_len
- 1] = 0;
7574 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7575 SIGNATURE_MEDIAWIKI_B
,
7582 else if (hash_mode
== 8800)
7584 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7586 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7588 char tmp
[3073] = { 0 };
7590 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7592 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7597 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7598 SIGNATURE_ANDROIDFDE
,
7599 byte_swap_32 (salt
.salt_buf
[0]),
7600 byte_swap_32 (salt
.salt_buf
[1]),
7601 byte_swap_32 (salt
.salt_buf
[2]),
7602 byte_swap_32 (salt
.salt_buf
[3]),
7603 byte_swap_32 (digest_buf
[0]),
7604 byte_swap_32 (digest_buf
[1]),
7605 byte_swap_32 (digest_buf
[2]),
7606 byte_swap_32 (digest_buf
[3]),
7609 else if (hash_mode
== 8900)
7611 uint N
= salt
.scrypt_N
;
7612 uint r
= salt
.scrypt_r
;
7613 uint p
= salt
.scrypt_p
;
7615 char base64_salt
[32] = { 0 };
7617 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7619 memset (tmp_buf
, 0, 46);
7621 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7622 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7623 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7624 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7625 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7626 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7627 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7628 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7629 digest_buf
[8] = 0; // needed for base64_encode ()
7631 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7633 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7641 else if (hash_mode
== 9000)
7643 snprintf (out_buf
, len
-1, "%s", hashfile
);
7645 else if (hash_mode
== 9200)
7649 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7651 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7653 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7657 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7658 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7659 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7660 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7661 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7662 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7663 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7664 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7665 digest_buf
[8] = 0; // needed for base64_encode ()
7667 char tmp_buf
[64] = { 0 };
7669 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7670 tmp_buf
[43] = 0; // cut it here
7674 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7676 else if (hash_mode
== 9300)
7678 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7679 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7680 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7681 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7682 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7683 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7684 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7685 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7686 digest_buf
[8] = 0; // needed for base64_encode ()
7688 char tmp_buf
[64] = { 0 };
7690 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7691 tmp_buf
[43] = 0; // cut it here
7693 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7695 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7697 else if (hash_mode
== 9400)
7699 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7701 office2007_t
*office2007
= &office2007s
[salt_pos
];
7703 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7704 SIGNATURE_OFFICE2007
,
7707 office2007
->keySize
,
7713 office2007
->encryptedVerifier
[0],
7714 office2007
->encryptedVerifier
[1],
7715 office2007
->encryptedVerifier
[2],
7716 office2007
->encryptedVerifier
[3],
7717 office2007
->encryptedVerifierHash
[0],
7718 office2007
->encryptedVerifierHash
[1],
7719 office2007
->encryptedVerifierHash
[2],
7720 office2007
->encryptedVerifierHash
[3],
7721 office2007
->encryptedVerifierHash
[4]);
7723 else if (hash_mode
== 9500)
7725 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7727 office2010_t
*office2010
= &office2010s
[salt_pos
];
7729 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,
7735 office2010
->encryptedVerifier
[0],
7736 office2010
->encryptedVerifier
[1],
7737 office2010
->encryptedVerifier
[2],
7738 office2010
->encryptedVerifier
[3],
7739 office2010
->encryptedVerifierHash
[0],
7740 office2010
->encryptedVerifierHash
[1],
7741 office2010
->encryptedVerifierHash
[2],
7742 office2010
->encryptedVerifierHash
[3],
7743 office2010
->encryptedVerifierHash
[4],
7744 office2010
->encryptedVerifierHash
[5],
7745 office2010
->encryptedVerifierHash
[6],
7746 office2010
->encryptedVerifierHash
[7]);
7748 else if (hash_mode
== 9600)
7750 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7752 office2013_t
*office2013
= &office2013s
[salt_pos
];
7754 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,
7760 office2013
->encryptedVerifier
[0],
7761 office2013
->encryptedVerifier
[1],
7762 office2013
->encryptedVerifier
[2],
7763 office2013
->encryptedVerifier
[3],
7764 office2013
->encryptedVerifierHash
[0],
7765 office2013
->encryptedVerifierHash
[1],
7766 office2013
->encryptedVerifierHash
[2],
7767 office2013
->encryptedVerifierHash
[3],
7768 office2013
->encryptedVerifierHash
[4],
7769 office2013
->encryptedVerifierHash
[5],
7770 office2013
->encryptedVerifierHash
[6],
7771 office2013
->encryptedVerifierHash
[7]);
7773 else if (hash_mode
== 9700)
7775 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7777 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7779 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7780 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7781 byte_swap_32 (salt
.salt_buf
[0]),
7782 byte_swap_32 (salt
.salt_buf
[1]),
7783 byte_swap_32 (salt
.salt_buf
[2]),
7784 byte_swap_32 (salt
.salt_buf
[3]),
7785 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7786 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7787 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7788 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7789 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7790 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7791 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7792 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7794 else if (hash_mode
== 9710)
7796 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7798 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7800 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7801 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7802 byte_swap_32 (salt
.salt_buf
[0]),
7803 byte_swap_32 (salt
.salt_buf
[1]),
7804 byte_swap_32 (salt
.salt_buf
[2]),
7805 byte_swap_32 (salt
.salt_buf
[3]),
7806 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7807 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7808 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7809 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7810 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7811 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7812 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7813 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7815 else if (hash_mode
== 9720)
7817 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7819 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7821 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7823 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7824 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7825 byte_swap_32 (salt
.salt_buf
[0]),
7826 byte_swap_32 (salt
.salt_buf
[1]),
7827 byte_swap_32 (salt
.salt_buf
[2]),
7828 byte_swap_32 (salt
.salt_buf
[3]),
7829 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7830 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7831 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7832 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7833 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7834 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7835 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7836 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7843 else if (hash_mode
== 9800)
7845 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7847 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7849 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7850 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7855 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7856 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7857 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7858 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7859 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7860 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7861 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7862 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7863 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7865 else if (hash_mode
== 9810)
7867 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7869 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7871 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7872 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7877 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7878 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7879 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7880 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7881 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7882 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7883 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7884 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7885 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7887 else if (hash_mode
== 9820)
7889 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7891 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7893 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7895 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7896 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7901 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7902 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7903 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7904 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7905 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7906 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7907 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7908 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7909 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7916 else if (hash_mode
== 10000)
7920 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7922 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7924 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7928 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7929 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7930 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7931 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7932 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7933 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7934 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7935 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7936 digest_buf
[8] = 0; // needed for base64_encode ()
7938 char tmp_buf
[64] = { 0 };
7940 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7944 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7946 else if (hash_mode
== 10100)
7948 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7953 byte_swap_32 (salt
.salt_buf
[0]),
7954 byte_swap_32 (salt
.salt_buf
[1]),
7955 byte_swap_32 (salt
.salt_buf
[2]),
7956 byte_swap_32 (salt
.salt_buf
[3]));
7958 else if (hash_mode
== 10200)
7960 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7962 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7966 char challenge
[100] = { 0 };
7968 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7972 char tmp_buf
[100] = { 0 };
7974 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7975 (char *) cram_md5
->user
,
7981 char response
[100] = { 0 };
7983 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7985 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7987 else if (hash_mode
== 10300)
7989 char tmp_buf
[100] = { 0 };
7991 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7992 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7994 uint tmp_len
= 20 + salt
.salt_len
;
7998 char base64_encoded
[100] = { 0 };
8000 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
8002 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
8004 else if (hash_mode
== 10400)
8006 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8008 pdf_t
*pdf
= &pdfs
[salt_pos
];
8010 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",
8018 byte_swap_32 (pdf
->id_buf
[0]),
8019 byte_swap_32 (pdf
->id_buf
[1]),
8020 byte_swap_32 (pdf
->id_buf
[2]),
8021 byte_swap_32 (pdf
->id_buf
[3]),
8023 byte_swap_32 (pdf
->u_buf
[0]),
8024 byte_swap_32 (pdf
->u_buf
[1]),
8025 byte_swap_32 (pdf
->u_buf
[2]),
8026 byte_swap_32 (pdf
->u_buf
[3]),
8027 byte_swap_32 (pdf
->u_buf
[4]),
8028 byte_swap_32 (pdf
->u_buf
[5]),
8029 byte_swap_32 (pdf
->u_buf
[6]),
8030 byte_swap_32 (pdf
->u_buf
[7]),
8032 byte_swap_32 (pdf
->o_buf
[0]),
8033 byte_swap_32 (pdf
->o_buf
[1]),
8034 byte_swap_32 (pdf
->o_buf
[2]),
8035 byte_swap_32 (pdf
->o_buf
[3]),
8036 byte_swap_32 (pdf
->o_buf
[4]),
8037 byte_swap_32 (pdf
->o_buf
[5]),
8038 byte_swap_32 (pdf
->o_buf
[6]),
8039 byte_swap_32 (pdf
->o_buf
[7])
8042 else if (hash_mode
== 10410)
8044 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8046 pdf_t
*pdf
= &pdfs
[salt_pos
];
8048 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",
8056 byte_swap_32 (pdf
->id_buf
[0]),
8057 byte_swap_32 (pdf
->id_buf
[1]),
8058 byte_swap_32 (pdf
->id_buf
[2]),
8059 byte_swap_32 (pdf
->id_buf
[3]),
8061 byte_swap_32 (pdf
->u_buf
[0]),
8062 byte_swap_32 (pdf
->u_buf
[1]),
8063 byte_swap_32 (pdf
->u_buf
[2]),
8064 byte_swap_32 (pdf
->u_buf
[3]),
8065 byte_swap_32 (pdf
->u_buf
[4]),
8066 byte_swap_32 (pdf
->u_buf
[5]),
8067 byte_swap_32 (pdf
->u_buf
[6]),
8068 byte_swap_32 (pdf
->u_buf
[7]),
8070 byte_swap_32 (pdf
->o_buf
[0]),
8071 byte_swap_32 (pdf
->o_buf
[1]),
8072 byte_swap_32 (pdf
->o_buf
[2]),
8073 byte_swap_32 (pdf
->o_buf
[3]),
8074 byte_swap_32 (pdf
->o_buf
[4]),
8075 byte_swap_32 (pdf
->o_buf
[5]),
8076 byte_swap_32 (pdf
->o_buf
[6]),
8077 byte_swap_32 (pdf
->o_buf
[7])
8080 else if (hash_mode
== 10420)
8082 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8084 pdf_t
*pdf
= &pdfs
[salt_pos
];
8086 u8
*rc4key
= (u8
*) pdf
->rc4key
;
8088 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",
8096 byte_swap_32 (pdf
->id_buf
[0]),
8097 byte_swap_32 (pdf
->id_buf
[1]),
8098 byte_swap_32 (pdf
->id_buf
[2]),
8099 byte_swap_32 (pdf
->id_buf
[3]),
8101 byte_swap_32 (pdf
->u_buf
[0]),
8102 byte_swap_32 (pdf
->u_buf
[1]),
8103 byte_swap_32 (pdf
->u_buf
[2]),
8104 byte_swap_32 (pdf
->u_buf
[3]),
8105 byte_swap_32 (pdf
->u_buf
[4]),
8106 byte_swap_32 (pdf
->u_buf
[5]),
8107 byte_swap_32 (pdf
->u_buf
[6]),
8108 byte_swap_32 (pdf
->u_buf
[7]),
8110 byte_swap_32 (pdf
->o_buf
[0]),
8111 byte_swap_32 (pdf
->o_buf
[1]),
8112 byte_swap_32 (pdf
->o_buf
[2]),
8113 byte_swap_32 (pdf
->o_buf
[3]),
8114 byte_swap_32 (pdf
->o_buf
[4]),
8115 byte_swap_32 (pdf
->o_buf
[5]),
8116 byte_swap_32 (pdf
->o_buf
[6]),
8117 byte_swap_32 (pdf
->o_buf
[7]),
8125 else if (hash_mode
== 10500)
8127 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8129 pdf_t
*pdf
= &pdfs
[salt_pos
];
8131 if (pdf
->id_len
== 32)
8133 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",
8141 byte_swap_32 (pdf
->id_buf
[0]),
8142 byte_swap_32 (pdf
->id_buf
[1]),
8143 byte_swap_32 (pdf
->id_buf
[2]),
8144 byte_swap_32 (pdf
->id_buf
[3]),
8145 byte_swap_32 (pdf
->id_buf
[4]),
8146 byte_swap_32 (pdf
->id_buf
[5]),
8147 byte_swap_32 (pdf
->id_buf
[6]),
8148 byte_swap_32 (pdf
->id_buf
[7]),
8150 byte_swap_32 (pdf
->u_buf
[0]),
8151 byte_swap_32 (pdf
->u_buf
[1]),
8152 byte_swap_32 (pdf
->u_buf
[2]),
8153 byte_swap_32 (pdf
->u_buf
[3]),
8154 byte_swap_32 (pdf
->u_buf
[4]),
8155 byte_swap_32 (pdf
->u_buf
[5]),
8156 byte_swap_32 (pdf
->u_buf
[6]),
8157 byte_swap_32 (pdf
->u_buf
[7]),
8159 byte_swap_32 (pdf
->o_buf
[0]),
8160 byte_swap_32 (pdf
->o_buf
[1]),
8161 byte_swap_32 (pdf
->o_buf
[2]),
8162 byte_swap_32 (pdf
->o_buf
[3]),
8163 byte_swap_32 (pdf
->o_buf
[4]),
8164 byte_swap_32 (pdf
->o_buf
[5]),
8165 byte_swap_32 (pdf
->o_buf
[6]),
8166 byte_swap_32 (pdf
->o_buf
[7])
8171 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",
8179 byte_swap_32 (pdf
->id_buf
[0]),
8180 byte_swap_32 (pdf
->id_buf
[1]),
8181 byte_swap_32 (pdf
->id_buf
[2]),
8182 byte_swap_32 (pdf
->id_buf
[3]),
8184 byte_swap_32 (pdf
->u_buf
[0]),
8185 byte_swap_32 (pdf
->u_buf
[1]),
8186 byte_swap_32 (pdf
->u_buf
[2]),
8187 byte_swap_32 (pdf
->u_buf
[3]),
8188 byte_swap_32 (pdf
->u_buf
[4]),
8189 byte_swap_32 (pdf
->u_buf
[5]),
8190 byte_swap_32 (pdf
->u_buf
[6]),
8191 byte_swap_32 (pdf
->u_buf
[7]),
8193 byte_swap_32 (pdf
->o_buf
[0]),
8194 byte_swap_32 (pdf
->o_buf
[1]),
8195 byte_swap_32 (pdf
->o_buf
[2]),
8196 byte_swap_32 (pdf
->o_buf
[3]),
8197 byte_swap_32 (pdf
->o_buf
[4]),
8198 byte_swap_32 (pdf
->o_buf
[5]),
8199 byte_swap_32 (pdf
->o_buf
[6]),
8200 byte_swap_32 (pdf
->o_buf
[7])
8204 else if (hash_mode
== 10600)
8206 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8208 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8209 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8211 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8213 else if (hash_mode
== 10700)
8215 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8217 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8218 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8220 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8222 else if (hash_mode
== 10900)
8224 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8226 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8227 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8229 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8231 else if (hash_mode
== 11100)
8233 u32 salt_challenge
= salt
.salt_buf
[0];
8235 salt_challenge
= byte_swap_32 (salt_challenge
);
8237 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8239 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8240 SIGNATURE_POSTGRESQL_AUTH
,
8248 else if (hash_mode
== 11200)
8250 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8251 SIGNATURE_MYSQL_AUTH
,
8252 (unsigned char *) salt
.salt_buf
,
8259 else if (hash_mode
== 11300)
8261 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8263 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8265 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8266 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8267 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8269 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8270 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8271 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8273 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8275 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8277 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8280 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8282 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8284 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8287 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8289 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8291 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8294 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8295 SIGNATURE_BITCOIN_WALLET
,
8299 (unsigned char *) salt
.salt_buf
,
8307 free (cry_master_buf
);
8309 free (public_key_buf
);
8311 else if (hash_mode
== 11400)
8313 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8315 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8316 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8318 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8320 else if (hash_mode
== 11600)
8322 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8324 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8326 const uint data_len
= seven_zip
->data_len
;
8328 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8330 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8332 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8334 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8337 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8338 SIGNATURE_SEVEN_ZIP
,
8342 (char *) seven_zip
->salt_buf
,
8344 seven_zip
->iv_buf
[0],
8345 seven_zip
->iv_buf
[1],
8346 seven_zip
->iv_buf
[2],
8347 seven_zip
->iv_buf
[3],
8349 seven_zip
->data_len
,
8350 seven_zip
->unpack_size
,
8355 else if (hash_mode
== 11700)
8357 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8367 else if (hash_mode
== 11800)
8369 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8387 else if (hash_mode
== 11900)
8389 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8391 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8392 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8394 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8396 else if (hash_mode
== 12000)
8398 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8400 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8401 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8403 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8405 else if (hash_mode
== 12100)
8407 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8409 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8410 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8412 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8414 else if (hash_mode
== 12200)
8416 uint
*ptr_digest
= digest_buf
;
8417 uint
*ptr_salt
= salt
.salt_buf
;
8419 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8426 else if (hash_mode
== 12300)
8428 uint
*ptr_digest
= digest_buf
;
8429 uint
*ptr_salt
= salt
.salt_buf
;
8431 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",
8432 ptr_digest
[ 0], ptr_digest
[ 1],
8433 ptr_digest
[ 2], ptr_digest
[ 3],
8434 ptr_digest
[ 4], ptr_digest
[ 5],
8435 ptr_digest
[ 6], ptr_digest
[ 7],
8436 ptr_digest
[ 8], ptr_digest
[ 9],
8437 ptr_digest
[10], ptr_digest
[11],
8438 ptr_digest
[12], ptr_digest
[13],
8439 ptr_digest
[14], ptr_digest
[15],
8445 else if (hash_mode
== 12400)
8447 // encode iteration count
8449 char salt_iter
[5] = { 0 };
8451 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8452 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8453 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8454 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8459 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8460 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8461 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8462 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8467 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8469 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8470 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8472 memcpy (tmp_buf
, digest_buf
, 8);
8474 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8478 // fill the resulting buffer
8480 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8482 else if (hash_mode
== 12500)
8484 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8486 byte_swap_32 (salt
.salt_buf
[0]),
8487 byte_swap_32 (salt
.salt_buf
[1]),
8493 else if (hash_mode
== 12600)
8495 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8496 digest_buf
[0] + salt
.salt_buf_pc
[0],
8497 digest_buf
[1] + salt
.salt_buf_pc
[1],
8498 digest_buf
[2] + salt
.salt_buf_pc
[2],
8499 digest_buf
[3] + salt
.salt_buf_pc
[3],
8500 digest_buf
[4] + salt
.salt_buf_pc
[4],
8501 digest_buf
[5] + salt
.salt_buf_pc
[5],
8502 digest_buf
[6] + salt
.salt_buf_pc
[6],
8503 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8505 else if (hash_mode
== 12700)
8507 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8509 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8510 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8512 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8514 else if (hash_mode
== 12800)
8516 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8518 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",
8531 byte_swap_32 (digest_buf
[0]),
8532 byte_swap_32 (digest_buf
[1]),
8533 byte_swap_32 (digest_buf
[2]),
8534 byte_swap_32 (digest_buf
[3]),
8535 byte_swap_32 (digest_buf
[4]),
8536 byte_swap_32 (digest_buf
[5]),
8537 byte_swap_32 (digest_buf
[6]),
8538 byte_swap_32 (digest_buf
[7])
8541 else if (hash_mode
== 12900)
8543 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",
8552 byte_swap_32 (digest_buf
[0]),
8553 byte_swap_32 (digest_buf
[1]),
8554 byte_swap_32 (digest_buf
[2]),
8555 byte_swap_32 (digest_buf
[3]),
8556 byte_swap_32 (digest_buf
[4]),
8557 byte_swap_32 (digest_buf
[5]),
8558 byte_swap_32 (digest_buf
[6]),
8559 byte_swap_32 (digest_buf
[7]),
8566 else if (hash_mode
== 13000)
8568 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8570 rar5_t
*rar5
= &rar5s
[salt_pos
];
8572 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8582 byte_swap_32 (digest_buf
[0]),
8583 byte_swap_32 (digest_buf
[1])
8586 else if (hash_mode
== 13100)
8588 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8590 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8592 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8593 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8595 char data
[2560 * 4 * 2] = { 0 };
8597 char *ptr_data
= data
;
8599 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8600 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8605 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8606 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8608 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8610 (char *) krb5tgs
->account_info
,
8614 else if (hash_mode
== 13200)
8616 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8630 else if (hash_mode
== 13300)
8632 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8633 SIGNATURE_AXCRYPT_SHA1
,
8639 else if (hash_mode
== 13400)
8641 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8643 keepass_t
*keepass
= &keepasss
[salt_pos
];
8645 u32 version
= (u32
) keepass
->version
;
8646 u32 rounds
= salt
.salt_iter
;
8647 u32 algorithm
= (u32
) keepass
->algorithm
;
8648 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8650 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8651 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8652 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8653 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8654 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8656 /* specific to version 1 */
8660 /* specific to version 2 */
8661 u32 expected_bytes_len
;
8662 u32
*ptr_expected_bytes
;
8664 u32 final_random_seed_len
;
8665 u32 transf_random_seed_len
;
8667 u32 contents_hash_len
;
8669 transf_random_seed_len
= 8;
8671 contents_hash_len
= 8;
8672 final_random_seed_len
= 8;
8675 final_random_seed_len
= 4;
8677 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8683 char *ptr_data
= out_buf
;
8685 ptr_data
+= strlen(out_buf
);
8690 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8691 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8696 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8697 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8702 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8703 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8710 contents_len
= (u32
) keepass
->contents_len
;
8711 ptr_contents
= (u32
*) keepass
->contents
;
8713 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8714 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8726 char ptr_contents_len
[10] = { 0 };
8728 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8730 sprintf (ptr_data
, "%d", contents_len
);
8732 ptr_data
+= strlen(ptr_contents_len
);
8737 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8738 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8740 else if (version
== 2)
8742 expected_bytes_len
= 8;
8743 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8745 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8746 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8751 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8752 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8766 sprintf (ptr_data
, "%d", keyfile_len
);
8773 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8774 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8777 else if (hash_mode
== 13500)
8779 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8781 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8783 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8785 char pstoken_tmp
[1024 + 1] = { 0 };
8787 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8789 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8791 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8794 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8802 else if (hash_mode
== 13600)
8804 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8806 zip2_t
*zip2
= &zip2s
[salt_pos
];
8808 const u32 salt_len
= zip2
->salt_len
;
8810 char salt_tmp
[32 + 1] = { 0 };
8812 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8814 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8816 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8819 const u32 data_len
= zip2
->data_len
;
8821 char data_tmp
[8192 + 1] = { 0 };
8823 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8825 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8827 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8830 const u32 auth_len
= zip2
->auth_len
;
8832 char auth_tmp
[20 + 1] = { 0 };
8834 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8836 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8838 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8841 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8842 SIGNATURE_ZIP2_START
,
8848 zip2
->compress_length
,
8851 SIGNATURE_ZIP2_STOP
);
8853 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8855 snprintf (out_buf
, len
-1, "%s", hashfile
);
8857 else if (hash_mode
== 13800)
8859 win8phone_t
*esalts
= (win8phone_t
*) data
.esalts_buf
;
8861 win8phone_t
*esalt
= &esalts
[salt_pos
];
8863 char buf
[256 + 1] = { 0 };
8865 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
8867 sprintf (buf
+ j
, "%08x", esalt
->salt_buf
[i
]);
8870 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%s",
8883 if (hash_type
== HASH_TYPE_MD4
)
8885 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8891 else if (hash_type
== HASH_TYPE_MD5
)
8893 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8899 else if (hash_type
== HASH_TYPE_SHA1
)
8901 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8908 else if (hash_type
== HASH_TYPE_SHA256
)
8910 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8920 else if (hash_type
== HASH_TYPE_SHA384
)
8922 uint
*ptr
= digest_buf
;
8924 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8932 else if (hash_type
== HASH_TYPE_SHA512
)
8934 uint
*ptr
= digest_buf
;
8936 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8946 else if (hash_type
== HASH_TYPE_LM
)
8948 snprintf (out_buf
, len
-1, "%08x%08x",
8952 else if (hash_type
== HASH_TYPE_ORACLEH
)
8954 snprintf (out_buf
, len
-1, "%08X%08X",
8958 else if (hash_type
== HASH_TYPE_BCRYPT
)
8960 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8961 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8963 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8965 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8967 else if (hash_type
== HASH_TYPE_KECCAK
)
8969 uint
*ptr
= digest_buf
;
8971 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",
8999 out_buf
[salt
.keccak_mdlen
* 2] = 0;
9001 else if (hash_type
== HASH_TYPE_RIPEMD160
)
9003 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
9010 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
9012 digest_buf
[ 0] = digest_buf
[ 0];
9013 digest_buf
[ 1] = digest_buf
[ 1];
9014 digest_buf
[ 2] = digest_buf
[ 2];
9015 digest_buf
[ 3] = digest_buf
[ 3];
9016 digest_buf
[ 4] = digest_buf
[ 4];
9017 digest_buf
[ 5] = digest_buf
[ 5];
9018 digest_buf
[ 6] = digest_buf
[ 6];
9019 digest_buf
[ 7] = digest_buf
[ 7];
9020 digest_buf
[ 8] = digest_buf
[ 8];
9021 digest_buf
[ 9] = digest_buf
[ 9];
9022 digest_buf
[10] = digest_buf
[10];
9023 digest_buf
[11] = digest_buf
[11];
9024 digest_buf
[12] = digest_buf
[12];
9025 digest_buf
[13] = digest_buf
[13];
9026 digest_buf
[14] = digest_buf
[14];
9027 digest_buf
[15] = digest_buf
[15];
9029 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
9047 else if (hash_type
== HASH_TYPE_GOST
)
9049 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
9059 else if (hash_type
== HASH_TYPE_MYSQL
)
9061 snprintf (out_buf
, len
-1, "%08x%08x",
9065 else if (hash_type
== HASH_TYPE_LOTUS5
)
9067 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
9073 else if (hash_type
== HASH_TYPE_LOTUS6
)
9075 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
9076 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
9077 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
9078 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
9080 char buf
[16] = { 0 };
9082 memcpy (buf
+ 0, salt
.salt_buf
, 5);
9083 memcpy (buf
+ 5, digest_buf
, 9);
9087 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
9089 tmp_buf
[18] = salt
.salt_buf_pc
[7];
9092 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
9094 else if (hash_type
== HASH_TYPE_LOTUS8
)
9096 char buf
[52] = { 0 };
9100 memcpy (buf
+ 0, salt
.salt_buf
, 16);
9106 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
9110 buf
[26] = salt
.salt_buf_pc
[0];
9111 buf
[27] = salt
.salt_buf_pc
[1];
9115 memcpy (buf
+ 28, digest_buf
, 8);
9117 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9121 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9123 else if (hash_type
== HASH_TYPE_CRC32
)
9125 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9129 if (salt_type
== SALT_TYPE_INTERN
)
9131 size_t pos
= strlen (out_buf
);
9133 out_buf
[pos
] = data
.separator
;
9135 char *ptr
= (char *) salt
.salt_buf
;
9137 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9139 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9143 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9145 memset (hccap
, 0, sizeof (hccap_t
));
9147 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9149 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9151 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9152 wpa_t
*wpa
= &wpas
[salt_pos
];
9154 hccap
->keyver
= wpa
->keyver
;
9156 hccap
->eapol_size
= wpa
->eapol_size
;
9158 if (wpa
->keyver
!= 1)
9160 uint eapol_tmp
[64] = { 0 };
9162 for (uint i
= 0; i
< 64; i
++)
9164 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9167 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9171 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9174 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9175 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9176 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9177 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9179 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9181 uint dgst_size
= data
.dgst_size
;
9183 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9185 if (wpa
->keyver
!= 1)
9187 uint digest_tmp
[4] = { 0 };
9189 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9190 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9191 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9192 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9194 memcpy (hccap
->keymic
, digest_tmp
, 16);
9198 memcpy (hccap
->keymic
, digest_ptr
, 16);
9202 void SuspendThreads ()
9204 if (data
.devices_status
!= STATUS_RUNNING
) return;
9206 hc_timer_set (&data
.timer_paused
);
9208 data
.devices_status
= STATUS_PAUSED
;
9210 log_info ("Paused");
9213 void ResumeThreads ()
9215 if (data
.devices_status
!= STATUS_PAUSED
) return;
9219 hc_timer_get (data
.timer_paused
, ms_paused
);
9221 data
.ms_paused
+= ms_paused
;
9223 data
.devices_status
= STATUS_RUNNING
;
9225 log_info ("Resumed");
9230 data
.devices_status
= STATUS_BYPASS
;
9232 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9235 void stop_at_checkpoint ()
9237 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9239 if (data
.devices_status
!= STATUS_RUNNING
) return;
9242 // this feature only makes sense if --restore-disable was not specified
9244 if (data
.restore_disable
== 1)
9246 log_info ("WARNING: This feature is disabled when --restore-disable is specified");
9251 // check if monitoring of Restore Point updates should be enabled or disabled
9253 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9255 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9257 // save the current restore point value
9259 data
.checkpoint_cur_words
= get_lowest_words_done ();
9261 log_info ("Checkpoint enabled: Will quit at next Restore Point update");
9265 data
.devices_status
= STATUS_RUNNING
;
9267 // reset the global value for checkpoint checks
9269 data
.checkpoint_cur_words
= 0;
9271 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9277 data
.devices_status
= STATUS_ABORTED
;
9282 data
.devices_status
= STATUS_QUIT
;
9285 void naive_replace (char *s
, const u8 key_char
, const u8 replace_char
)
9287 const size_t len
= strlen (s
);
9289 for (size_t in
= 0; in
< len
; in
++)
9295 s
[in
] = replace_char
;
9300 void naive_escape (char *s
, size_t s_max
, const u8 key_char
, const u8 escape_char
)
9302 char s_escaped
[1024] = { 0 };
9304 size_t s_escaped_max
= sizeof (s_escaped
);
9306 const size_t len
= strlen (s
);
9308 for (size_t in
= 0, out
= 0; in
< len
; in
++, out
++)
9314 s_escaped
[out
] = escape_char
;
9319 if (out
== s_escaped_max
- 2) break;
9324 strncpy (s
, s_escaped
, s_max
- 1);
9327 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9329 FILE *fp
= fopen (kernel_file
, "rb");
9335 memset (&st
, 0, sizeof (st
));
9337 stat (kernel_file
, &st
);
9339 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9341 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9343 if (num_read
!= (size_t) st
.st_size
)
9345 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9352 buf
[st
.st_size
] = 0;
9354 for (int i
= 0; i
< num_devices
; i
++)
9356 kernel_lengths
[i
] = (size_t) st
.st_size
;
9358 kernel_sources
[i
] = buf
;
9363 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9371 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9373 if (binary_size
> 0)
9375 FILE *fp
= fopen (dst
, "wb");
9378 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9389 restore_data_t
*init_restore (int argc
, char **argv
)
9391 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9393 if (data
.restore_disable
== 0)
9395 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9399 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9403 log_error ("ERROR: Cannot read %s", data
.eff_restore_file
);
9412 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9414 int pidbin_len
= -1;
9417 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9419 FILE *fd
= fopen (pidbin
, "rb");
9423 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9425 pidbin
[pidbin_len
] = 0;
9429 char *argv0_r
= strrchr (argv
[0], '/');
9431 char *pidbin_r
= strrchr (pidbin
, '/');
9433 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9435 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9437 if (strcmp (argv0_r
, pidbin_r
) == 0)
9439 log_error ("ERROR: Already an instance %s running on pid %d", pidbin
, rd
->pid
);
9446 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9448 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9450 int pidbin2_len
= -1;
9452 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9453 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9455 pidbin
[pidbin_len
] = 0;
9456 pidbin2
[pidbin2_len
] = 0;
9460 if (strcmp (pidbin
, pidbin2
) == 0)
9462 log_error ("ERROR: Already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9475 if (rd
->version_bin
< RESTORE_MIN
)
9477 log_error ("ERROR: Cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9484 memset (rd
, 0, sizeof (restore_data_t
));
9486 rd
->version_bin
= VERSION_BIN
;
9489 rd
->pid
= getpid ();
9491 rd
->pid
= GetCurrentProcessId ();
9494 if (getcwd (rd
->cwd
, 255) == NULL
)
9507 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9509 FILE *fp
= fopen (eff_restore_file
, "rb");
9513 log_error ("ERROR: Restore file '%s': %s", eff_restore_file
, strerror (errno
));
9518 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9520 log_error ("ERROR: Can't read %s", eff_restore_file
);
9525 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9527 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9529 for (uint i
= 0; i
< rd
->argc
; i
++)
9531 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9533 log_error ("ERROR: Can't read %s", eff_restore_file
);
9538 size_t len
= strlen (buf
);
9540 if (len
) buf
[len
- 1] = 0;
9542 rd
->argv
[i
] = mystrdup (buf
);
9549 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9551 if (chdir (rd
->cwd
))
9553 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9554 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9555 " https://github.com/philsmd/analyze_hc_restore\n"
9556 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9562 u64
get_lowest_words_done ()
9566 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9568 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9570 if (device_param
->skipped
) continue;
9572 const u64 words_done
= device_param
->words_done
;
9574 if (words_done
< words_cur
) words_cur
= words_done
;
9577 // It's possible that a device's workload isn't finished right after a restore-case.
9578 // In that case, this function would return 0 and overwrite the real restore point
9579 // There's also data.words_cur which is set to rd->words_cur but it changes while
9580 // the attack is running therefore we should stick to rd->words_cur.
9581 // Note that -s influences rd->words_cur we should keep a close look on that.
9583 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9588 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9590 u64 words_cur
= get_lowest_words_done ();
9592 rd
->words_cur
= words_cur
;
9594 FILE *fp
= fopen (new_restore_file
, "wb");
9598 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9603 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9605 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9610 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9612 for (uint i
= 0; i
< rd
->argc
; i
++)
9614 fprintf (fp
, "%s", rd
->argv
[i
]);
9620 fsync (fileno (fp
));
9625 void cycle_restore ()
9627 const char *eff_restore_file
= data
.eff_restore_file
;
9628 const char *new_restore_file
= data
.new_restore_file
;
9630 restore_data_t
*rd
= data
.rd
;
9632 write_restore (new_restore_file
, rd
);
9636 memset (&st
, 0, sizeof(st
));
9638 if (stat (eff_restore_file
, &st
) == 0)
9640 if (unlink (eff_restore_file
))
9642 log_info ("WARN: Unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9646 if (rename (new_restore_file
, eff_restore_file
))
9648 log_info ("WARN: Rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9652 void check_checkpoint ()
9654 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9656 u64 words_cur
= get_lowest_words_done ();
9658 if (words_cur
!= data
.checkpoint_cur_words
)
9668 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9672 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9674 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9676 myfree (alias
->device_name
);
9677 myfree (alias
->alias_name
);
9680 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9682 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9684 myfree (entry
->device_name
);
9687 myfree (tuning_db
->alias_buf
);
9688 myfree (tuning_db
->entry_buf
);
9693 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9695 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9697 int num_lines
= count_lines (fp
);
9699 // a bit over-allocated
9701 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9702 tuning_db
->alias_cnt
= 0;
9704 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9705 tuning_db
->entry_cnt
= 0;
9710 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9712 FILE *fp
= fopen (tuning_db_file
, "rb");
9716 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9721 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9727 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9731 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9733 if (line_buf
== NULL
) break;
9737 const int line_len
= in_superchop (line_buf
);
9739 if (line_len
== 0) continue;
9741 if (line_buf
[0] == '#') continue;
9745 char *token_ptr
[7] = { NULL
};
9749 char *next
= strtok (line_buf
, "\t ");
9751 token_ptr
[token_cnt
] = next
;
9755 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9757 token_ptr
[token_cnt
] = next
;
9764 char *device_name
= token_ptr
[0];
9765 char *alias_name
= token_ptr
[1];
9767 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9769 alias
->device_name
= mystrdup (device_name
);
9770 alias
->alias_name
= mystrdup (alias_name
);
9772 tuning_db
->alias_cnt
++;
9774 else if (token_cnt
== 6)
9776 if ((token_ptr
[1][0] != '0') &&
9777 (token_ptr
[1][0] != '1') &&
9778 (token_ptr
[1][0] != '3') &&
9779 (token_ptr
[1][0] != '*'))
9781 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9786 if ((token_ptr
[3][0] != '1') &&
9787 (token_ptr
[3][0] != '2') &&
9788 (token_ptr
[3][0] != '4') &&
9789 (token_ptr
[3][0] != '8') &&
9790 (token_ptr
[3][0] != 'N'))
9792 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9797 char *device_name
= token_ptr
[0];
9799 int attack_mode
= -1;
9801 int vector_width
= -1;
9802 int kernel_accel
= -1;
9803 int kernel_loops
= -1;
9805 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9806 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9807 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9809 if (token_ptr
[4][0] != 'A')
9811 kernel_accel
= atoi (token_ptr
[4]);
9813 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9815 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9825 if (token_ptr
[5][0] != 'A')
9827 kernel_loops
= atoi (token_ptr
[5]);
9829 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9831 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9841 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9843 entry
->device_name
= mystrdup (device_name
);
9844 entry
->attack_mode
= attack_mode
;
9845 entry
->hash_type
= hash_type
;
9846 entry
->vector_width
= vector_width
;
9847 entry
->kernel_accel
= kernel_accel
;
9848 entry
->kernel_loops
= kernel_loops
;
9850 tuning_db
->entry_cnt
++;
9854 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9864 // todo: print loaded 'cnt' message
9866 // sort the database
9868 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9869 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9874 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9876 static tuning_db_entry_t s
;
9878 // first we need to convert all spaces in the device_name to underscore
9880 char *device_name_nospace
= strdup (device_param
->device_name
);
9882 int device_name_length
= strlen (device_name_nospace
);
9886 for (i
= 0; i
< device_name_length
; i
++)
9888 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9891 // find out if there's an alias configured
9893 tuning_db_alias_t a
;
9895 a
.device_name
= device_name_nospace
;
9897 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
);
9899 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9901 // attack-mode 6 and 7 are attack-mode 1 basically
9903 if (attack_mode
== 6) attack_mode
= 1;
9904 if (attack_mode
== 7) attack_mode
= 1;
9906 // bsearch is not ideal but fast enough
9908 s
.device_name
= device_name_nospace
;
9909 s
.attack_mode
= attack_mode
;
9910 s
.hash_type
= hash_type
;
9912 tuning_db_entry_t
*entry
= NULL
;
9914 // this will produce all 2^3 combinations required
9916 for (i
= 0; i
< 8; i
++)
9918 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9919 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9920 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9922 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9924 if (entry
!= NULL
) break;
9926 // in non-wildcard mode do some additional checks:
9930 // in case we have an alias-name
9932 if (alias_name
!= NULL
)
9934 s
.device_name
= alias_name
;
9936 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9938 if (entry
!= NULL
) break;
9941 // or by device type
9943 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9945 s
.device_name
= "DEVICE_TYPE_CPU";
9947 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9949 s
.device_name
= "DEVICE_TYPE_GPU";
9951 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9953 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9956 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9958 if (entry
!= NULL
) break;
9962 // free converted device_name
9964 myfree (device_name_nospace
);
9973 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9975 u8 tmp
[256] = { 0 };
9977 if (salt_len
> sizeof (tmp
))
9982 memcpy (tmp
, in
, salt_len
);
9984 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9986 if ((salt_len
% 2) == 0)
9988 u32 new_salt_len
= salt_len
/ 2;
9990 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9995 tmp
[i
] = hex_convert (p1
) << 0;
9996 tmp
[i
] |= hex_convert (p0
) << 4;
9999 salt_len
= new_salt_len
;
10006 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
10008 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
10011 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
10013 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
10017 u32
*tmp_uint
= (u32
*) tmp
;
10019 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
10020 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
10021 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
10022 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
10023 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
10024 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
10025 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
10026 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
10027 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
10028 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
10030 salt_len
= salt_len
* 2;
10038 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
10040 lowercase (tmp
, salt_len
);
10043 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
10045 uppercase (tmp
, salt_len
);
10048 u32 len
= salt_len
;
10050 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
10055 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
10060 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
10062 u32
*tmp_uint
= (uint
*) tmp
;
10066 if (len
% 4) max
++;
10068 for (u32 i
= 0; i
< max
; i
++)
10070 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
10073 // Important: we may need to increase the length of memcpy since
10074 // we don't want to "loose" some swapped bytes (could happen if
10075 // they do not perfectly fit in the 4-byte blocks)
10076 // Memcpy does always copy the bytes in the BE order, but since
10077 // we swapped them, some important bytes could be in positions
10078 // we normally skip with the original len
10080 if (len
% 4) len
+= 4 - (len
% 4);
10083 memcpy (out
, tmp
, len
);
10088 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10090 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
10092 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
10094 u32
*digest
= (u32
*) hash_buf
->digest
;
10096 salt_t
*salt
= hash_buf
->salt
;
10098 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
10100 char *iter_pos
= input_buf
+ 4;
10102 salt
->salt_iter
= 1 << atoi (iter_pos
);
10104 char *salt_pos
= strchr (iter_pos
, '$');
10106 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10110 uint salt_len
= 16;
10112 salt
->salt_len
= salt_len
;
10114 u8 tmp_buf
[100] = { 0 };
10116 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
10118 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10120 memcpy (salt_buf_ptr
, tmp_buf
, 16);
10122 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
10123 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
10124 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
10125 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
10127 char *hash_pos
= salt_pos
+ 22;
10129 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10131 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
10133 memcpy (digest
, tmp_buf
, 24);
10135 digest
[0] = byte_swap_32 (digest
[0]);
10136 digest
[1] = byte_swap_32 (digest
[1]);
10137 digest
[2] = byte_swap_32 (digest
[2]);
10138 digest
[3] = byte_swap_32 (digest
[3]);
10139 digest
[4] = byte_swap_32 (digest
[4]);
10140 digest
[5] = byte_swap_32 (digest
[5]);
10142 digest
[5] &= ~0xff; // its just 23 not 24 !
10144 return (PARSER_OK
);
10147 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10149 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10151 u32
*digest
= (u32
*) hash_buf
->digest
;
10153 u8 tmp_buf
[100] = { 0 };
10155 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10157 memcpy (digest
, tmp_buf
, 32);
10159 digest
[0] = byte_swap_32 (digest
[0]);
10160 digest
[1] = byte_swap_32 (digest
[1]);
10161 digest
[2] = byte_swap_32 (digest
[2]);
10162 digest
[3] = byte_swap_32 (digest
[3]);
10163 digest
[4] = byte_swap_32 (digest
[4]);
10164 digest
[5] = byte_swap_32 (digest
[5]);
10165 digest
[6] = byte_swap_32 (digest
[6]);
10166 digest
[7] = byte_swap_32 (digest
[7]);
10168 digest
[0] -= SHA256M_A
;
10169 digest
[1] -= SHA256M_B
;
10170 digest
[2] -= SHA256M_C
;
10171 digest
[3] -= SHA256M_D
;
10172 digest
[4] -= SHA256M_E
;
10173 digest
[5] -= SHA256M_F
;
10174 digest
[6] -= SHA256M_G
;
10175 digest
[7] -= SHA256M_H
;
10177 return (PARSER_OK
);
10180 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10182 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10184 u32
*digest
= (u32
*) hash_buf
->digest
;
10186 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10187 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10189 digest
[0] = byte_swap_32 (digest
[0]);
10190 digest
[1] = byte_swap_32 (digest
[1]);
10194 IP (digest
[0], digest
[1], tt
);
10196 digest
[0] = digest
[0];
10197 digest
[1] = digest
[1];
10201 return (PARSER_OK
);
10204 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10206 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10208 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10210 u32
*digest
= (u32
*) hash_buf
->digest
;
10212 salt_t
*salt
= hash_buf
->salt
;
10214 char *hash_pos
= input_buf
+ 10;
10216 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10217 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10218 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10219 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10220 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10222 digest
[0] -= SHA1M_A
;
10223 digest
[1] -= SHA1M_B
;
10224 digest
[2] -= SHA1M_C
;
10225 digest
[3] -= SHA1M_D
;
10226 digest
[4] -= SHA1M_E
;
10228 uint salt_len
= 10;
10230 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10232 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10234 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10236 salt
->salt_len
= salt_len
;
10238 return (PARSER_OK
);
10241 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10243 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10245 u32
*digest
= (u32
*) hash_buf
->digest
;
10247 salt_t
*salt
= hash_buf
->salt
;
10249 char *hash_pos
= input_buf
+ 8;
10251 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10252 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10253 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10254 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10255 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10257 digest
[0] -= SHA1M_A
;
10258 digest
[1] -= SHA1M_B
;
10259 digest
[2] -= SHA1M_C
;
10260 digest
[3] -= SHA1M_D
;
10261 digest
[4] -= SHA1M_E
;
10265 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10267 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10269 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10271 salt
->salt_len
= salt_len
;
10273 return (PARSER_OK
);
10276 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10278 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10280 u64
*digest
= (u64
*) hash_buf
->digest
;
10282 salt_t
*salt
= hash_buf
->salt
;
10284 char *hash_pos
= input_buf
+ 8;
10286 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10287 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10288 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10289 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10290 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10291 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10292 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10293 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10295 digest
[0] -= SHA512M_A
;
10296 digest
[1] -= SHA512M_B
;
10297 digest
[2] -= SHA512M_C
;
10298 digest
[3] -= SHA512M_D
;
10299 digest
[4] -= SHA512M_E
;
10300 digest
[5] -= SHA512M_F
;
10301 digest
[6] -= SHA512M_G
;
10302 digest
[7] -= SHA512M_H
;
10306 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10308 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10310 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10312 salt
->salt_len
= salt_len
;
10314 return (PARSER_OK
);
10317 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10319 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10321 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10325 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10328 u32
*digest
= (u32
*) hash_buf
->digest
;
10330 salt_t
*salt
= hash_buf
->salt
;
10332 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10333 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10334 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10335 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10337 digest
[0] = byte_swap_32 (digest
[0]);
10338 digest
[1] = byte_swap_32 (digest
[1]);
10339 digest
[2] = byte_swap_32 (digest
[2]);
10340 digest
[3] = byte_swap_32 (digest
[3]);
10342 digest
[0] -= MD5M_A
;
10343 digest
[1] -= MD5M_B
;
10344 digest
[2] -= MD5M_C
;
10345 digest
[3] -= MD5M_D
;
10347 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10349 uint salt_len
= input_len
- 32 - 1;
10351 char *salt_buf
= input_buf
+ 32 + 1;
10353 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10355 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10357 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10359 salt
->salt_len
= salt_len
;
10361 return (PARSER_OK
);
10364 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10366 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10368 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10372 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10377 char clean_input_buf
[32] = { 0 };
10379 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10380 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10382 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10386 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10392 clean_input_buf
[k
] = input_buf
[i
];
10400 u32
*digest
= (u32
*) hash_buf
->digest
;
10402 salt_t
*salt
= hash_buf
->salt
;
10404 u32 a
, b
, c
, d
, e
, f
;
10406 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10407 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10408 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10409 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10410 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10411 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10413 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10414 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10416 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10417 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10418 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10419 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10420 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10421 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10423 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10424 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10426 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10427 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10428 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10429 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10430 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10431 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10433 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10434 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10436 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10437 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10438 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10439 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10440 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10441 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10443 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10444 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10446 digest
[0] = byte_swap_32 (digest
[0]);
10447 digest
[1] = byte_swap_32 (digest
[1]);
10448 digest
[2] = byte_swap_32 (digest
[2]);
10449 digest
[3] = byte_swap_32 (digest
[3]);
10451 digest
[0] -= MD5M_A
;
10452 digest
[1] -= MD5M_B
;
10453 digest
[2] -= MD5M_C
;
10454 digest
[3] -= MD5M_D
;
10456 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10458 uint salt_len
= input_len
- 30 - 1;
10460 char *salt_buf
= input_buf
+ 30 + 1;
10462 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10464 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10466 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10467 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10469 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10471 salt
->salt_len
= salt_len
;
10473 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10475 salt
->salt_len
+= 22;
10477 return (PARSER_OK
);
10480 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10482 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10484 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10488 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10491 u32
*digest
= (u32
*) hash_buf
->digest
;
10493 salt_t
*salt
= hash_buf
->salt
;
10495 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10496 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10497 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10498 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10499 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10501 digest
[0] -= SHA1M_A
;
10502 digest
[1] -= SHA1M_B
;
10503 digest
[2] -= SHA1M_C
;
10504 digest
[3] -= SHA1M_D
;
10505 digest
[4] -= SHA1M_E
;
10507 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10509 uint salt_len
= input_len
- 40 - 1;
10511 char *salt_buf
= input_buf
+ 40 + 1;
10513 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10515 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10517 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10519 salt
->salt_len
= salt_len
;
10521 return (PARSER_OK
);
10524 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10526 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10528 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10532 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10535 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10537 char *iter_pos
= input_buf
+ 6;
10539 salt_t
*salt
= hash_buf
->salt
;
10541 uint iter
= atoi (iter_pos
);
10545 iter
= ROUNDS_DCC2
;
10548 salt
->salt_iter
= iter
- 1;
10550 char *salt_pos
= strchr (iter_pos
, '#');
10552 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10556 char *digest_pos
= strchr (salt_pos
, '#');
10558 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10562 uint salt_len
= digest_pos
- salt_pos
- 1;
10564 u32
*digest
= (u32
*) hash_buf
->digest
;
10566 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10567 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10568 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10569 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10571 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10573 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10575 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10577 salt
->salt_len
= salt_len
;
10579 return (PARSER_OK
);
10582 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10584 u32
*digest
= (u32
*) hash_buf
->digest
;
10586 salt_t
*salt
= hash_buf
->salt
;
10588 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10592 memcpy (&in
, input_buf
, input_len
);
10594 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10596 memcpy (digest
, in
.keymic
, 16);
10599 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10600 The phrase "Pairwise key expansion"
10601 Access Point Address (referred to as Authenticator Address AA)
10602 Supplicant Address (referred to as Supplicant Address SA)
10603 Access Point Nonce (referred to as Authenticator Anonce)
10604 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10607 uint salt_len
= strlen (in
.essid
);
10611 log_info ("WARNING: The ESSID length is too long, the hccap file may be invalid or corrupted");
10613 return (PARSER_SALT_LENGTH
);
10616 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10618 salt
->salt_len
= salt_len
;
10620 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10622 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10624 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10626 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10628 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10629 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10633 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10634 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10637 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10639 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10640 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10644 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10645 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10648 for (int i
= 0; i
< 25; i
++)
10650 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10653 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10654 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10655 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10656 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10658 wpa
->keyver
= in
.keyver
;
10660 if (wpa
->keyver
> 255)
10662 log_info ("ATTENTION!");
10663 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10664 log_info (" This could be due to a recent aircrack-ng bug.");
10665 log_info (" The key version was automatically reset to a reasonable value.");
10668 wpa
->keyver
&= 0xff;
10671 wpa
->eapol_size
= in
.eapol_size
;
10673 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10675 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10677 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10679 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10681 if (wpa
->keyver
== 1)
10687 digest
[0] = byte_swap_32 (digest
[0]);
10688 digest
[1] = byte_swap_32 (digest
[1]);
10689 digest
[2] = byte_swap_32 (digest
[2]);
10690 digest
[3] = byte_swap_32 (digest
[3]);
10692 for (int i
= 0; i
< 64; i
++)
10694 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10698 uint32_t *p0
= (uint32_t *) in
.essid
;
10702 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10703 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10705 salt
->salt_buf
[10] = c0
;
10706 salt
->salt_buf
[11] = c1
;
10708 return (PARSER_OK
);
10711 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10713 u32
*digest
= (u32
*) hash_buf
->digest
;
10715 salt_t
*salt
= hash_buf
->salt
;
10717 if (input_len
== 0)
10719 log_error ("Password Safe v2 container not specified");
10724 FILE *fp
= fopen (input_buf
, "rb");
10728 log_error ("%s: %s", input_buf
, strerror (errno
));
10735 memset (&buf
, 0, sizeof (psafe2_hdr
));
10737 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10741 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10743 salt
->salt_buf
[0] = buf
.random
[0];
10744 salt
->salt_buf
[1] = buf
.random
[1];
10746 salt
->salt_len
= 8;
10747 salt
->salt_iter
= 1000;
10749 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10750 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10751 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10752 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10753 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10755 return (PARSER_OK
);
10758 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10760 u32
*digest
= (u32
*) hash_buf
->digest
;
10762 salt_t
*salt
= hash_buf
->salt
;
10764 if (input_len
== 0)
10766 log_error (".psafe3 not specified");
10771 FILE *fp
= fopen (input_buf
, "rb");
10775 log_error ("%s: %s", input_buf
, strerror (errno
));
10782 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10786 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10788 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10790 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10792 salt
->salt_iter
= in
.iterations
+ 1;
10794 salt
->salt_buf
[0] = in
.salt_buf
[0];
10795 salt
->salt_buf
[1] = in
.salt_buf
[1];
10796 salt
->salt_buf
[2] = in
.salt_buf
[2];
10797 salt
->salt_buf
[3] = in
.salt_buf
[3];
10798 salt
->salt_buf
[4] = in
.salt_buf
[4];
10799 salt
->salt_buf
[5] = in
.salt_buf
[5];
10800 salt
->salt_buf
[6] = in
.salt_buf
[6];
10801 salt
->salt_buf
[7] = in
.salt_buf
[7];
10803 salt
->salt_len
= 32;
10805 digest
[0] = in
.hash_buf
[0];
10806 digest
[1] = in
.hash_buf
[1];
10807 digest
[2] = in
.hash_buf
[2];
10808 digest
[3] = in
.hash_buf
[3];
10809 digest
[4] = in
.hash_buf
[4];
10810 digest
[5] = in
.hash_buf
[5];
10811 digest
[6] = in
.hash_buf
[6];
10812 digest
[7] = in
.hash_buf
[7];
10814 digest
[0] = byte_swap_32 (digest
[0]);
10815 digest
[1] = byte_swap_32 (digest
[1]);
10816 digest
[2] = byte_swap_32 (digest
[2]);
10817 digest
[3] = byte_swap_32 (digest
[3]);
10818 digest
[4] = byte_swap_32 (digest
[4]);
10819 digest
[5] = byte_swap_32 (digest
[5]);
10820 digest
[6] = byte_swap_32 (digest
[6]);
10821 digest
[7] = byte_swap_32 (digest
[7]);
10823 return (PARSER_OK
);
10826 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10828 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10830 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10832 u32
*digest
= (u32
*) hash_buf
->digest
;
10834 salt_t
*salt
= hash_buf
->salt
;
10836 char *iter_pos
= input_buf
+ 3;
10838 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10840 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10842 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10844 salt
->salt_iter
= salt_iter
;
10846 char *salt_pos
= iter_pos
+ 1;
10850 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10852 salt
->salt_len
= salt_len
;
10854 char *hash_pos
= salt_pos
+ salt_len
;
10856 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10858 return (PARSER_OK
);
10861 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10863 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10865 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10867 u32
*digest
= (u32
*) hash_buf
->digest
;
10869 salt_t
*salt
= hash_buf
->salt
;
10871 char *salt_pos
= input_buf
+ 3;
10873 uint iterations_len
= 0;
10875 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10879 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10881 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10882 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10886 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10890 iterations_len
+= 8;
10894 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10897 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10899 char *hash_pos
= strchr (salt_pos
, '$');
10901 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10903 uint salt_len
= hash_pos
- salt_pos
;
10905 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10907 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10909 salt
->salt_len
= salt_len
;
10913 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10915 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10917 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10919 return (PARSER_OK
);
10922 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10924 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10926 u32
*digest
= (u32
*) hash_buf
->digest
;
10928 salt_t
*salt
= hash_buf
->salt
;
10930 char *salt_pos
= input_buf
+ 6;
10932 uint iterations_len
= 0;
10934 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10938 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10940 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10941 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10945 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10949 iterations_len
+= 8;
10953 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10956 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10958 char *hash_pos
= strchr (salt_pos
, '$');
10960 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10962 uint salt_len
= hash_pos
- salt_pos
;
10964 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10966 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10968 salt
->salt_len
= salt_len
;
10972 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10974 return (PARSER_OK
);
10977 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10979 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10981 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10983 u32
*digest
= (u32
*) hash_buf
->digest
;
10985 salt_t
*salt
= hash_buf
->salt
;
10987 char *salt_pos
= input_buf
+ 14;
10989 char *hash_pos
= strchr (salt_pos
, '*');
10991 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10995 uint salt_len
= hash_pos
- salt_pos
- 1;
10997 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10999 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
11001 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11003 salt
->salt_len
= salt_len
;
11005 u8 tmp_buf
[100] = { 0 };
11007 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
11009 memcpy (digest
, tmp_buf
, 20);
11011 digest
[0] = byte_swap_32 (digest
[0]);
11012 digest
[1] = byte_swap_32 (digest
[1]);
11013 digest
[2] = byte_swap_32 (digest
[2]);
11014 digest
[3] = byte_swap_32 (digest
[3]);
11015 digest
[4] = byte_swap_32 (digest
[4]);
11017 digest
[0] -= SHA1M_A
;
11018 digest
[1] -= SHA1M_B
;
11019 digest
[2] -= SHA1M_C
;
11020 digest
[3] -= SHA1M_D
;
11021 digest
[4] -= SHA1M_E
;
11023 return (PARSER_OK
);
11026 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11028 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
11030 unsigned char c12
= itoa64_to_int (input_buf
[12]);
11032 if (c12
& 3) return (PARSER_HASH_VALUE
);
11034 u32
*digest
= (u32
*) hash_buf
->digest
;
11036 salt_t
*salt
= hash_buf
->salt
;
11038 // for ascii_digest
11039 salt
->salt_sign
[0] = input_buf
[0];
11040 salt
->salt_sign
[1] = input_buf
[1];
11042 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
11043 | itoa64_to_int (input_buf
[1]) << 6;
11045 salt
->salt_len
= 2;
11047 u8 tmp_buf
[100] = { 0 };
11049 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
11051 memcpy (digest
, tmp_buf
, 8);
11055 IP (digest
[0], digest
[1], tt
);
11060 return (PARSER_OK
);
11063 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11065 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
11067 u32
*digest
= (u32
*) hash_buf
->digest
;
11069 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11070 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11071 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11072 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11074 digest
[0] = byte_swap_32 (digest
[0]);
11075 digest
[1] = byte_swap_32 (digest
[1]);
11076 digest
[2] = byte_swap_32 (digest
[2]);
11077 digest
[3] = byte_swap_32 (digest
[3]);
11079 digest
[0] -= MD4M_A
;
11080 digest
[1] -= MD4M_B
;
11081 digest
[2] -= MD4M_C
;
11082 digest
[3] -= MD4M_D
;
11084 return (PARSER_OK
);
11087 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11089 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11091 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
11095 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
11098 u32
*digest
= (u32
*) hash_buf
->digest
;
11100 salt_t
*salt
= hash_buf
->salt
;
11102 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11103 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11104 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11105 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11107 digest
[0] = byte_swap_32 (digest
[0]);
11108 digest
[1] = byte_swap_32 (digest
[1]);
11109 digest
[2] = byte_swap_32 (digest
[2]);
11110 digest
[3] = byte_swap_32 (digest
[3]);
11112 digest
[0] -= MD4M_A
;
11113 digest
[1] -= MD4M_B
;
11114 digest
[2] -= MD4M_C
;
11115 digest
[3] -= MD4M_D
;
11117 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11119 uint salt_len
= input_len
- 32 - 1;
11121 char *salt_buf
= input_buf
+ 32 + 1;
11123 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11125 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11127 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11129 salt
->salt_len
= salt_len
;
11131 return (PARSER_OK
);
11134 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11136 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
11138 u32
*digest
= (u32
*) hash_buf
->digest
;
11140 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11141 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11142 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11143 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11145 digest
[0] = byte_swap_32 (digest
[0]);
11146 digest
[1] = byte_swap_32 (digest
[1]);
11147 digest
[2] = byte_swap_32 (digest
[2]);
11148 digest
[3] = byte_swap_32 (digest
[3]);
11150 digest
[0] -= MD5M_A
;
11151 digest
[1] -= MD5M_B
;
11152 digest
[2] -= MD5M_C
;
11153 digest
[3] -= MD5M_D
;
11155 return (PARSER_OK
);
11158 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11160 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11162 u32
*digest
= (u32
*) hash_buf
->digest
;
11164 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11165 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11169 digest
[0] = byte_swap_32 (digest
[0]);
11170 digest
[1] = byte_swap_32 (digest
[1]);
11172 return (PARSER_OK
);
11175 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11177 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11179 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11183 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11186 u32
*digest
= (u32
*) hash_buf
->digest
;
11188 salt_t
*salt
= hash_buf
->salt
;
11190 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11191 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11192 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11193 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11195 digest
[0] = byte_swap_32 (digest
[0]);
11196 digest
[1] = byte_swap_32 (digest
[1]);
11197 digest
[2] = byte_swap_32 (digest
[2]);
11198 digest
[3] = byte_swap_32 (digest
[3]);
11200 digest
[0] -= MD5M_A
;
11201 digest
[1] -= MD5M_B
;
11202 digest
[2] -= MD5M_C
;
11203 digest
[3] -= MD5M_D
;
11205 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11207 uint salt_len
= input_len
- 32 - 1;
11209 char *salt_buf
= input_buf
+ 32 + 1;
11211 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11213 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11215 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11217 salt
->salt_len
= salt_len
;
11219 return (PARSER_OK
);
11222 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11224 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11226 u32
*digest
= (u32
*) hash_buf
->digest
;
11228 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11229 | itoa64_to_int (input_buf
[ 1]) << 6
11230 | itoa64_to_int (input_buf
[ 2]) << 12
11231 | itoa64_to_int (input_buf
[ 3]) << 18;
11232 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11233 | itoa64_to_int (input_buf
[ 5]) << 6
11234 | itoa64_to_int (input_buf
[ 6]) << 12
11235 | itoa64_to_int (input_buf
[ 7]) << 18;
11236 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11237 | itoa64_to_int (input_buf
[ 9]) << 6
11238 | itoa64_to_int (input_buf
[10]) << 12
11239 | itoa64_to_int (input_buf
[11]) << 18;
11240 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11241 | itoa64_to_int (input_buf
[13]) << 6
11242 | itoa64_to_int (input_buf
[14]) << 12
11243 | itoa64_to_int (input_buf
[15]) << 18;
11245 digest
[0] -= MD5M_A
;
11246 digest
[1] -= MD5M_B
;
11247 digest
[2] -= MD5M_C
;
11248 digest
[3] -= MD5M_D
;
11250 digest
[0] &= 0x00ffffff;
11251 digest
[1] &= 0x00ffffff;
11252 digest
[2] &= 0x00ffffff;
11253 digest
[3] &= 0x00ffffff;
11255 return (PARSER_OK
);
11258 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11260 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11262 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11266 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11269 u32
*digest
= (u32
*) hash_buf
->digest
;
11271 salt_t
*salt
= hash_buf
->salt
;
11273 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11274 | itoa64_to_int (input_buf
[ 1]) << 6
11275 | itoa64_to_int (input_buf
[ 2]) << 12
11276 | itoa64_to_int (input_buf
[ 3]) << 18;
11277 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11278 | itoa64_to_int (input_buf
[ 5]) << 6
11279 | itoa64_to_int (input_buf
[ 6]) << 12
11280 | itoa64_to_int (input_buf
[ 7]) << 18;
11281 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11282 | itoa64_to_int (input_buf
[ 9]) << 6
11283 | itoa64_to_int (input_buf
[10]) << 12
11284 | itoa64_to_int (input_buf
[11]) << 18;
11285 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11286 | itoa64_to_int (input_buf
[13]) << 6
11287 | itoa64_to_int (input_buf
[14]) << 12
11288 | itoa64_to_int (input_buf
[15]) << 18;
11290 digest
[0] -= MD5M_A
;
11291 digest
[1] -= MD5M_B
;
11292 digest
[2] -= MD5M_C
;
11293 digest
[3] -= MD5M_D
;
11295 digest
[0] &= 0x00ffffff;
11296 digest
[1] &= 0x00ffffff;
11297 digest
[2] &= 0x00ffffff;
11298 digest
[3] &= 0x00ffffff;
11300 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11302 uint salt_len
= input_len
- 16 - 1;
11304 char *salt_buf
= input_buf
+ 16 + 1;
11306 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11308 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11310 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11312 salt
->salt_len
= salt_len
;
11314 return (PARSER_OK
);
11317 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11319 key
[0] = (nthash
[0] >> 0);
11320 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11321 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11322 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11323 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11324 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11325 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11326 key
[7] = (nthash
[6] << 1);
11338 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11340 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11342 u32
*digest
= (u32
*) hash_buf
->digest
;
11344 salt_t
*salt
= hash_buf
->salt
;
11346 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11352 char *user_pos
= input_buf
;
11354 char *unused_pos
= strchr (user_pos
, ':');
11356 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11358 uint user_len
= unused_pos
- user_pos
;
11360 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11364 char *domain_pos
= strchr (unused_pos
, ':');
11366 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11368 uint unused_len
= domain_pos
- unused_pos
;
11370 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11374 char *srvchall_pos
= strchr (domain_pos
, ':');
11376 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11378 uint domain_len
= srvchall_pos
- domain_pos
;
11380 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11384 char *hash_pos
= strchr (srvchall_pos
, ':');
11386 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11388 uint srvchall_len
= hash_pos
- srvchall_pos
;
11390 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11394 char *clichall_pos
= strchr (hash_pos
, ':');
11396 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11398 uint hash_len
= clichall_pos
- hash_pos
;
11400 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11404 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11406 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11409 * store some data for later use
11412 netntlm
->user_len
= user_len
* 2;
11413 netntlm
->domain_len
= domain_len
* 2;
11414 netntlm
->srvchall_len
= srvchall_len
/ 2;
11415 netntlm
->clichall_len
= clichall_len
/ 2;
11417 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11418 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11421 * handle username and domainname
11424 for (uint i
= 0; i
< user_len
; i
++)
11426 *userdomain_ptr
++ = user_pos
[i
];
11427 *userdomain_ptr
++ = 0;
11430 for (uint i
= 0; i
< domain_len
; i
++)
11432 *userdomain_ptr
++ = domain_pos
[i
];
11433 *userdomain_ptr
++ = 0;
11437 * handle server challenge encoding
11440 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11442 const char p0
= srvchall_pos
[i
+ 0];
11443 const char p1
= srvchall_pos
[i
+ 1];
11445 *chall_ptr
++ = hex_convert (p1
) << 0
11446 | hex_convert (p0
) << 4;
11450 * handle client challenge encoding
11453 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11455 const char p0
= clichall_pos
[i
+ 0];
11456 const char p1
= clichall_pos
[i
+ 1];
11458 *chall_ptr
++ = hex_convert (p1
) << 0
11459 | hex_convert (p0
) << 4;
11466 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11468 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11470 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11472 salt
->salt_len
= salt_len
;
11474 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11475 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11476 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11477 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11479 digest
[0] = byte_swap_32 (digest
[0]);
11480 digest
[1] = byte_swap_32 (digest
[1]);
11481 digest
[2] = byte_swap_32 (digest
[2]);
11482 digest
[3] = byte_swap_32 (digest
[3]);
11484 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11486 uint digest_tmp
[2] = { 0 };
11488 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11489 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11491 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11492 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11494 /* special case 2: ESS */
11496 if (srvchall_len
== 48)
11498 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11500 uint w
[16] = { 0 };
11502 w
[ 0] = netntlm
->chall_buf
[6];
11503 w
[ 1] = netntlm
->chall_buf
[7];
11504 w
[ 2] = netntlm
->chall_buf
[0];
11505 w
[ 3] = netntlm
->chall_buf
[1];
11509 uint dgst
[4] = { 0 };
11518 salt
->salt_buf
[0] = dgst
[0];
11519 salt
->salt_buf
[1] = dgst
[1];
11523 /* precompute netntlmv1 exploit start */
11525 for (uint i
= 0; i
< 0x10000; i
++)
11527 uint key_md4
[2] = { i
, 0 };
11528 uint key_des
[2] = { 0, 0 };
11530 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11532 uint Kc
[16] = { 0 };
11533 uint Kd
[16] = { 0 };
11535 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11537 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11539 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11541 if (data3
[0] != digest_tmp
[0]) continue;
11542 if (data3
[1] != digest_tmp
[1]) continue;
11544 salt
->salt_buf
[2] = i
;
11546 salt
->salt_len
= 24;
11551 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11552 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11554 /* precompute netntlmv1 exploit stop */
11558 IP (digest
[0], digest
[1], tt
);
11559 IP (digest
[2], digest
[3], tt
);
11561 digest
[0] = rotr32 (digest
[0], 29);
11562 digest
[1] = rotr32 (digest
[1], 29);
11563 digest
[2] = rotr32 (digest
[2], 29);
11564 digest
[3] = rotr32 (digest
[3], 29);
11566 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11568 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11569 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11571 return (PARSER_OK
);
11574 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11576 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11578 u32
*digest
= (u32
*) hash_buf
->digest
;
11580 salt_t
*salt
= hash_buf
->salt
;
11582 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11588 char *user_pos
= input_buf
;
11590 char *unused_pos
= strchr (user_pos
, ':');
11592 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11594 uint user_len
= unused_pos
- user_pos
;
11596 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11600 char *domain_pos
= strchr (unused_pos
, ':');
11602 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11604 uint unused_len
= domain_pos
- unused_pos
;
11606 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11610 char *srvchall_pos
= strchr (domain_pos
, ':');
11612 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11614 uint domain_len
= srvchall_pos
- domain_pos
;
11616 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11620 char *hash_pos
= strchr (srvchall_pos
, ':');
11622 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11624 uint srvchall_len
= hash_pos
- srvchall_pos
;
11626 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11630 char *clichall_pos
= strchr (hash_pos
, ':');
11632 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11634 uint hash_len
= clichall_pos
- hash_pos
;
11636 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11640 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11642 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11644 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11647 * store some data for later use
11650 netntlm
->user_len
= user_len
* 2;
11651 netntlm
->domain_len
= domain_len
* 2;
11652 netntlm
->srvchall_len
= srvchall_len
/ 2;
11653 netntlm
->clichall_len
= clichall_len
/ 2;
11655 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11656 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11659 * handle username and domainname
11662 for (uint i
= 0; i
< user_len
; i
++)
11664 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11665 *userdomain_ptr
++ = 0;
11668 for (uint i
= 0; i
< domain_len
; i
++)
11670 *userdomain_ptr
++ = domain_pos
[i
];
11671 *userdomain_ptr
++ = 0;
11674 *userdomain_ptr
++ = 0x80;
11677 * handle server challenge encoding
11680 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11682 const char p0
= srvchall_pos
[i
+ 0];
11683 const char p1
= srvchall_pos
[i
+ 1];
11685 *chall_ptr
++ = hex_convert (p1
) << 0
11686 | hex_convert (p0
) << 4;
11690 * handle client challenge encoding
11693 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11695 const char p0
= clichall_pos
[i
+ 0];
11696 const char p1
= clichall_pos
[i
+ 1];
11698 *chall_ptr
++ = hex_convert (p1
) << 0
11699 | hex_convert (p0
) << 4;
11702 *chall_ptr
++ = 0x80;
11705 * handle hash itself
11708 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11709 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11710 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11711 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11713 digest
[0] = byte_swap_32 (digest
[0]);
11714 digest
[1] = byte_swap_32 (digest
[1]);
11715 digest
[2] = byte_swap_32 (digest
[2]);
11716 digest
[3] = byte_swap_32 (digest
[3]);
11719 * reuse challange data as salt_buf, its the buffer that is most likely unique
11722 salt
->salt_buf
[0] = 0;
11723 salt
->salt_buf
[1] = 0;
11724 salt
->salt_buf
[2] = 0;
11725 salt
->salt_buf
[3] = 0;
11726 salt
->salt_buf
[4] = 0;
11727 salt
->salt_buf
[5] = 0;
11728 salt
->salt_buf
[6] = 0;
11729 salt
->salt_buf
[7] = 0;
11733 uptr
= (uint
*) netntlm
->userdomain_buf
;
11735 for (uint i
= 0; i
< 16; i
+= 16)
11737 md5_64 (uptr
, salt
->salt_buf
);
11740 uptr
= (uint
*) netntlm
->chall_buf
;
11742 for (uint i
= 0; i
< 256; i
+= 16)
11744 md5_64 (uptr
, salt
->salt_buf
);
11747 salt
->salt_len
= 16;
11749 return (PARSER_OK
);
11752 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11754 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11756 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11760 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11763 u32
*digest
= (u32
*) hash_buf
->digest
;
11765 salt_t
*salt
= hash_buf
->salt
;
11767 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11768 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11769 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11770 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11772 digest
[0] = byte_swap_32 (digest
[0]);
11773 digest
[1] = byte_swap_32 (digest
[1]);
11774 digest
[2] = byte_swap_32 (digest
[2]);
11775 digest
[3] = byte_swap_32 (digest
[3]);
11777 digest
[0] -= MD5M_A
;
11778 digest
[1] -= MD5M_B
;
11779 digest
[2] -= MD5M_C
;
11780 digest
[3] -= MD5M_D
;
11782 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11784 uint salt_len
= input_len
- 32 - 1;
11786 char *salt_buf
= input_buf
+ 32 + 1;
11788 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11790 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11792 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11794 salt
->salt_len
= salt_len
;
11796 return (PARSER_OK
);
11799 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11801 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11803 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11807 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11810 u32
*digest
= (u32
*) hash_buf
->digest
;
11812 salt_t
*salt
= hash_buf
->salt
;
11814 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11815 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11816 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11817 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11819 digest
[0] = byte_swap_32 (digest
[0]);
11820 digest
[1] = byte_swap_32 (digest
[1]);
11821 digest
[2] = byte_swap_32 (digest
[2]);
11822 digest
[3] = byte_swap_32 (digest
[3]);
11824 digest
[0] -= MD5M_A
;
11825 digest
[1] -= MD5M_B
;
11826 digest
[2] -= MD5M_C
;
11827 digest
[3] -= MD5M_D
;
11829 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11831 uint salt_len
= input_len
- 32 - 1;
11833 char *salt_buf
= input_buf
+ 32 + 1;
11835 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11837 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11839 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11841 salt
->salt_len
= salt_len
;
11843 return (PARSER_OK
);
11846 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11848 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11850 u32
*digest
= (u32
*) hash_buf
->digest
;
11852 salt_t
*salt
= hash_buf
->salt
;
11854 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11855 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11856 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11857 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11859 digest
[0] = byte_swap_32 (digest
[0]);
11860 digest
[1] = byte_swap_32 (digest
[1]);
11861 digest
[2] = byte_swap_32 (digest
[2]);
11862 digest
[3] = byte_swap_32 (digest
[3]);
11864 digest
[0] -= MD5M_A
;
11865 digest
[1] -= MD5M_B
;
11866 digest
[2] -= MD5M_C
;
11867 digest
[3] -= MD5M_D
;
11870 * This is a virtual salt. While the algorithm is basically not salted
11871 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11872 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11875 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11877 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11879 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11881 salt
->salt_len
= salt_len
;
11883 return (PARSER_OK
);
11886 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11888 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11890 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11894 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11897 u32
*digest
= (u32
*) hash_buf
->digest
;
11899 salt_t
*salt
= hash_buf
->salt
;
11901 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11902 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11903 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11904 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11906 digest
[0] = byte_swap_32 (digest
[0]);
11907 digest
[1] = byte_swap_32 (digest
[1]);
11908 digest
[2] = byte_swap_32 (digest
[2]);
11909 digest
[3] = byte_swap_32 (digest
[3]);
11911 digest
[0] -= MD5M_A
;
11912 digest
[1] -= MD5M_B
;
11913 digest
[2] -= MD5M_C
;
11914 digest
[3] -= MD5M_D
;
11916 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11918 uint salt_len
= input_len
- 32 - 1;
11920 char *salt_buf
= input_buf
+ 32 + 1;
11922 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11924 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11926 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11928 salt
->salt_len
= salt_len
;
11930 return (PARSER_OK
);
11933 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11935 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11937 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11941 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11944 u32
*digest
= (u32
*) hash_buf
->digest
;
11946 salt_t
*salt
= hash_buf
->salt
;
11948 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11949 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11950 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11951 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11953 digest
[0] = byte_swap_32 (digest
[0]);
11954 digest
[1] = byte_swap_32 (digest
[1]);
11955 digest
[2] = byte_swap_32 (digest
[2]);
11956 digest
[3] = byte_swap_32 (digest
[3]);
11958 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11960 uint salt_len
= input_len
- 32 - 1;
11962 char *salt_buf
= input_buf
+ 32 + 1;
11964 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11966 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11968 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11970 salt
->salt_len
= salt_len
;
11972 return (PARSER_OK
);
11975 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11977 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11979 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11983 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11986 u32
*digest
= (u32
*) hash_buf
->digest
;
11988 salt_t
*salt
= hash_buf
->salt
;
11990 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11991 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11992 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11993 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11995 digest
[0] = byte_swap_32 (digest
[0]);
11996 digest
[1] = byte_swap_32 (digest
[1]);
11997 digest
[2] = byte_swap_32 (digest
[2]);
11998 digest
[3] = byte_swap_32 (digest
[3]);
12000 digest
[0] -= MD4M_A
;
12001 digest
[1] -= MD4M_B
;
12002 digest
[2] -= MD4M_C
;
12003 digest
[3] -= MD4M_D
;
12005 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12007 uint salt_len
= input_len
- 32 - 1;
12009 char *salt_buf
= input_buf
+ 32 + 1;
12011 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12013 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12015 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12017 salt
->salt_len
= salt_len
;
12019 return (PARSER_OK
);
12022 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12024 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12026 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
12030 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
12033 u32
*digest
= (u32
*) hash_buf
->digest
;
12035 salt_t
*salt
= hash_buf
->salt
;
12037 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12038 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12039 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12040 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12042 digest
[0] = byte_swap_32 (digest
[0]);
12043 digest
[1] = byte_swap_32 (digest
[1]);
12044 digest
[2] = byte_swap_32 (digest
[2]);
12045 digest
[3] = byte_swap_32 (digest
[3]);
12047 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12049 uint salt_len
= input_len
- 32 - 1;
12051 char *salt_buf
= input_buf
+ 32 + 1;
12053 uint salt_pc_block
[16] = { 0 };
12055 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
12057 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
12059 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12061 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
12063 salt_pc_block
[14] = salt_len
* 8;
12065 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
12067 md5_64 (salt_pc_block
, salt_pc_digest
);
12069 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
12070 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
12071 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
12072 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
12074 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
12076 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
12078 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
12080 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
12081 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
12082 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
12083 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
12085 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
12087 return (PARSER_OK
);
12090 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12092 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
12094 u32
*digest
= (u32
*) hash_buf
->digest
;
12096 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12097 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12098 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12099 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12100 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12102 digest
[0] -= SHA1M_A
;
12103 digest
[1] -= SHA1M_B
;
12104 digest
[2] -= SHA1M_C
;
12105 digest
[3] -= SHA1M_D
;
12106 digest
[4] -= SHA1M_E
;
12108 return (PARSER_OK
);
12111 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12113 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
12115 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
12117 u32
*digest
= (u32
*) hash_buf
->digest
;
12121 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12122 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12123 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12124 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12127 return (PARSER_OK
);
12130 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12132 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12134 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12138 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12141 u32
*digest
= (u32
*) hash_buf
->digest
;
12143 salt_t
*salt
= hash_buf
->salt
;
12145 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12146 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12147 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12148 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12149 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12151 digest
[0] -= SHA1M_A
;
12152 digest
[1] -= SHA1M_B
;
12153 digest
[2] -= SHA1M_C
;
12154 digest
[3] -= SHA1M_D
;
12155 digest
[4] -= SHA1M_E
;
12157 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12159 uint salt_len
= input_len
- 40 - 1;
12161 char *salt_buf
= input_buf
+ 40 + 1;
12163 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12165 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12167 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12169 salt
->salt_len
= salt_len
;
12171 return (PARSER_OK
);
12174 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12176 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12178 u32
*digest
= (u32
*) hash_buf
->digest
;
12180 salt_t
*salt
= hash_buf
->salt
;
12182 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12184 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12185 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12186 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12187 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12188 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12190 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12192 uint salt_len
= input_len
- 40 - 1;
12194 char *salt_buf
= input_buf
+ 40 + 1;
12196 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12198 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12200 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12202 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12205 pstoken
->salt_len
= salt_len
/ 2;
12207 /* some fake salt for the sorting mechanisms */
12209 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12210 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12211 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12212 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12213 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12214 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12215 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12216 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12218 salt
->salt_len
= 32;
12220 /* we need to check if we can precompute some of the data --
12221 this is possible since the scheme is badly designed */
12223 pstoken
->pc_digest
[0] = SHA1M_A
;
12224 pstoken
->pc_digest
[1] = SHA1M_B
;
12225 pstoken
->pc_digest
[2] = SHA1M_C
;
12226 pstoken
->pc_digest
[3] = SHA1M_D
;
12227 pstoken
->pc_digest
[4] = SHA1M_E
;
12229 pstoken
->pc_offset
= 0;
12231 for (int i
= 0; i
< (int) pstoken
->salt_len
- 63; i
+= 64)
12235 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12236 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12237 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12238 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12239 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12240 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12241 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12242 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12243 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12244 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12245 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12246 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12247 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12248 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12249 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12250 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12252 sha1_64 (w
, pstoken
->pc_digest
);
12254 pstoken
->pc_offset
+= 16;
12257 return (PARSER_OK
);
12260 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12262 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12264 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12266 u32
*digest
= (u32
*) hash_buf
->digest
;
12268 u8 tmp_buf
[100] = { 0 };
12270 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12272 memcpy (digest
, tmp_buf
, 20);
12274 digest
[0] = byte_swap_32 (digest
[0]);
12275 digest
[1] = byte_swap_32 (digest
[1]);
12276 digest
[2] = byte_swap_32 (digest
[2]);
12277 digest
[3] = byte_swap_32 (digest
[3]);
12278 digest
[4] = byte_swap_32 (digest
[4]);
12280 digest
[0] -= SHA1M_A
;
12281 digest
[1] -= SHA1M_B
;
12282 digest
[2] -= SHA1M_C
;
12283 digest
[3] -= SHA1M_D
;
12284 digest
[4] -= SHA1M_E
;
12286 return (PARSER_OK
);
12289 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12291 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12293 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12295 u32
*digest
= (u32
*) hash_buf
->digest
;
12297 salt_t
*salt
= hash_buf
->salt
;
12299 u8 tmp_buf
[100] = { 0 };
12301 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12303 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12305 memcpy (digest
, tmp_buf
, 20);
12307 int salt_len
= tmp_len
- 20;
12309 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12311 salt
->salt_len
= salt_len
;
12313 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12315 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12317 char *ptr
= (char *) salt
->salt_buf
;
12319 ptr
[salt
->salt_len
] = 0x80;
12322 digest
[0] = byte_swap_32 (digest
[0]);
12323 digest
[1] = byte_swap_32 (digest
[1]);
12324 digest
[2] = byte_swap_32 (digest
[2]);
12325 digest
[3] = byte_swap_32 (digest
[3]);
12326 digest
[4] = byte_swap_32 (digest
[4]);
12328 digest
[0] -= SHA1M_A
;
12329 digest
[1] -= SHA1M_B
;
12330 digest
[2] -= SHA1M_C
;
12331 digest
[3] -= SHA1M_D
;
12332 digest
[4] -= SHA1M_E
;
12334 return (PARSER_OK
);
12337 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12339 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12341 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12343 u32
*digest
= (u32
*) hash_buf
->digest
;
12345 salt_t
*salt
= hash_buf
->salt
;
12347 char *salt_buf
= input_buf
+ 6;
12351 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12353 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12355 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12357 salt
->salt_len
= salt_len
;
12359 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12361 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12362 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12363 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12364 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12365 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12367 digest
[0] -= SHA1M_A
;
12368 digest
[1] -= SHA1M_B
;
12369 digest
[2] -= SHA1M_C
;
12370 digest
[3] -= SHA1M_D
;
12371 digest
[4] -= SHA1M_E
;
12373 return (PARSER_OK
);
12376 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12378 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12380 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12382 u32
*digest
= (u32
*) hash_buf
->digest
;
12384 salt_t
*salt
= hash_buf
->salt
;
12386 char *salt_buf
= input_buf
+ 6;
12390 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12392 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12394 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12396 salt
->salt_len
= salt_len
;
12398 char *hash_pos
= input_buf
+ 6 + 8;
12400 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12401 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12402 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12403 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12404 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12406 digest
[0] -= SHA1M_A
;
12407 digest
[1] -= SHA1M_B
;
12408 digest
[2] -= SHA1M_C
;
12409 digest
[3] -= SHA1M_D
;
12410 digest
[4] -= SHA1M_E
;
12412 return (PARSER_OK
);
12415 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12417 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12419 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12421 u64
*digest
= (u64
*) hash_buf
->digest
;
12423 salt_t
*salt
= hash_buf
->salt
;
12425 char *salt_buf
= input_buf
+ 6;
12429 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12431 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12433 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12435 salt
->salt_len
= salt_len
;
12437 char *hash_pos
= input_buf
+ 6 + 8;
12439 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12440 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12441 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12442 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12443 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12444 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12445 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12446 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12448 digest
[0] -= SHA512M_A
;
12449 digest
[1] -= SHA512M_B
;
12450 digest
[2] -= SHA512M_C
;
12451 digest
[3] -= SHA512M_D
;
12452 digest
[4] -= SHA512M_E
;
12453 digest
[5] -= SHA512M_F
;
12454 digest
[6] -= SHA512M_G
;
12455 digest
[7] -= SHA512M_H
;
12457 return (PARSER_OK
);
12460 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12462 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12464 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12468 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12471 u32
*digest
= (u32
*) hash_buf
->digest
;
12473 salt_t
*salt
= hash_buf
->salt
;
12475 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12476 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12480 digest
[0] = byte_swap_32 (digest
[0]);
12481 digest
[1] = byte_swap_32 (digest
[1]);
12483 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12485 uint salt_len
= input_len
- 16 - 1;
12487 char *salt_buf
= input_buf
+ 16 + 1;
12489 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12491 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12493 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12495 salt
->salt_len
= salt_len
;
12497 return (PARSER_OK
);
12500 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12502 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12504 u32
*digest
= (u32
*) hash_buf
->digest
;
12506 salt_t
*salt
= hash_buf
->salt
;
12508 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12509 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12510 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12511 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12512 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12514 digest
[0] -= SHA1M_A
;
12515 digest
[1] -= SHA1M_B
;
12516 digest
[2] -= SHA1M_C
;
12517 digest
[3] -= SHA1M_D
;
12518 digest
[4] -= SHA1M_E
;
12520 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12522 uint salt_len
= input_len
- 40 - 1;
12524 char *salt_buf
= input_buf
+ 40 + 1;
12526 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12528 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12530 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12532 salt
->salt_len
= salt_len
;
12534 return (PARSER_OK
);
12537 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12539 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12541 u32
*digest
= (u32
*) hash_buf
->digest
;
12543 salt_t
*salt
= hash_buf
->salt
;
12545 char *hash_pos
= input_buf
;
12547 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12548 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12549 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12550 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12551 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12552 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12553 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12554 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12555 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12556 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12557 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12558 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12559 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12560 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12561 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12562 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12564 char *salt_pos
= input_buf
+ 128;
12566 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12567 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12568 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12569 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12571 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12572 salt
->salt_len
= 16;
12574 return (PARSER_OK
);
12577 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12579 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12581 u32
*digest
= (u32
*) hash_buf
->digest
;
12583 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12584 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12585 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12586 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12587 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12588 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12589 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12590 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12592 digest
[0] -= SHA256M_A
;
12593 digest
[1] -= SHA256M_B
;
12594 digest
[2] -= SHA256M_C
;
12595 digest
[3] -= SHA256M_D
;
12596 digest
[4] -= SHA256M_E
;
12597 digest
[5] -= SHA256M_F
;
12598 digest
[6] -= SHA256M_G
;
12599 digest
[7] -= SHA256M_H
;
12601 return (PARSER_OK
);
12604 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12606 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12608 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12612 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12615 u32
*digest
= (u32
*) hash_buf
->digest
;
12617 salt_t
*salt
= hash_buf
->salt
;
12619 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12620 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12621 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12622 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12623 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12624 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12625 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12626 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12628 digest
[0] -= SHA256M_A
;
12629 digest
[1] -= SHA256M_B
;
12630 digest
[2] -= SHA256M_C
;
12631 digest
[3] -= SHA256M_D
;
12632 digest
[4] -= SHA256M_E
;
12633 digest
[5] -= SHA256M_F
;
12634 digest
[6] -= SHA256M_G
;
12635 digest
[7] -= SHA256M_H
;
12637 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12639 uint salt_len
= input_len
- 64 - 1;
12641 char *salt_buf
= input_buf
+ 64 + 1;
12643 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12645 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12647 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12649 salt
->salt_len
= salt_len
;
12651 return (PARSER_OK
);
12654 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12656 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12658 u64
*digest
= (u64
*) hash_buf
->digest
;
12660 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12661 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12662 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12663 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12664 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12665 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12669 digest
[0] -= SHA384M_A
;
12670 digest
[1] -= SHA384M_B
;
12671 digest
[2] -= SHA384M_C
;
12672 digest
[3] -= SHA384M_D
;
12673 digest
[4] -= SHA384M_E
;
12674 digest
[5] -= SHA384M_F
;
12678 return (PARSER_OK
);
12681 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12683 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12685 u64
*digest
= (u64
*) hash_buf
->digest
;
12687 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12688 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12689 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12690 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12691 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12692 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12693 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12694 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12696 digest
[0] -= SHA512M_A
;
12697 digest
[1] -= SHA512M_B
;
12698 digest
[2] -= SHA512M_C
;
12699 digest
[3] -= SHA512M_D
;
12700 digest
[4] -= SHA512M_E
;
12701 digest
[5] -= SHA512M_F
;
12702 digest
[6] -= SHA512M_G
;
12703 digest
[7] -= SHA512M_H
;
12705 return (PARSER_OK
);
12708 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12710 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12712 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12716 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12719 u64
*digest
= (u64
*) hash_buf
->digest
;
12721 salt_t
*salt
= hash_buf
->salt
;
12723 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12724 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12725 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12726 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12727 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12728 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12729 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12730 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12732 digest
[0] -= SHA512M_A
;
12733 digest
[1] -= SHA512M_B
;
12734 digest
[2] -= SHA512M_C
;
12735 digest
[3] -= SHA512M_D
;
12736 digest
[4] -= SHA512M_E
;
12737 digest
[5] -= SHA512M_F
;
12738 digest
[6] -= SHA512M_G
;
12739 digest
[7] -= SHA512M_H
;
12741 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12743 uint salt_len
= input_len
- 128 - 1;
12745 char *salt_buf
= input_buf
+ 128 + 1;
12747 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12749 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12751 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12753 salt
->salt_len
= salt_len
;
12755 return (PARSER_OK
);
12758 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12760 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12762 u64
*digest
= (u64
*) hash_buf
->digest
;
12764 salt_t
*salt
= hash_buf
->salt
;
12766 char *salt_pos
= input_buf
+ 3;
12768 uint iterations_len
= 0;
12770 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12774 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12776 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12777 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12781 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12785 iterations_len
+= 8;
12789 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12792 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12794 char *hash_pos
= strchr (salt_pos
, '$');
12796 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12798 uint salt_len
= hash_pos
- salt_pos
;
12800 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12802 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12804 salt
->salt_len
= salt_len
;
12808 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12810 return (PARSER_OK
);
12813 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12815 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12817 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12819 u64
*digest
= (u64
*) hash_buf
->digest
;
12821 salt_t
*salt
= hash_buf
->salt
;
12823 uint keccak_mdlen
= input_len
/ 2;
12825 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12827 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12829 digest
[i
] = byte_swap_64 (digest
[i
]);
12832 salt
->keccak_mdlen
= keccak_mdlen
;
12834 return (PARSER_OK
);
12837 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12839 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12841 u32
*digest
= (u32
*) hash_buf
->digest
;
12843 salt_t
*salt
= hash_buf
->salt
;
12845 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12848 * Parse that strange long line
12853 size_t in_len
[9] = { 0 };
12855 in_off
[0] = strtok (input_buf
, ":");
12857 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12859 in_len
[0] = strlen (in_off
[0]);
12863 for (i
= 1; i
< 9; i
++)
12865 in_off
[i
] = strtok (NULL
, ":");
12867 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12869 in_len
[i
] = strlen (in_off
[i
]);
12872 char *ptr
= (char *) ikepsk
->msg_buf
;
12874 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12875 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12876 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12877 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12878 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12879 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12883 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12885 ptr
= (char *) ikepsk
->nr_buf
;
12887 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12888 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12892 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12895 * Store to database
12900 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12901 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12902 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12903 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12905 digest
[0] = byte_swap_32 (digest
[0]);
12906 digest
[1] = byte_swap_32 (digest
[1]);
12907 digest
[2] = byte_swap_32 (digest
[2]);
12908 digest
[3] = byte_swap_32 (digest
[3]);
12910 salt
->salt_len
= 32;
12912 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12913 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12914 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12915 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12916 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12917 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12918 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12919 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12921 return (PARSER_OK
);
12924 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12926 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12928 u32
*digest
= (u32
*) hash_buf
->digest
;
12930 salt_t
*salt
= hash_buf
->salt
;
12932 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12935 * Parse that strange long line
12940 size_t in_len
[9] = { 0 };
12942 in_off
[0] = strtok (input_buf
, ":");
12944 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12946 in_len
[0] = strlen (in_off
[0]);
12950 for (i
= 1; i
< 9; i
++)
12952 in_off
[i
] = strtok (NULL
, ":");
12954 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12956 in_len
[i
] = strlen (in_off
[i
]);
12959 char *ptr
= (char *) ikepsk
->msg_buf
;
12961 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12962 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12963 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12964 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12965 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12966 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12970 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12972 ptr
= (char *) ikepsk
->nr_buf
;
12974 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12975 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12979 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12982 * Store to database
12987 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12988 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12989 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12990 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12991 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12993 salt
->salt_len
= 32;
12995 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12996 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12997 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12998 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12999 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
13000 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
13001 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
13002 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
13004 return (PARSER_OK
);
13007 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13009 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
13011 u32
*digest
= (u32
*) hash_buf
->digest
;
13013 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13014 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13015 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13016 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13017 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13019 digest
[0] = byte_swap_32 (digest
[0]);
13020 digest
[1] = byte_swap_32 (digest
[1]);
13021 digest
[2] = byte_swap_32 (digest
[2]);
13022 digest
[3] = byte_swap_32 (digest
[3]);
13023 digest
[4] = byte_swap_32 (digest
[4]);
13025 return (PARSER_OK
);
13028 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13030 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
13032 u32
*digest
= (u32
*) hash_buf
->digest
;
13034 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13035 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13036 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
13037 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
13038 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
13039 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
13040 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
13041 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
13042 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
13043 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
13044 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
13045 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
13046 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
13047 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
13048 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
13049 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
13051 return (PARSER_OK
);
13054 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13056 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
13058 u32
*digest
= (u32
*) hash_buf
->digest
;
13060 salt_t
*salt
= hash_buf
->salt
;
13062 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13063 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13064 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13065 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13066 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13068 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13070 uint salt_len
= input_len
- 40 - 1;
13072 char *salt_buf
= input_buf
+ 40 + 1;
13074 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13076 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13078 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13080 salt
->salt_len
= salt_len
;
13082 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
13084 return (PARSER_OK
);
13087 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13089 u32
*digest
= (u32
*) hash_buf
->digest
;
13091 salt_t
*salt
= hash_buf
->salt
;
13093 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13095 if (input_len
== 0)
13097 log_error ("TrueCrypt container not specified");
13102 FILE *fp
= fopen (input_buf
, "rb");
13106 log_error ("%s: %s", input_buf
, strerror (errno
));
13111 char buf
[512] = { 0 };
13113 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13117 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13119 memcpy (tc
->salt_buf
, buf
, 64);
13121 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13123 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13125 salt
->salt_len
= 4;
13127 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
13129 tc
->signature
= 0x45555254; // "TRUE"
13131 digest
[0] = tc
->data_buf
[0];
13133 return (PARSER_OK
);
13136 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13138 u32
*digest
= (u32
*) hash_buf
->digest
;
13140 salt_t
*salt
= hash_buf
->salt
;
13142 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13144 if (input_len
== 0)
13146 log_error ("TrueCrypt container not specified");
13151 FILE *fp
= fopen (input_buf
, "rb");
13155 log_error ("%s: %s", input_buf
, strerror (errno
));
13160 char buf
[512] = { 0 };
13162 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13166 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13168 memcpy (tc
->salt_buf
, buf
, 64);
13170 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13172 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13174 salt
->salt_len
= 4;
13176 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13178 tc
->signature
= 0x45555254; // "TRUE"
13180 digest
[0] = tc
->data_buf
[0];
13182 return (PARSER_OK
);
13185 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13187 u32
*digest
= (u32
*) hash_buf
->digest
;
13189 salt_t
*salt
= hash_buf
->salt
;
13191 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13193 if (input_len
== 0)
13195 log_error ("VeraCrypt container not specified");
13200 FILE *fp
= fopen (input_buf
, "rb");
13204 log_error ("%s: %s", input_buf
, strerror (errno
));
13209 char buf
[512] = { 0 };
13211 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13215 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13217 memcpy (tc
->salt_buf
, buf
, 64);
13219 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13221 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13223 salt
->salt_len
= 4;
13225 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13227 tc
->signature
= 0x41524556; // "VERA"
13229 digest
[0] = tc
->data_buf
[0];
13231 return (PARSER_OK
);
13234 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13236 u32
*digest
= (u32
*) hash_buf
->digest
;
13238 salt_t
*salt
= hash_buf
->salt
;
13240 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13242 if (input_len
== 0)
13244 log_error ("VeraCrypt container not specified");
13249 FILE *fp
= fopen (input_buf
, "rb");
13253 log_error ("%s: %s", input_buf
, strerror (errno
));
13258 char buf
[512] = { 0 };
13260 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13264 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13266 memcpy (tc
->salt_buf
, buf
, 64);
13268 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13270 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13272 salt
->salt_len
= 4;
13274 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13276 tc
->signature
= 0x41524556; // "VERA"
13278 digest
[0] = tc
->data_buf
[0];
13280 return (PARSER_OK
);
13283 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13285 u32
*digest
= (u32
*) hash_buf
->digest
;
13287 salt_t
*salt
= hash_buf
->salt
;
13289 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13291 if (input_len
== 0)
13293 log_error ("VeraCrypt container not specified");
13298 FILE *fp
= fopen (input_buf
, "rb");
13302 log_error ("%s: %s", input_buf
, strerror (errno
));
13307 char buf
[512] = { 0 };
13309 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13313 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13315 memcpy (tc
->salt_buf
, buf
, 64);
13317 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13319 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13321 salt
->salt_len
= 4;
13323 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13325 tc
->signature
= 0x41524556; // "VERA"
13327 digest
[0] = tc
->data_buf
[0];
13329 return (PARSER_OK
);
13332 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13334 u32
*digest
= (u32
*) hash_buf
->digest
;
13336 salt_t
*salt
= hash_buf
->salt
;
13338 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13340 if (input_len
== 0)
13342 log_error ("VeraCrypt container not specified");
13347 FILE *fp
= fopen (input_buf
, "rb");
13351 log_error ("%s: %s", input_buf
, strerror (errno
));
13356 char buf
[512] = { 0 };
13358 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13362 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13364 memcpy (tc
->salt_buf
, buf
, 64);
13366 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13368 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13370 salt
->salt_len
= 4;
13372 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13374 tc
->signature
= 0x41524556; // "VERA"
13376 digest
[0] = tc
->data_buf
[0];
13378 return (PARSER_OK
);
13381 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13383 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13385 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13387 u32
*digest
= (u32
*) hash_buf
->digest
;
13389 salt_t
*salt
= hash_buf
->salt
;
13391 char *salt_pos
= input_buf
+ 6;
13393 char *hash_pos
= strchr (salt_pos
, '$');
13395 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13397 uint salt_len
= hash_pos
- salt_pos
;
13399 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13401 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13403 salt
->salt_len
= salt_len
;
13405 salt
->salt_iter
= 1000;
13409 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13411 return (PARSER_OK
);
13414 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13416 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13418 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13420 u32
*digest
= (u32
*) hash_buf
->digest
;
13422 salt_t
*salt
= hash_buf
->salt
;
13424 char *iter_pos
= input_buf
+ 7;
13426 char *salt_pos
= strchr (iter_pos
, '$');
13428 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13432 char *hash_pos
= strchr (salt_pos
, '$');
13434 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13436 uint salt_len
= hash_pos
- salt_pos
;
13438 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13440 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13442 salt
->salt_len
= salt_len
;
13444 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13446 salt
->salt_sign
[0] = atoi (salt_iter
);
13448 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13452 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13454 digest
[0] = byte_swap_32 (digest
[0]);
13455 digest
[1] = byte_swap_32 (digest
[1]);
13456 digest
[2] = byte_swap_32 (digest
[2]);
13457 digest
[3] = byte_swap_32 (digest
[3]);
13458 digest
[4] = byte_swap_32 (digest
[4]);
13460 return (PARSER_OK
);
13463 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13465 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13467 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13469 u32
*digest
= (u32
*) hash_buf
->digest
;
13471 salt_t
*salt
= hash_buf
->salt
;
13473 char *iter_pos
= input_buf
+ 9;
13475 char *salt_pos
= strchr (iter_pos
, '$');
13477 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13481 char *hash_pos
= strchr (salt_pos
, '$');
13483 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13485 uint salt_len
= hash_pos
- salt_pos
;
13487 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13489 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13491 salt
->salt_len
= salt_len
;
13493 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13495 salt
->salt_sign
[0] = atoi (salt_iter
);
13497 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13501 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13503 digest
[0] = byte_swap_32 (digest
[0]);
13504 digest
[1] = byte_swap_32 (digest
[1]);
13505 digest
[2] = byte_swap_32 (digest
[2]);
13506 digest
[3] = byte_swap_32 (digest
[3]);
13507 digest
[4] = byte_swap_32 (digest
[4]);
13508 digest
[5] = byte_swap_32 (digest
[5]);
13509 digest
[6] = byte_swap_32 (digest
[6]);
13510 digest
[7] = byte_swap_32 (digest
[7]);
13512 return (PARSER_OK
);
13515 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13517 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13519 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13521 u64
*digest
= (u64
*) hash_buf
->digest
;
13523 salt_t
*salt
= hash_buf
->salt
;
13525 char *iter_pos
= input_buf
+ 9;
13527 char *salt_pos
= strchr (iter_pos
, '$');
13529 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13533 char *hash_pos
= strchr (salt_pos
, '$');
13535 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13537 uint salt_len
= hash_pos
- salt_pos
;
13539 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13541 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13543 salt
->salt_len
= salt_len
;
13545 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13547 salt
->salt_sign
[0] = atoi (salt_iter
);
13549 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13553 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13555 digest
[0] = byte_swap_64 (digest
[0]);
13556 digest
[1] = byte_swap_64 (digest
[1]);
13557 digest
[2] = byte_swap_64 (digest
[2]);
13558 digest
[3] = byte_swap_64 (digest
[3]);
13559 digest
[4] = byte_swap_64 (digest
[4]);
13560 digest
[5] = byte_swap_64 (digest
[5]);
13561 digest
[6] = byte_swap_64 (digest
[6]);
13562 digest
[7] = byte_swap_64 (digest
[7]);
13564 return (PARSER_OK
);
13567 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13569 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13571 u32
*digest
= (u32
*) hash_buf
->digest
;
13573 salt_t
*salt
= hash_buf
->salt
;
13575 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13581 char *iterations_pos
= input_buf
;
13583 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13585 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13587 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13589 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13593 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13595 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13597 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13599 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13601 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13603 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13608 * pbkdf2 iterations
13611 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13614 * handle salt encoding
13617 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13619 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13621 const char p0
= saltbuf_pos
[i
+ 0];
13622 const char p1
= saltbuf_pos
[i
+ 1];
13624 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13625 | hex_convert (p0
) << 4;
13628 salt
->salt_len
= saltbuf_len
/ 2;
13631 * handle cipher encoding
13634 uint
*tmp
= (uint
*) mymalloc (32);
13636 char *cipherbuf_ptr
= (char *) tmp
;
13638 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13640 const char p0
= cipherbuf_pos
[i
+ 0];
13641 const char p1
= cipherbuf_pos
[i
+ 1];
13643 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13644 | hex_convert (p0
) << 4;
13647 // iv is stored at salt_buf 4 (length 16)
13648 // data is stored at salt_buf 8 (length 16)
13650 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13651 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13652 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13653 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13655 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13656 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13657 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13658 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13662 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13664 const char p0
= cipherbuf_pos
[j
+ 0];
13665 const char p1
= cipherbuf_pos
[j
+ 1];
13667 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13668 | hex_convert (p0
) << 4;
13675 digest
[0] = 0x10101010;
13676 digest
[1] = 0x10101010;
13677 digest
[2] = 0x10101010;
13678 digest
[3] = 0x10101010;
13680 return (PARSER_OK
);
13683 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13685 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13687 u32
*digest
= (u32
*) hash_buf
->digest
;
13689 salt_t
*salt
= hash_buf
->salt
;
13691 char *hashbuf_pos
= input_buf
;
13693 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13695 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13697 uint hash_len
= iterations_pos
- hashbuf_pos
;
13699 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13703 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13705 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13707 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13711 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13713 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13715 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13717 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13719 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13721 salt
->salt_len
= salt_len
;
13723 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13725 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13726 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13727 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13728 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13730 return (PARSER_OK
);
13733 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13735 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13737 u32
*digest
= (u32
*) hash_buf
->digest
;
13739 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13740 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13741 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13742 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13743 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13744 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13745 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13746 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13748 digest
[0] = byte_swap_32 (digest
[0]);
13749 digest
[1] = byte_swap_32 (digest
[1]);
13750 digest
[2] = byte_swap_32 (digest
[2]);
13751 digest
[3] = byte_swap_32 (digest
[3]);
13752 digest
[4] = byte_swap_32 (digest
[4]);
13753 digest
[5] = byte_swap_32 (digest
[5]);
13754 digest
[6] = byte_swap_32 (digest
[6]);
13755 digest
[7] = byte_swap_32 (digest
[7]);
13757 return (PARSER_OK
);
13760 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13762 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13764 u32
*digest
= (u32
*) hash_buf
->digest
;
13766 salt_t
*salt
= hash_buf
->salt
;
13768 char *salt_pos
= input_buf
+ 3;
13770 uint iterations_len
= 0;
13772 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13776 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13778 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13779 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13783 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13787 iterations_len
+= 8;
13791 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13794 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13796 char *hash_pos
= strchr (salt_pos
, '$');
13798 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13800 uint salt_len
= hash_pos
- salt_pos
;
13802 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13804 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13806 salt
->salt_len
= salt_len
;
13810 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13812 return (PARSER_OK
);
13815 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13817 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13819 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13821 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13823 u64
*digest
= (u64
*) hash_buf
->digest
;
13825 salt_t
*salt
= hash_buf
->salt
;
13827 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13829 char *iter_pos
= input_buf
+ 4;
13831 char *salt_pos
= strchr (iter_pos
, '$');
13833 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13837 char *hash_pos
= strchr (salt_pos
, '$');
13839 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13841 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13845 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13846 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13847 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13848 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13849 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13850 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13851 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13852 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13854 uint salt_len
= hash_pos
- salt_pos
- 1;
13856 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13858 salt
->salt_len
= salt_len
/ 2;
13860 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13861 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13862 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13863 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13864 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13865 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13866 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13867 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13869 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13870 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13871 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13872 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13873 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13874 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13875 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13876 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13877 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13878 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13880 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13882 salt
->salt_iter
= atoi (iter_pos
) - 1;
13884 return (PARSER_OK
);
13887 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13889 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13891 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13893 u32
*digest
= (u32
*) hash_buf
->digest
;
13895 salt_t
*salt
= hash_buf
->salt
;
13897 char *salt_pos
= input_buf
+ 14;
13899 char *hash_pos
= strchr (salt_pos
, '*');
13901 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13905 uint salt_len
= hash_pos
- salt_pos
- 1;
13907 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13909 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13911 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13913 salt
->salt_len
= salt_len
;
13915 u8 tmp_buf
[100] = { 0 };
13917 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13919 memcpy (digest
, tmp_buf
, 32);
13921 digest
[0] = byte_swap_32 (digest
[0]);
13922 digest
[1] = byte_swap_32 (digest
[1]);
13923 digest
[2] = byte_swap_32 (digest
[2]);
13924 digest
[3] = byte_swap_32 (digest
[3]);
13925 digest
[4] = byte_swap_32 (digest
[4]);
13926 digest
[5] = byte_swap_32 (digest
[5]);
13927 digest
[6] = byte_swap_32 (digest
[6]);
13928 digest
[7] = byte_swap_32 (digest
[7]);
13930 digest
[0] -= SHA256M_A
;
13931 digest
[1] -= SHA256M_B
;
13932 digest
[2] -= SHA256M_C
;
13933 digest
[3] -= SHA256M_D
;
13934 digest
[4] -= SHA256M_E
;
13935 digest
[5] -= SHA256M_F
;
13936 digest
[6] -= SHA256M_G
;
13937 digest
[7] -= SHA256M_H
;
13939 return (PARSER_OK
);
13942 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13944 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13946 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13948 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13950 u64
*digest
= (u64
*) hash_buf
->digest
;
13952 salt_t
*salt
= hash_buf
->salt
;
13954 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13956 char *iter_pos
= input_buf
+ 19;
13958 char *salt_pos
= strchr (iter_pos
, '.');
13960 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13964 char *hash_pos
= strchr (salt_pos
, '.');
13966 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13968 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13972 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13973 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13974 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13975 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13976 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13977 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13978 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13979 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13981 uint salt_len
= hash_pos
- salt_pos
- 1;
13985 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13989 for (i
= 0; i
< salt_len
; i
++)
13991 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13994 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13995 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13997 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13999 salt
->salt_len
= salt_len
;
14001 salt
->salt_iter
= atoi (iter_pos
) - 1;
14003 return (PARSER_OK
);
14006 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14008 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
14010 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
14012 u64
*digest
= (u64
*) hash_buf
->digest
;
14014 salt_t
*salt
= hash_buf
->salt
;
14016 u8 tmp_buf
[120] = { 0 };
14018 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
14020 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
14022 memcpy (digest
, tmp_buf
, 64);
14024 digest
[0] = byte_swap_64 (digest
[0]);
14025 digest
[1] = byte_swap_64 (digest
[1]);
14026 digest
[2] = byte_swap_64 (digest
[2]);
14027 digest
[3] = byte_swap_64 (digest
[3]);
14028 digest
[4] = byte_swap_64 (digest
[4]);
14029 digest
[5] = byte_swap_64 (digest
[5]);
14030 digest
[6] = byte_swap_64 (digest
[6]);
14031 digest
[7] = byte_swap_64 (digest
[7]);
14033 digest
[0] -= SHA512M_A
;
14034 digest
[1] -= SHA512M_B
;
14035 digest
[2] -= SHA512M_C
;
14036 digest
[3] -= SHA512M_D
;
14037 digest
[4] -= SHA512M_E
;
14038 digest
[5] -= SHA512M_F
;
14039 digest
[6] -= SHA512M_G
;
14040 digest
[7] -= SHA512M_H
;
14042 int salt_len
= tmp_len
- 64;
14044 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
14046 salt
->salt_len
= salt_len
;
14048 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
14050 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
14052 char *ptr
= (char *) salt
->salt_buf
;
14054 ptr
[salt
->salt_len
] = 0x80;
14057 return (PARSER_OK
);
14060 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14062 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14064 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
14068 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
14071 u32
*digest
= (u32
*) hash_buf
->digest
;
14073 salt_t
*salt
= hash_buf
->salt
;
14075 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14076 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14077 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14078 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14080 digest
[0] = byte_swap_32 (digest
[0]);
14081 digest
[1] = byte_swap_32 (digest
[1]);
14082 digest
[2] = byte_swap_32 (digest
[2]);
14083 digest
[3] = byte_swap_32 (digest
[3]);
14085 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14087 uint salt_len
= input_len
- 32 - 1;
14089 char *salt_buf
= input_buf
+ 32 + 1;
14091 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14093 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14095 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14097 salt
->salt_len
= salt_len
;
14099 return (PARSER_OK
);
14102 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14104 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14106 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
14110 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
14113 u32
*digest
= (u32
*) hash_buf
->digest
;
14115 salt_t
*salt
= hash_buf
->salt
;
14117 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14118 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14119 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14120 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14121 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14123 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14125 uint salt_len
= input_len
- 40 - 1;
14127 char *salt_buf
= input_buf
+ 40 + 1;
14129 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14131 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14133 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14135 salt
->salt_len
= salt_len
;
14137 return (PARSER_OK
);
14140 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14142 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14144 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14148 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14151 u32
*digest
= (u32
*) hash_buf
->digest
;
14153 salt_t
*salt
= hash_buf
->salt
;
14155 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14156 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14157 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14158 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14159 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14160 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14161 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14162 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14164 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14166 uint salt_len
= input_len
- 64 - 1;
14168 char *salt_buf
= input_buf
+ 64 + 1;
14170 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14172 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14174 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14176 salt
->salt_len
= salt_len
;
14178 return (PARSER_OK
);
14181 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14183 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14185 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14189 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14192 u64
*digest
= (u64
*) hash_buf
->digest
;
14194 salt_t
*salt
= hash_buf
->salt
;
14196 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14197 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14198 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14199 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14200 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14201 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14202 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14203 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14205 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14207 uint salt_len
= input_len
- 128 - 1;
14209 char *salt_buf
= input_buf
+ 128 + 1;
14211 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14213 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14215 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14217 salt
->salt_len
= salt_len
;
14219 return (PARSER_OK
);
14222 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14224 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14226 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14228 u32
*digest
= (u32
*) hash_buf
->digest
;
14230 salt_t
*salt
= hash_buf
->salt
;
14232 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14238 char *user_pos
= input_buf
+ 10 + 1;
14240 char *realm_pos
= strchr (user_pos
, '$');
14242 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14244 uint user_len
= realm_pos
- user_pos
;
14246 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14250 char *salt_pos
= strchr (realm_pos
, '$');
14252 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14254 uint realm_len
= salt_pos
- realm_pos
;
14256 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14260 char *data_pos
= strchr (salt_pos
, '$');
14262 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14264 uint salt_len
= data_pos
- salt_pos
;
14266 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14270 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14272 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14278 memcpy (krb5pa
->user
, user_pos
, user_len
);
14279 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14280 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14282 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14284 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14286 const char p0
= data_pos
[i
+ 0];
14287 const char p1
= data_pos
[i
+ 1];
14289 *timestamp_ptr
++ = hex_convert (p1
) << 0
14290 | hex_convert (p0
) << 4;
14293 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14295 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14297 const char p0
= data_pos
[i
+ 0];
14298 const char p1
= data_pos
[i
+ 1];
14300 *checksum_ptr
++ = hex_convert (p1
) << 0
14301 | hex_convert (p0
) << 4;
14305 * copy some data to generic buffers to make sorting happy
14308 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14309 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14310 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14311 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14312 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14313 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14314 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14315 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14316 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14318 salt
->salt_len
= 36;
14320 digest
[0] = krb5pa
->checksum
[0];
14321 digest
[1] = krb5pa
->checksum
[1];
14322 digest
[2] = krb5pa
->checksum
[2];
14323 digest
[3] = krb5pa
->checksum
[3];
14325 return (PARSER_OK
);
14328 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14330 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14332 u32
*digest
= (u32
*) hash_buf
->digest
;
14334 salt_t
*salt
= hash_buf
->salt
;
14340 char *salt_pos
= input_buf
;
14342 char *hash_pos
= strchr (salt_pos
, '$');
14344 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14346 uint salt_len
= hash_pos
- salt_pos
;
14348 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14352 uint hash_len
= input_len
- 1 - salt_len
;
14354 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14362 for (uint i
= 0; i
< salt_len
; i
++)
14364 if (salt_pos
[i
] == ' ') continue;
14369 // SAP user names cannot be longer than 12 characters
14370 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14372 // SAP user name cannot start with ! or ?
14373 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14379 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14381 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14383 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14385 salt
->salt_len
= salt_len
;
14387 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14388 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14392 digest
[0] = byte_swap_32 (digest
[0]);
14393 digest
[1] = byte_swap_32 (digest
[1]);
14395 return (PARSER_OK
);
14398 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14400 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14402 u32
*digest
= (u32
*) hash_buf
->digest
;
14404 salt_t
*salt
= hash_buf
->salt
;
14410 char *salt_pos
= input_buf
;
14412 char *hash_pos
= strchr (salt_pos
, '$');
14414 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14416 uint salt_len
= hash_pos
- salt_pos
;
14418 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14422 uint hash_len
= input_len
- 1 - salt_len
;
14424 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14432 for (uint i
= 0; i
< salt_len
; i
++)
14434 if (salt_pos
[i
] == ' ') continue;
14439 // SAP user names cannot be longer than 12 characters
14440 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14441 // so far nobody complained so we stay with this because it helps in optimization
14442 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14444 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14446 // SAP user name cannot start with ! or ?
14447 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14453 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14455 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14457 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14459 salt
->salt_len
= salt_len
;
14461 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14462 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14463 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14464 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14465 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14467 return (PARSER_OK
);
14470 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14472 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14474 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14476 u64
*digest
= (u64
*) hash_buf
->digest
;
14478 salt_t
*salt
= hash_buf
->salt
;
14480 char *iter_pos
= input_buf
+ 3;
14482 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14484 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14486 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14488 salt
->salt_iter
= salt_iter
;
14490 char *salt_pos
= iter_pos
+ 1;
14494 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14496 salt
->salt_len
= salt_len
;
14498 char *hash_pos
= salt_pos
+ salt_len
;
14500 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14504 char *tmp
= (char *) salt
->salt_buf_pc
;
14506 tmp
[0] = hash_pos
[42];
14510 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14511 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14512 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14513 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14519 return (PARSER_OK
);
14522 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14524 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14526 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14528 u32
*digest
= (u32
*) hash_buf
->digest
;
14530 salt_t
*salt
= hash_buf
->salt
;
14532 char *salt_buf
= input_buf
+ 6;
14534 uint salt_len
= 16;
14536 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14538 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14540 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14542 salt
->salt_len
= salt_len
;
14544 char *hash_pos
= input_buf
+ 6 + 16;
14546 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14547 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14548 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14549 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14550 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14551 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14552 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14553 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14555 return (PARSER_OK
);
14558 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14560 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14562 u32
*digest
= (u32
*) hash_buf
->digest
;
14564 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14565 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14569 return (PARSER_OK
);
14572 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14574 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14576 u32
*digest
= (u32
*) hash_buf
->digest
;
14578 salt_t
*salt
= hash_buf
->salt
;
14580 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14582 char *saltbuf_pos
= input_buf
;
14584 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14586 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14588 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14590 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14591 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14593 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14597 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14599 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14601 char *salt_ptr
= (char *) saltbuf_pos
;
14602 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14607 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14609 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14612 rakp_ptr
[j
] = 0x80;
14614 rakp
->salt_len
= j
;
14616 for (i
= 0; i
< 64; i
++)
14618 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14621 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14622 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14623 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14624 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14625 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14626 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14627 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14628 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14630 salt
->salt_len
= 32; // muss min. 32 haben
14632 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14633 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14634 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14635 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14636 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14638 return (PARSER_OK
);
14641 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14643 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14645 u32
*digest
= (u32
*) hash_buf
->digest
;
14647 salt_t
*salt
= hash_buf
->salt
;
14649 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14651 char *salt_pos
= input_buf
+ 1;
14653 memcpy (salt
->salt_buf
, salt_pos
, 8);
14655 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14656 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14658 salt
->salt_len
= 8;
14660 char *hash_pos
= salt_pos
+ 8;
14662 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14663 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14664 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14665 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14666 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14668 digest
[0] -= SHA1M_A
;
14669 digest
[1] -= SHA1M_B
;
14670 digest
[2] -= SHA1M_C
;
14671 digest
[3] -= SHA1M_D
;
14672 digest
[4] -= SHA1M_E
;
14674 return (PARSER_OK
);
14677 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14679 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14681 u32
*digest
= (u32
*) hash_buf
->digest
;
14683 salt_t
*salt
= hash_buf
->salt
;
14685 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14686 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14687 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14688 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14690 digest
[0] = byte_swap_32 (digest
[0]);
14691 digest
[1] = byte_swap_32 (digest
[1]);
14692 digest
[2] = byte_swap_32 (digest
[2]);
14693 digest
[3] = byte_swap_32 (digest
[3]);
14695 digest
[0] -= MD5M_A
;
14696 digest
[1] -= MD5M_B
;
14697 digest
[2] -= MD5M_C
;
14698 digest
[3] -= MD5M_D
;
14700 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14702 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14704 u32
*salt_buf
= salt
->salt_buf
;
14706 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14707 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14708 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14709 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14711 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14712 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14713 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14714 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14716 salt
->salt_len
= 16 + 1;
14718 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14720 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14722 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14724 return (PARSER_OK
);
14727 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14729 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14731 u32
*digest
= (u32
*) hash_buf
->digest
;
14733 salt_t
*salt
= hash_buf
->salt
;
14735 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14741 char *hashbuf_pos
= input_buf
;
14743 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14745 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14747 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14749 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14753 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14755 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14757 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14759 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14763 char *databuf_pos
= strchr (iteration_pos
, ':');
14765 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14767 const uint iteration_len
= databuf_pos
- iteration_pos
;
14769 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14770 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14772 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14774 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14775 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14781 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14782 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14783 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14784 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14785 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14786 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14787 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14788 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14792 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14794 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14796 const char p0
= saltbuf_pos
[i
+ 0];
14797 const char p1
= saltbuf_pos
[i
+ 1];
14799 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14800 | hex_convert (p0
) << 4;
14803 salt
->salt_buf
[4] = 0x01000000;
14804 salt
->salt_buf
[5] = 0x80;
14806 salt
->salt_len
= saltbuf_len
/ 2;
14810 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14814 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14816 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14818 const char p0
= databuf_pos
[i
+ 0];
14819 const char p1
= databuf_pos
[i
+ 1];
14821 *databuf_ptr
++ = hex_convert (p1
) << 0
14822 | hex_convert (p0
) << 4;
14825 *databuf_ptr
++ = 0x80;
14827 for (uint i
= 0; i
< 512; i
++)
14829 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14832 cloudkey
->data_len
= databuf_len
/ 2;
14834 return (PARSER_OK
);
14837 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14839 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14841 u32
*digest
= (u32
*) hash_buf
->digest
;
14843 salt_t
*salt
= hash_buf
->salt
;
14849 char *hashbuf_pos
= input_buf
;
14851 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14853 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14855 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14857 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14861 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14863 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14865 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14867 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14869 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14873 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14875 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14877 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14879 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14881 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14885 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14887 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14888 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14890 // ok, the plan for this algorithm is the following:
14891 // we have 2 salts here, the domain-name and a random salt
14892 // while both are used in the initial transformation,
14893 // only the random salt is used in the following iterations
14894 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14895 // and one that includes only the real salt (stored into salt_buf[]).
14896 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14898 u8 tmp_buf
[100] = { 0 };
14900 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14902 memcpy (digest
, tmp_buf
, 20);
14904 digest
[0] = byte_swap_32 (digest
[0]);
14905 digest
[1] = byte_swap_32 (digest
[1]);
14906 digest
[2] = byte_swap_32 (digest
[2]);
14907 digest
[3] = byte_swap_32 (digest
[3]);
14908 digest
[4] = byte_swap_32 (digest
[4]);
14912 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14914 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14916 char *len_ptr
= NULL
;
14918 for (uint i
= 0; i
< domainbuf_len
; i
++)
14920 if (salt_buf_pc_ptr
[i
] == '.')
14922 len_ptr
= &salt_buf_pc_ptr
[i
];
14932 salt
->salt_buf_pc
[7] = domainbuf_len
;
14936 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14938 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14940 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14942 salt
->salt_len
= salt_len
;
14946 salt
->salt_iter
= atoi (iteration_pos
);
14948 return (PARSER_OK
);
14951 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14953 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14955 u32
*digest
= (u32
*) hash_buf
->digest
;
14957 salt_t
*salt
= hash_buf
->salt
;
14959 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14960 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14961 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14962 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14963 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14965 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14967 uint salt_len
= input_len
- 40 - 1;
14969 char *salt_buf
= input_buf
+ 40 + 1;
14971 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14973 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14975 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14977 salt
->salt_len
= salt_len
;
14979 return (PARSER_OK
);
14982 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14984 const u8 ascii_to_ebcdic
[] =
14986 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14987 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14988 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14989 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14990 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14991 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14992 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14993 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14994 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14995 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14996 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14997 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14998 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14999 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
15000 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
15001 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
15004 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
15006 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15008 u32
*digest
= (u32
*) hash_buf
->digest
;
15010 salt_t
*salt
= hash_buf
->salt
;
15012 char *salt_pos
= input_buf
+ 6 + 1;
15014 char *digest_pos
= strchr (salt_pos
, '*');
15016 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15018 uint salt_len
= digest_pos
- salt_pos
;
15020 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
15022 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
15024 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
15028 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15029 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
15031 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
15033 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15035 salt
->salt_len
= salt_len
;
15037 for (uint i
= 0; i
< salt_len
; i
++)
15039 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
15041 for (uint i
= salt_len
; i
< 8; i
++)
15043 salt_buf_pc_ptr
[i
] = 0x40;
15048 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
15050 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
15051 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
15053 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
15054 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
15056 digest
[0] = byte_swap_32 (digest
[0]);
15057 digest
[1] = byte_swap_32 (digest
[1]);
15059 IP (digest
[0], digest
[1], tt
);
15061 digest
[0] = rotr32 (digest
[0], 29);
15062 digest
[1] = rotr32 (digest
[1], 29);
15066 return (PARSER_OK
);
15069 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15071 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
15073 u32
*digest
= (u32
*) hash_buf
->digest
;
15075 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15076 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15077 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15078 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15080 digest
[0] = byte_swap_32 (digest
[0]);
15081 digest
[1] = byte_swap_32 (digest
[1]);
15082 digest
[2] = byte_swap_32 (digest
[2]);
15083 digest
[3] = byte_swap_32 (digest
[3]);
15085 return (PARSER_OK
);
15088 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15090 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
15092 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15094 u32
*digest
= (u32
*) hash_buf
->digest
;
15096 salt_t
*salt
= hash_buf
->salt
;
15098 u8 tmp_buf
[120] = { 0 };
15100 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15102 tmp_buf
[3] += -4; // dont ask!
15104 memcpy (salt
->salt_buf
, tmp_buf
, 5);
15106 salt
->salt_len
= 5;
15108 memcpy (digest
, tmp_buf
+ 5, 9);
15110 // yes, only 9 byte are needed to crack, but 10 to display
15112 salt
->salt_buf_pc
[7] = input_buf
[20];
15114 return (PARSER_OK
);
15117 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15119 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
15121 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15123 u32
*digest
= (u32
*) hash_buf
->digest
;
15125 salt_t
*salt
= hash_buf
->salt
;
15127 u8 tmp_buf
[120] = { 0 };
15129 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15131 tmp_buf
[3] += -4; // dont ask!
15135 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15137 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)
15141 char tmp_iter_buf
[11] = { 0 };
15143 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15145 tmp_iter_buf
[10] = 0;
15147 salt
->salt_iter
= atoi (tmp_iter_buf
);
15149 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15151 return (PARSER_SALT_ITERATION
);
15154 salt
->salt_iter
--; // first round in init
15156 // 2 additional bytes for display only
15158 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15159 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15163 memcpy (digest
, tmp_buf
+ 28, 8);
15165 digest
[0] = byte_swap_32 (digest
[0]);
15166 digest
[1] = byte_swap_32 (digest
[1]);
15170 return (PARSER_OK
);
15173 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15175 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15177 u32
*digest
= (u32
*) hash_buf
->digest
;
15179 salt_t
*salt
= hash_buf
->salt
;
15181 char *salt_buf_pos
= input_buf
;
15183 char *hash_buf_pos
= salt_buf_pos
+ 6;
15185 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15186 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15187 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15188 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15189 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15190 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15191 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15192 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15194 digest
[0] -= SHA256M_A
;
15195 digest
[1] -= SHA256M_B
;
15196 digest
[2] -= SHA256M_C
;
15197 digest
[3] -= SHA256M_D
;
15198 digest
[4] -= SHA256M_E
;
15199 digest
[5] -= SHA256M_F
;
15200 digest
[6] -= SHA256M_G
;
15201 digest
[7] -= SHA256M_H
;
15203 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15205 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15207 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15209 salt
->salt_len
= salt_len
;
15211 return (PARSER_OK
);
15214 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15216 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15218 u32
*digest
= (u32
*) hash_buf
->digest
;
15220 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15222 salt_t
*salt
= hash_buf
->salt
;
15224 char *salt_buf
= input_buf
+ 6;
15226 char *digest_buf
= strchr (salt_buf
, '$');
15228 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15230 uint salt_len
= digest_buf
- salt_buf
;
15232 digest_buf
++; // skip the '$' symbol
15234 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15236 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15238 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15240 salt
->salt_len
= salt_len
;
15242 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15243 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15244 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15245 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15247 digest
[0] = byte_swap_32 (digest
[0]);
15248 digest
[1] = byte_swap_32 (digest
[1]);
15249 digest
[2] = byte_swap_32 (digest
[2]);
15250 digest
[3] = byte_swap_32 (digest
[3]);
15252 digest
[0] -= MD5M_A
;
15253 digest
[1] -= MD5M_B
;
15254 digest
[2] -= MD5M_C
;
15255 digest
[3] -= MD5M_D
;
15257 return (PARSER_OK
);
15260 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15262 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15264 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15266 u32
*digest
= (u32
*) hash_buf
->digest
;
15268 salt_t
*salt
= hash_buf
->salt
;
15270 char *salt_buf
= input_buf
+ 3;
15272 char *digest_buf
= strchr (salt_buf
, '$');
15274 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15276 uint salt_len
= digest_buf
- salt_buf
;
15278 digest_buf
++; // skip the '$' symbol
15280 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15282 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15284 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15286 salt_buf_ptr
[salt_len
] = 0x2d;
15288 salt
->salt_len
= salt_len
+ 1;
15290 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15291 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15292 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15293 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15295 digest
[0] = byte_swap_32 (digest
[0]);
15296 digest
[1] = byte_swap_32 (digest
[1]);
15297 digest
[2] = byte_swap_32 (digest
[2]);
15298 digest
[3] = byte_swap_32 (digest
[3]);
15300 digest
[0] -= MD5M_A
;
15301 digest
[1] -= MD5M_B
;
15302 digest
[2] -= MD5M_C
;
15303 digest
[3] -= MD5M_D
;
15305 return (PARSER_OK
);
15308 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15310 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15312 u32
*digest
= (u32
*) hash_buf
->digest
;
15314 salt_t
*salt
= hash_buf
->salt
;
15316 u8 tmp_buf
[100] = { 0 };
15318 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15320 memcpy (digest
, tmp_buf
, 20);
15322 digest
[0] = byte_swap_32 (digest
[0]);
15323 digest
[1] = byte_swap_32 (digest
[1]);
15324 digest
[2] = byte_swap_32 (digest
[2]);
15325 digest
[3] = byte_swap_32 (digest
[3]);
15326 digest
[4] = byte_swap_32 (digest
[4]);
15328 digest
[0] -= SHA1M_A
;
15329 digest
[1] -= SHA1M_B
;
15330 digest
[2] -= SHA1M_C
;
15331 digest
[3] -= SHA1M_D
;
15332 digest
[4] -= SHA1M_E
;
15334 salt
->salt_buf
[0] = 0x80;
15336 salt
->salt_len
= 0;
15338 return (PARSER_OK
);
15341 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15343 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15345 u32
*digest
= (u32
*) hash_buf
->digest
;
15347 salt_t
*salt
= hash_buf
->salt
;
15349 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15350 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15351 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15352 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15354 digest
[0] = byte_swap_32 (digest
[0]);
15355 digest
[1] = byte_swap_32 (digest
[1]);
15356 digest
[2] = byte_swap_32 (digest
[2]);
15357 digest
[3] = byte_swap_32 (digest
[3]);
15359 digest
[0] -= MD5M_A
;
15360 digest
[1] -= MD5M_B
;
15361 digest
[2] -= MD5M_C
;
15362 digest
[3] -= MD5M_D
;
15364 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15366 uint salt_len
= input_len
- 32 - 1;
15368 char *salt_buf
= input_buf
+ 32 + 1;
15370 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15372 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15374 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15377 * add static "salt" part
15380 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15384 salt
->salt_len
= salt_len
;
15386 return (PARSER_OK
);
15389 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15391 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15393 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15395 u32
*digest
= (u32
*) hash_buf
->digest
;
15397 salt_t
*salt
= hash_buf
->salt
;
15399 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15405 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15407 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15409 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15411 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15413 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15417 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15419 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15421 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15423 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15427 char *keybuf_pos
= strchr (keylen_pos
, '$');
15429 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15431 uint keylen_len
= keybuf_pos
- keylen_pos
;
15433 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15437 char *databuf_pos
= strchr (keybuf_pos
, '$');
15439 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15441 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15443 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15447 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15449 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15455 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15456 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15457 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15458 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15460 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15461 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15462 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15463 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15465 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15466 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15467 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15468 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15470 salt
->salt_len
= 16;
15471 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15473 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15475 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15478 return (PARSER_OK
);
15481 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15483 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15485 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15487 u32
*digest
= (u32
*) hash_buf
->digest
;
15489 salt_t
*salt
= hash_buf
->salt
;
15495 // first is the N salt parameter
15497 char *N_pos
= input_buf
+ 6;
15499 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15503 salt
->scrypt_N
= atoi (N_pos
);
15507 char *r_pos
= strchr (N_pos
, ':');
15509 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15513 salt
->scrypt_r
= atoi (r_pos
);
15517 char *p_pos
= strchr (r_pos
, ':');
15519 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15523 salt
->scrypt_p
= atoi (p_pos
);
15527 char *saltbuf_pos
= strchr (p_pos
, ':');
15529 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15533 char *hash_pos
= strchr (saltbuf_pos
, ':');
15535 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15541 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15543 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15545 u8 tmp_buf
[33] = { 0 };
15547 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15549 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15551 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15553 salt
->salt_len
= tmp_len
;
15554 salt
->salt_iter
= 1;
15556 // digest - base64 decode
15558 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15560 tmp_len
= input_len
- (hash_pos
- input_buf
);
15562 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15564 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15566 memcpy (digest
, tmp_buf
, 32);
15568 return (PARSER_OK
);
15571 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15573 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15575 u32
*digest
= (u32
*) hash_buf
->digest
;
15577 salt_t
*salt
= hash_buf
->salt
;
15583 char decrypted
[76] = { 0 }; // iv + hash
15585 juniper_decrypt_hash (input_buf
, decrypted
);
15587 char *md5crypt_hash
= decrypted
+ 12;
15589 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15591 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15593 char *salt_pos
= md5crypt_hash
+ 3;
15595 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15597 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15599 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15603 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15605 return (PARSER_OK
);
15608 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15610 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15612 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15614 u32
*digest
= (u32
*) hash_buf
->digest
;
15616 salt_t
*salt
= hash_buf
->salt
;
15618 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15624 // first is *raw* salt
15626 char *salt_pos
= input_buf
+ 3;
15628 char *hash_pos
= strchr (salt_pos
, '$');
15630 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15632 uint salt_len
= hash_pos
- salt_pos
;
15634 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15638 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15640 memcpy (salt_buf_ptr
, salt_pos
, 14);
15642 salt_buf_ptr
[17] = 0x01;
15643 salt_buf_ptr
[18] = 0x80;
15645 // add some stuff to normal salt to make sorted happy
15647 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15648 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15649 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15650 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15652 salt
->salt_len
= salt_len
;
15653 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15655 // base64 decode hash
15657 u8 tmp_buf
[100] = { 0 };
15659 uint hash_len
= input_len
- 3 - salt_len
- 1;
15661 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15663 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15665 memcpy (digest
, tmp_buf
, 32);
15667 digest
[0] = byte_swap_32 (digest
[0]);
15668 digest
[1] = byte_swap_32 (digest
[1]);
15669 digest
[2] = byte_swap_32 (digest
[2]);
15670 digest
[3] = byte_swap_32 (digest
[3]);
15671 digest
[4] = byte_swap_32 (digest
[4]);
15672 digest
[5] = byte_swap_32 (digest
[5]);
15673 digest
[6] = byte_swap_32 (digest
[6]);
15674 digest
[7] = byte_swap_32 (digest
[7]);
15676 return (PARSER_OK
);
15679 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15681 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15683 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15685 u32
*digest
= (u32
*) hash_buf
->digest
;
15687 salt_t
*salt
= hash_buf
->salt
;
15693 // first is *raw* salt
15695 char *salt_pos
= input_buf
+ 3;
15697 char *hash_pos
= strchr (salt_pos
, '$');
15699 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15701 uint salt_len
= hash_pos
- salt_pos
;
15703 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15705 salt
->salt_len
= salt_len
;
15708 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15710 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15711 salt_buf_ptr
[salt_len
] = 0;
15713 // base64 decode hash
15715 u8 tmp_buf
[100] = { 0 };
15717 uint hash_len
= input_len
- 3 - salt_len
- 1;
15719 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15721 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15723 memcpy (digest
, tmp_buf
, 32);
15726 salt
->scrypt_N
= 16384;
15727 salt
->scrypt_r
= 1;
15728 salt
->scrypt_p
= 1;
15729 salt
->salt_iter
= 1;
15731 return (PARSER_OK
);
15734 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15736 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15738 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15740 u32
*digest
= (u32
*) hash_buf
->digest
;
15742 salt_t
*salt
= hash_buf
->salt
;
15744 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15750 char *version_pos
= input_buf
+ 8 + 1;
15752 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15754 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15756 u32 version_len
= verifierHashSize_pos
- version_pos
;
15758 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15760 verifierHashSize_pos
++;
15762 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15764 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15766 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15768 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15772 char *saltSize_pos
= strchr (keySize_pos
, '*');
15774 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15776 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15778 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15782 char *osalt_pos
= strchr (saltSize_pos
, '*');
15784 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15786 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15788 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15792 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15794 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15796 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15798 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15800 encryptedVerifier_pos
++;
15802 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15804 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15806 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15808 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15810 encryptedVerifierHash_pos
++;
15812 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;
15814 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15816 const uint version
= atoi (version_pos
);
15818 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15820 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15822 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15824 const uint keySize
= atoi (keySize_pos
);
15826 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15828 office2007
->keySize
= keySize
;
15830 const uint saltSize
= atoi (saltSize_pos
);
15832 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15838 salt
->salt_len
= 16;
15839 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15841 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15842 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15843 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15844 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15850 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15851 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15852 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15853 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15855 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15856 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15857 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15858 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15859 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15865 digest
[0] = office2007
->encryptedVerifierHash
[0];
15866 digest
[1] = office2007
->encryptedVerifierHash
[1];
15867 digest
[2] = office2007
->encryptedVerifierHash
[2];
15868 digest
[3] = office2007
->encryptedVerifierHash
[3];
15870 return (PARSER_OK
);
15873 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15875 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15877 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15879 u32
*digest
= (u32
*) hash_buf
->digest
;
15881 salt_t
*salt
= hash_buf
->salt
;
15883 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15889 char *version_pos
= input_buf
+ 8 + 1;
15891 char *spinCount_pos
= strchr (version_pos
, '*');
15893 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15895 u32 version_len
= spinCount_pos
- version_pos
;
15897 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15901 char *keySize_pos
= strchr (spinCount_pos
, '*');
15903 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15905 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15907 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15911 char *saltSize_pos
= strchr (keySize_pos
, '*');
15913 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15915 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15917 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15921 char *osalt_pos
= strchr (saltSize_pos
, '*');
15923 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15925 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15927 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15931 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15933 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15935 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15937 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15939 encryptedVerifier_pos
++;
15941 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15943 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15945 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15947 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15949 encryptedVerifierHash_pos
++;
15951 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;
15953 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15955 const uint version
= atoi (version_pos
);
15957 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15959 const uint spinCount
= atoi (spinCount_pos
);
15961 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15963 const uint keySize
= atoi (keySize_pos
);
15965 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15967 const uint saltSize
= atoi (saltSize_pos
);
15969 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15975 salt
->salt_len
= 16;
15976 salt
->salt_iter
= spinCount
;
15978 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15979 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15980 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15981 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15987 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15988 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15989 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15990 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15992 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15993 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15994 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15995 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15996 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15997 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15998 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15999 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16005 digest
[0] = office2010
->encryptedVerifierHash
[0];
16006 digest
[1] = office2010
->encryptedVerifierHash
[1];
16007 digest
[2] = office2010
->encryptedVerifierHash
[2];
16008 digest
[3] = office2010
->encryptedVerifierHash
[3];
16010 return (PARSER_OK
);
16013 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16015 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
16017 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
16019 u32
*digest
= (u32
*) hash_buf
->digest
;
16021 salt_t
*salt
= hash_buf
->salt
;
16023 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
16029 char *version_pos
= input_buf
+ 8 + 1;
16031 char *spinCount_pos
= strchr (version_pos
, '*');
16033 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16035 u32 version_len
= spinCount_pos
- version_pos
;
16037 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
16041 char *keySize_pos
= strchr (spinCount_pos
, '*');
16043 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16045 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
16047 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
16051 char *saltSize_pos
= strchr (keySize_pos
, '*');
16053 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16055 u32 keySize_len
= saltSize_pos
- keySize_pos
;
16057 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
16061 char *osalt_pos
= strchr (saltSize_pos
, '*');
16063 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16065 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
16067 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
16071 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16073 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16075 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16077 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16079 encryptedVerifier_pos
++;
16081 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16083 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16085 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16087 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16089 encryptedVerifierHash_pos
++;
16091 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;
16093 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
16095 const uint version
= atoi (version_pos
);
16097 if (version
!= 2013) return (PARSER_SALT_VALUE
);
16099 const uint spinCount
= atoi (spinCount_pos
);
16101 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
16103 const uint keySize
= atoi (keySize_pos
);
16105 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
16107 const uint saltSize
= atoi (saltSize_pos
);
16109 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
16115 salt
->salt_len
= 16;
16116 salt
->salt_iter
= spinCount
;
16118 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16119 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16120 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16121 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16127 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16128 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16129 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16130 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16132 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16133 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16134 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16135 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16136 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16137 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16138 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16139 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16145 digest
[0] = office2013
->encryptedVerifierHash
[0];
16146 digest
[1] = office2013
->encryptedVerifierHash
[1];
16147 digest
[2] = office2013
->encryptedVerifierHash
[2];
16148 digest
[3] = office2013
->encryptedVerifierHash
[3];
16150 return (PARSER_OK
);
16153 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16155 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16157 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16159 u32
*digest
= (u32
*) hash_buf
->digest
;
16161 salt_t
*salt
= hash_buf
->salt
;
16163 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16169 char *version_pos
= input_buf
+ 11;
16171 char *osalt_pos
= strchr (version_pos
, '*');
16173 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16175 u32 version_len
= osalt_pos
- version_pos
;
16177 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16181 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16183 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16185 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16187 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16189 encryptedVerifier_pos
++;
16191 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16193 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16195 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16197 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16199 encryptedVerifierHash_pos
++;
16201 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16203 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16205 const uint version
= *version_pos
- 0x30;
16207 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16213 oldoffice01
->version
= version
;
16215 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16216 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16217 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16218 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16220 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16221 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16222 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16223 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16225 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16226 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16227 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16228 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16230 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16231 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16232 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16233 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16239 salt
->salt_len
= 16;
16241 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16242 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16243 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16244 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16246 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16247 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16248 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16249 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16251 // this is a workaround as office produces multiple documents with the same salt
16253 salt
->salt_len
+= 32;
16255 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16256 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16257 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16258 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16259 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16260 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16261 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16262 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16268 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16269 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16270 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16271 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16273 return (PARSER_OK
);
16276 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16278 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16281 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16283 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16285 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16287 u32
*digest
= (u32
*) hash_buf
->digest
;
16289 salt_t
*salt
= hash_buf
->salt
;
16291 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16297 char *version_pos
= input_buf
+ 11;
16299 char *osalt_pos
= strchr (version_pos
, '*');
16301 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16303 u32 version_len
= osalt_pos
- version_pos
;
16305 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16309 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16311 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16313 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16315 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16317 encryptedVerifier_pos
++;
16319 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16321 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16323 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16325 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16327 encryptedVerifierHash_pos
++;
16329 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16331 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16333 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16335 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16339 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16341 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16343 const uint version
= *version_pos
- 0x30;
16345 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16351 oldoffice01
->version
= version
;
16353 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16354 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16355 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16356 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16358 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16359 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16360 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16361 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16363 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16364 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16365 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16366 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16368 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16369 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16370 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16371 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16373 oldoffice01
->rc4key
[1] = 0;
16374 oldoffice01
->rc4key
[0] = 0;
16376 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16377 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16378 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16379 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16380 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16381 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16382 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16383 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16384 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16385 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16387 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16388 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16394 salt
->salt_len
= 16;
16396 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16397 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16398 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16399 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16401 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16402 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16403 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16404 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16406 // this is a workaround as office produces multiple documents with the same salt
16408 salt
->salt_len
+= 32;
16410 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16411 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16412 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16413 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16414 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16415 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16416 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16417 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16423 digest
[0] = oldoffice01
->rc4key
[0];
16424 digest
[1] = oldoffice01
->rc4key
[1];
16428 return (PARSER_OK
);
16431 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16433 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16435 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16437 u32
*digest
= (u32
*) hash_buf
->digest
;
16439 salt_t
*salt
= hash_buf
->salt
;
16441 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16447 char *version_pos
= input_buf
+ 11;
16449 char *osalt_pos
= strchr (version_pos
, '*');
16451 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16453 u32 version_len
= osalt_pos
- version_pos
;
16455 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16459 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16461 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16463 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16465 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16467 encryptedVerifier_pos
++;
16469 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16471 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16473 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16475 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16477 encryptedVerifierHash_pos
++;
16479 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16481 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16483 const uint version
= *version_pos
- 0x30;
16485 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16491 oldoffice34
->version
= version
;
16493 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16494 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16495 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16496 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16498 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16499 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16500 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16501 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16503 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16504 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16505 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16506 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16507 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16509 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16510 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16511 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16512 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16513 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16519 salt
->salt_len
= 16;
16521 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16522 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16523 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16524 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16526 // this is a workaround as office produces multiple documents with the same salt
16528 salt
->salt_len
+= 32;
16530 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16531 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16532 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16533 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16534 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16535 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16536 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16537 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16543 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16544 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16545 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16546 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16548 return (PARSER_OK
);
16551 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16553 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16555 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16558 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16560 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16562 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16564 u32
*digest
= (u32
*) hash_buf
->digest
;
16566 salt_t
*salt
= hash_buf
->salt
;
16568 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16574 char *version_pos
= input_buf
+ 11;
16576 char *osalt_pos
= strchr (version_pos
, '*');
16578 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16580 u32 version_len
= osalt_pos
- version_pos
;
16582 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16586 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16588 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16590 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16592 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16594 encryptedVerifier_pos
++;
16596 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16598 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16600 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16602 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16604 encryptedVerifierHash_pos
++;
16606 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16608 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16610 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16612 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16616 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16618 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16620 const uint version
= *version_pos
- 0x30;
16622 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16628 oldoffice34
->version
= version
;
16630 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16631 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16632 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16633 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16635 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16636 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16637 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16638 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16640 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16641 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16642 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16643 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16644 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16646 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16647 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16648 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16649 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16650 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16652 oldoffice34
->rc4key
[1] = 0;
16653 oldoffice34
->rc4key
[0] = 0;
16655 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16656 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16657 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16658 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16659 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16660 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16661 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16662 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16663 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16664 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16666 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16667 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16673 salt
->salt_len
= 16;
16675 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16676 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16677 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16678 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16680 // this is a workaround as office produces multiple documents with the same salt
16682 salt
->salt_len
+= 32;
16684 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16685 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16686 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16687 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16688 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16689 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16690 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16691 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16697 digest
[0] = oldoffice34
->rc4key
[0];
16698 digest
[1] = oldoffice34
->rc4key
[1];
16702 return (PARSER_OK
);
16705 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16707 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16709 u32
*digest
= (u32
*) hash_buf
->digest
;
16711 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16712 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16713 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16714 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16716 digest
[0] = byte_swap_32 (digest
[0]);
16717 digest
[1] = byte_swap_32 (digest
[1]);
16718 digest
[2] = byte_swap_32 (digest
[2]);
16719 digest
[3] = byte_swap_32 (digest
[3]);
16721 return (PARSER_OK
);
16724 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16726 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16728 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16730 u32
*digest
= (u32
*) hash_buf
->digest
;
16732 salt_t
*salt
= hash_buf
->salt
;
16734 char *signature_pos
= input_buf
;
16736 char *salt_pos
= strchr (signature_pos
, '$');
16738 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16740 u32 signature_len
= salt_pos
- signature_pos
;
16742 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16746 char *hash_pos
= strchr (salt_pos
, '$');
16748 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16750 u32 salt_len
= hash_pos
- salt_pos
;
16752 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16756 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16758 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16760 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16761 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16762 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16763 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16764 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16766 digest
[0] -= SHA1M_A
;
16767 digest
[1] -= SHA1M_B
;
16768 digest
[2] -= SHA1M_C
;
16769 digest
[3] -= SHA1M_D
;
16770 digest
[4] -= SHA1M_E
;
16772 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16774 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16776 salt
->salt_len
= salt_len
;
16778 return (PARSER_OK
);
16781 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16783 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16785 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16787 u32
*digest
= (u32
*) hash_buf
->digest
;
16789 salt_t
*salt
= hash_buf
->salt
;
16791 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16797 char *iter_pos
= input_buf
+ 14;
16799 const int iter
= atoi (iter_pos
);
16801 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16803 salt
->salt_iter
= iter
- 1;
16805 char *salt_pos
= strchr (iter_pos
, '$');
16807 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16811 char *hash_pos
= strchr (salt_pos
, '$');
16813 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16815 const uint salt_len
= hash_pos
- salt_pos
;
16819 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16821 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16823 salt
->salt_len
= salt_len
;
16825 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16826 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16828 // add some stuff to normal salt to make sorted happy
16830 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16831 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16832 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16833 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16834 salt
->salt_buf
[4] = salt
->salt_iter
;
16836 // base64 decode hash
16838 u8 tmp_buf
[100] = { 0 };
16840 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16842 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16844 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16846 memcpy (digest
, tmp_buf
, 32);
16848 digest
[0] = byte_swap_32 (digest
[0]);
16849 digest
[1] = byte_swap_32 (digest
[1]);
16850 digest
[2] = byte_swap_32 (digest
[2]);
16851 digest
[3] = byte_swap_32 (digest
[3]);
16852 digest
[4] = byte_swap_32 (digest
[4]);
16853 digest
[5] = byte_swap_32 (digest
[5]);
16854 digest
[6] = byte_swap_32 (digest
[6]);
16855 digest
[7] = byte_swap_32 (digest
[7]);
16857 return (PARSER_OK
);
16860 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16862 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16864 u32
*digest
= (u32
*) hash_buf
->digest
;
16866 salt_t
*salt
= hash_buf
->salt
;
16868 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16869 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16873 digest
[0] = byte_swap_32 (digest
[0]);
16874 digest
[1] = byte_swap_32 (digest
[1]);
16876 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16877 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16878 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16880 char iter_c
= input_buf
[17];
16881 char iter_d
= input_buf
[19];
16883 // atm only defaults, let's see if there's more request
16884 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16885 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16887 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16889 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16890 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16891 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16892 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16894 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16895 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16896 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16897 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16899 salt
->salt_len
= 16;
16901 return (PARSER_OK
);
16904 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16906 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16908 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16910 u32
*digest
= (u32
*) hash_buf
->digest
;
16912 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16914 salt_t
*salt
= hash_buf
->salt
;
16916 char *salt_pos
= input_buf
+ 10;
16918 char *hash_pos
= strchr (salt_pos
, '$');
16920 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16922 uint salt_len
= hash_pos
- salt_pos
;
16926 uint hash_len
= input_len
- 10 - salt_len
- 1;
16928 // base64 decode salt
16930 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16932 u8 tmp_buf
[100] = { 0 };
16934 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16936 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16938 tmp_buf
[salt_len
] = 0x80;
16940 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16942 salt
->salt_len
= salt_len
;
16944 // base64 decode hash
16946 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16948 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16950 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16952 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16954 uint user_len
= hash_len
- 32;
16956 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16958 user_len
--; // skip the trailing space
16960 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16961 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16962 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16963 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16965 digest
[0] = byte_swap_32 (digest
[0]);
16966 digest
[1] = byte_swap_32 (digest
[1]);
16967 digest
[2] = byte_swap_32 (digest
[2]);
16968 digest
[3] = byte_swap_32 (digest
[3]);
16970 // store username for host only (output hash if cracked)
16972 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16973 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16975 return (PARSER_OK
);
16978 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16980 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16982 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16984 u32
*digest
= (u32
*) hash_buf
->digest
;
16986 salt_t
*salt
= hash_buf
->salt
;
16988 char *iter_pos
= input_buf
+ 10;
16990 u32 iter
= atoi (iter_pos
);
16994 return (PARSER_SALT_ITERATION
);
16997 iter
--; // first iteration is special
16999 salt
->salt_iter
= iter
;
17001 char *base64_pos
= strchr (iter_pos
, '}');
17003 if (base64_pos
== NULL
)
17005 return (PARSER_SIGNATURE_UNMATCHED
);
17010 // base64 decode salt
17012 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
17014 u8 tmp_buf
[100] = { 0 };
17016 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
17018 if (decoded_len
< 24)
17020 return (PARSER_SALT_LENGTH
);
17025 uint salt_len
= decoded_len
- 20;
17027 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
17028 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
17030 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
17032 salt
->salt_len
= salt_len
;
17036 u32
*digest_ptr
= (u32
*) tmp_buf
;
17038 digest
[0] = byte_swap_32 (digest_ptr
[0]);
17039 digest
[1] = byte_swap_32 (digest_ptr
[1]);
17040 digest
[2] = byte_swap_32 (digest_ptr
[2]);
17041 digest
[3] = byte_swap_32 (digest_ptr
[3]);
17042 digest
[4] = byte_swap_32 (digest_ptr
[4]);
17044 return (PARSER_OK
);
17047 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17049 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
17051 u32
*digest
= (u32
*) hash_buf
->digest
;
17053 salt_t
*salt
= hash_buf
->salt
;
17055 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17056 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17057 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17058 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17059 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
17061 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17063 uint salt_len
= input_len
- 40 - 1;
17065 char *salt_buf
= input_buf
+ 40 + 1;
17067 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17069 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17071 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
17073 salt
->salt_len
= salt_len
;
17075 return (PARSER_OK
);
17078 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17080 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
17082 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17084 u32
*digest
= (u32
*) hash_buf
->digest
;
17086 salt_t
*salt
= hash_buf
->salt
;
17088 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17094 char *V_pos
= input_buf
+ 5;
17096 char *R_pos
= strchr (V_pos
, '*');
17098 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17100 u32 V_len
= R_pos
- V_pos
;
17104 char *bits_pos
= strchr (R_pos
, '*');
17106 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17108 u32 R_len
= bits_pos
- R_pos
;
17112 char *P_pos
= strchr (bits_pos
, '*');
17114 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17116 u32 bits_len
= P_pos
- bits_pos
;
17120 char *enc_md_pos
= strchr (P_pos
, '*');
17122 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17124 u32 P_len
= enc_md_pos
- P_pos
;
17128 char *id_len_pos
= strchr (enc_md_pos
, '*');
17130 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17132 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17136 char *id_buf_pos
= strchr (id_len_pos
, '*');
17138 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17140 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17144 char *u_len_pos
= strchr (id_buf_pos
, '*');
17146 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17148 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17150 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17154 char *u_buf_pos
= strchr (u_len_pos
, '*');
17156 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17158 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17162 char *o_len_pos
= strchr (u_buf_pos
, '*');
17164 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17166 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17168 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17172 char *o_buf_pos
= strchr (o_len_pos
, '*');
17174 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17176 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17180 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;
17182 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17186 const int V
= atoi (V_pos
);
17187 const int R
= atoi (R_pos
);
17188 const int P
= atoi (P_pos
);
17190 if (V
!= 1) return (PARSER_SALT_VALUE
);
17191 if (R
!= 2) return (PARSER_SALT_VALUE
);
17193 const int enc_md
= atoi (enc_md_pos
);
17195 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17197 const int id_len
= atoi (id_len_pos
);
17198 const int u_len
= atoi (u_len_pos
);
17199 const int o_len
= atoi (o_len_pos
);
17201 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17202 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17203 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17205 const int bits
= atoi (bits_pos
);
17207 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17209 // copy data to esalt
17215 pdf
->enc_md
= enc_md
;
17217 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17218 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17219 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17220 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17221 pdf
->id_len
= id_len
;
17223 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17224 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17225 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17226 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17227 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17228 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17229 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17230 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17231 pdf
->u_len
= u_len
;
17233 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17234 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17235 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17236 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17237 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17238 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17239 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17240 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17241 pdf
->o_len
= o_len
;
17243 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17244 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17245 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17246 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17248 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17249 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17250 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17251 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17252 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17253 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17254 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17255 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17257 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17258 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17259 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17260 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17261 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17262 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17263 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17264 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17266 // we use ID for salt, maybe needs to change, we will see...
17268 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17269 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17270 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17271 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17272 salt
->salt_len
= pdf
->id_len
;
17274 digest
[0] = pdf
->u_buf
[0];
17275 digest
[1] = pdf
->u_buf
[1];
17276 digest
[2] = pdf
->u_buf
[2];
17277 digest
[3] = pdf
->u_buf
[3];
17279 return (PARSER_OK
);
17282 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17284 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17287 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17289 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17291 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17293 u32
*digest
= (u32
*) hash_buf
->digest
;
17295 salt_t
*salt
= hash_buf
->salt
;
17297 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17303 char *V_pos
= input_buf
+ 5;
17305 char *R_pos
= strchr (V_pos
, '*');
17307 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17309 u32 V_len
= R_pos
- V_pos
;
17313 char *bits_pos
= strchr (R_pos
, '*');
17315 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17317 u32 R_len
= bits_pos
- R_pos
;
17321 char *P_pos
= strchr (bits_pos
, '*');
17323 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17325 u32 bits_len
= P_pos
- bits_pos
;
17329 char *enc_md_pos
= strchr (P_pos
, '*');
17331 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17333 u32 P_len
= enc_md_pos
- P_pos
;
17337 char *id_len_pos
= strchr (enc_md_pos
, '*');
17339 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17341 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17345 char *id_buf_pos
= strchr (id_len_pos
, '*');
17347 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17349 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17353 char *u_len_pos
= strchr (id_buf_pos
, '*');
17355 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17357 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17359 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17363 char *u_buf_pos
= strchr (u_len_pos
, '*');
17365 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17367 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17371 char *o_len_pos
= strchr (u_buf_pos
, '*');
17373 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17375 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17377 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17381 char *o_buf_pos
= strchr (o_len_pos
, '*');
17383 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17385 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17389 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17391 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17393 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17395 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17399 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;
17401 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17405 const int V
= atoi (V_pos
);
17406 const int R
= atoi (R_pos
);
17407 const int P
= atoi (P_pos
);
17409 if (V
!= 1) return (PARSER_SALT_VALUE
);
17410 if (R
!= 2) return (PARSER_SALT_VALUE
);
17412 const int enc_md
= atoi (enc_md_pos
);
17414 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17416 const int id_len
= atoi (id_len_pos
);
17417 const int u_len
= atoi (u_len_pos
);
17418 const int o_len
= atoi (o_len_pos
);
17420 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17421 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17422 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17424 const int bits
= atoi (bits_pos
);
17426 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17428 // copy data to esalt
17434 pdf
->enc_md
= enc_md
;
17436 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17437 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17438 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17439 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17440 pdf
->id_len
= id_len
;
17442 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17443 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17444 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17445 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17446 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17447 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17448 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17449 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17450 pdf
->u_len
= u_len
;
17452 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17453 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17454 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17455 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17456 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17457 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17458 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17459 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17460 pdf
->o_len
= o_len
;
17462 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17463 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17464 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17465 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17467 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17468 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17469 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17470 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17471 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17472 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17473 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17474 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17476 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17477 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17478 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17479 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17480 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17481 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17482 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17483 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17485 pdf
->rc4key
[1] = 0;
17486 pdf
->rc4key
[0] = 0;
17488 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17489 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17490 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17491 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17492 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17493 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17494 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17495 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17496 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17497 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17499 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17500 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17502 // we use ID for salt, maybe needs to change, we will see...
17504 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17505 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17506 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17507 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17508 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17509 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17510 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17511 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17512 salt
->salt_len
= pdf
->id_len
+ 16;
17514 digest
[0] = pdf
->rc4key
[0];
17515 digest
[1] = pdf
->rc4key
[1];
17519 return (PARSER_OK
);
17522 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17524 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17526 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17528 u32
*digest
= (u32
*) hash_buf
->digest
;
17530 salt_t
*salt
= hash_buf
->salt
;
17532 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17538 char *V_pos
= input_buf
+ 5;
17540 char *R_pos
= strchr (V_pos
, '*');
17542 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17544 u32 V_len
= R_pos
- V_pos
;
17548 char *bits_pos
= strchr (R_pos
, '*');
17550 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17552 u32 R_len
= bits_pos
- R_pos
;
17556 char *P_pos
= strchr (bits_pos
, '*');
17558 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17560 u32 bits_len
= P_pos
- bits_pos
;
17564 char *enc_md_pos
= strchr (P_pos
, '*');
17566 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17568 u32 P_len
= enc_md_pos
- P_pos
;
17572 char *id_len_pos
= strchr (enc_md_pos
, '*');
17574 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17576 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17580 char *id_buf_pos
= strchr (id_len_pos
, '*');
17582 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17584 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17588 char *u_len_pos
= strchr (id_buf_pos
, '*');
17590 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17592 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17594 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17598 char *u_buf_pos
= strchr (u_len_pos
, '*');
17600 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17602 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17606 char *o_len_pos
= strchr (u_buf_pos
, '*');
17608 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17610 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17612 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17616 char *o_buf_pos
= strchr (o_len_pos
, '*');
17618 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17620 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17624 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;
17626 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17630 const int V
= atoi (V_pos
);
17631 const int R
= atoi (R_pos
);
17632 const int P
= atoi (P_pos
);
17636 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17637 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17639 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17641 const int id_len
= atoi (id_len_pos
);
17642 const int u_len
= atoi (u_len_pos
);
17643 const int o_len
= atoi (o_len_pos
);
17645 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17647 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17648 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17650 const int bits
= atoi (bits_pos
);
17652 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17658 enc_md
= atoi (enc_md_pos
);
17661 // copy data to esalt
17667 pdf
->enc_md
= enc_md
;
17669 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17670 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17671 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17672 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17676 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17677 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17678 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17679 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17682 pdf
->id_len
= id_len
;
17684 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17685 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17686 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17687 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17688 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17689 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17690 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17691 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17692 pdf
->u_len
= u_len
;
17694 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17695 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17696 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17697 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17698 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17699 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17700 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17701 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17702 pdf
->o_len
= o_len
;
17704 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17705 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17706 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17707 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17711 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17712 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17713 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17714 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17717 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17718 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17719 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17720 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17721 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17722 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17723 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17724 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17726 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17727 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17728 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17729 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17730 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17731 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17732 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17733 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17735 // precompute rc4 data for later use
17751 uint salt_pc_block
[32] = { 0 };
17753 char *salt_pc_ptr
= (char *) salt_pc_block
;
17755 memcpy (salt_pc_ptr
, padding
, 32);
17756 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17758 uint salt_pc_digest
[4] = { 0 };
17760 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17762 pdf
->rc4data
[0] = salt_pc_digest
[0];
17763 pdf
->rc4data
[1] = salt_pc_digest
[1];
17765 // we use ID for salt, maybe needs to change, we will see...
17767 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17768 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17769 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17770 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17771 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17772 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17773 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17774 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17775 salt
->salt_len
= pdf
->id_len
+ 16;
17777 salt
->salt_iter
= ROUNDS_PDF14
;
17779 digest
[0] = pdf
->u_buf
[0];
17780 digest
[1] = pdf
->u_buf
[1];
17784 return (PARSER_OK
);
17787 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17789 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17791 if (ret
!= PARSER_OK
)
17796 u32
*digest
= (u32
*) hash_buf
->digest
;
17798 salt_t
*salt
= hash_buf
->salt
;
17800 digest
[0] -= SHA256M_A
;
17801 digest
[1] -= SHA256M_B
;
17802 digest
[2] -= SHA256M_C
;
17803 digest
[3] -= SHA256M_D
;
17804 digest
[4] -= SHA256M_E
;
17805 digest
[5] -= SHA256M_F
;
17806 digest
[6] -= SHA256M_G
;
17807 digest
[7] -= SHA256M_H
;
17809 salt
->salt_buf
[2] = 0x80;
17811 return (PARSER_OK
);
17814 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17816 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17818 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17820 u32
*digest
= (u32
*) hash_buf
->digest
;
17822 salt_t
*salt
= hash_buf
->salt
;
17824 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17830 char *V_pos
= input_buf
+ 5;
17832 char *R_pos
= strchr (V_pos
, '*');
17834 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17836 u32 V_len
= R_pos
- V_pos
;
17840 char *bits_pos
= strchr (R_pos
, '*');
17842 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17844 u32 R_len
= bits_pos
- R_pos
;
17848 char *P_pos
= strchr (bits_pos
, '*');
17850 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17852 u32 bits_len
= P_pos
- bits_pos
;
17856 char *enc_md_pos
= strchr (P_pos
, '*');
17858 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17860 u32 P_len
= enc_md_pos
- P_pos
;
17864 char *id_len_pos
= strchr (enc_md_pos
, '*');
17866 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17868 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17872 char *id_buf_pos
= strchr (id_len_pos
, '*');
17874 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17876 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17880 char *u_len_pos
= strchr (id_buf_pos
, '*');
17882 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17884 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17888 char *u_buf_pos
= strchr (u_len_pos
, '*');
17890 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17892 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17896 char *o_len_pos
= strchr (u_buf_pos
, '*');
17898 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17900 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17904 char *o_buf_pos
= strchr (o_len_pos
, '*');
17906 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17908 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17912 char *last
= strchr (o_buf_pos
, '*');
17914 if (last
== NULL
) last
= input_buf
+ input_len
;
17916 u32 o_buf_len
= last
- o_buf_pos
;
17920 const int V
= atoi (V_pos
);
17921 const int R
= atoi (R_pos
);
17925 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17926 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17928 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17930 const int bits
= atoi (bits_pos
);
17932 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17934 int enc_md
= atoi (enc_md_pos
);
17936 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17938 const uint id_len
= atoi (id_len_pos
);
17939 const uint u_len
= atoi (u_len_pos
);
17940 const uint o_len
= atoi (o_len_pos
);
17942 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17943 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17944 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17945 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17946 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17947 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17948 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17949 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17951 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17952 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17953 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17955 // copy data to esalt
17957 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17959 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17961 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17964 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17965 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17967 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17968 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17970 salt
->salt_len
= 8;
17971 salt
->salt_iter
= ROUNDS_PDF17L8
;
17973 digest
[0] = pdf
->u_buf
[0];
17974 digest
[1] = pdf
->u_buf
[1];
17975 digest
[2] = pdf
->u_buf
[2];
17976 digest
[3] = pdf
->u_buf
[3];
17977 digest
[4] = pdf
->u_buf
[4];
17978 digest
[5] = pdf
->u_buf
[5];
17979 digest
[6] = pdf
->u_buf
[6];
17980 digest
[7] = pdf
->u_buf
[7];
17982 return (PARSER_OK
);
17985 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17987 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17989 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17991 u32
*digest
= (u32
*) hash_buf
->digest
;
17993 salt_t
*salt
= hash_buf
->salt
;
17995 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
18003 char *iter_pos
= input_buf
+ 7;
18005 u32 iter
= atoi (iter_pos
);
18007 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18008 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18010 // first is *raw* salt
18012 char *salt_pos
= strchr (iter_pos
, ':');
18014 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18018 char *hash_pos
= strchr (salt_pos
, ':');
18020 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18022 u32 salt_len
= hash_pos
- salt_pos
;
18024 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18028 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18030 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18034 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
18036 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18038 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18040 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18041 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18043 salt
->salt_len
= salt_len
;
18044 salt
->salt_iter
= iter
- 1;
18048 u8 tmp_buf
[100] = { 0 };
18050 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18052 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18054 memcpy (digest
, tmp_buf
, 16);
18056 digest
[0] = byte_swap_32 (digest
[0]);
18057 digest
[1] = byte_swap_32 (digest
[1]);
18058 digest
[2] = byte_swap_32 (digest
[2]);
18059 digest
[3] = byte_swap_32 (digest
[3]);
18061 // add some stuff to normal salt to make sorted happy
18063 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
18064 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
18065 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
18066 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
18067 salt
->salt_buf
[4] = salt
->salt_iter
;
18069 return (PARSER_OK
);
18072 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18074 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
18076 u32
*digest
= (u32
*) hash_buf
->digest
;
18078 salt_t
*salt
= hash_buf
->salt
;
18080 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18081 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18082 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18083 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18085 digest
[0] = byte_swap_32 (digest
[0]);
18086 digest
[1] = byte_swap_32 (digest
[1]);
18087 digest
[2] = byte_swap_32 (digest
[2]);
18088 digest
[3] = byte_swap_32 (digest
[3]);
18090 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18092 uint salt_len
= input_len
- 32 - 1;
18094 char *salt_buf
= input_buf
+ 32 + 1;
18096 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18098 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18100 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18102 salt
->salt_len
= salt_len
;
18104 return (PARSER_OK
);
18107 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18109 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
18111 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18113 u32
*digest
= (u32
*) hash_buf
->digest
;
18115 salt_t
*salt
= hash_buf
->salt
;
18117 char *user_pos
= input_buf
+ 10;
18119 char *salt_pos
= strchr (user_pos
, '*');
18121 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18125 char *hash_pos
= strchr (salt_pos
, '*');
18129 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18131 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18133 uint user_len
= salt_pos
- user_pos
- 1;
18135 uint salt_len
= hash_pos
- salt_pos
- 1;
18137 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18143 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18144 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18145 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18146 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18148 digest
[0] = byte_swap_32 (digest
[0]);
18149 digest
[1] = byte_swap_32 (digest
[1]);
18150 digest
[2] = byte_swap_32 (digest
[2]);
18151 digest
[3] = byte_swap_32 (digest
[3]);
18153 digest
[0] -= MD5M_A
;
18154 digest
[1] -= MD5M_B
;
18155 digest
[2] -= MD5M_C
;
18156 digest
[3] -= MD5M_D
;
18162 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18164 // first 4 bytes are the "challenge"
18166 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18167 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18168 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18169 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18171 // append the user name
18173 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18175 salt
->salt_len
= 4 + user_len
;
18177 return (PARSER_OK
);
18180 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18182 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18184 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18186 u32
*digest
= (u32
*) hash_buf
->digest
;
18188 salt_t
*salt
= hash_buf
->salt
;
18190 char *salt_pos
= input_buf
+ 9;
18192 char *hash_pos
= strchr (salt_pos
, '*');
18194 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18198 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18200 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18202 uint salt_len
= hash_pos
- salt_pos
- 1;
18204 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18210 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18211 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18212 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18213 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18214 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18220 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18222 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18224 salt
->salt_len
= salt_len
;
18226 return (PARSER_OK
);
18229 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18231 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18233 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18235 u32
*digest
= (u32
*) hash_buf
->digest
;
18237 salt_t
*salt
= hash_buf
->salt
;
18239 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18245 char *cry_master_len_pos
= input_buf
+ 9;
18247 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18249 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18251 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18253 cry_master_buf_pos
++;
18255 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18257 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18259 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18261 cry_salt_len_pos
++;
18263 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18265 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18267 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18269 cry_salt_buf_pos
++;
18271 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18273 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18275 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18279 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18281 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18283 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18287 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18289 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18291 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18295 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18297 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18299 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18301 public_key_len_pos
++;
18303 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18305 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18307 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18309 public_key_buf_pos
++;
18311 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;
18313 const uint cry_master_len
= atoi (cry_master_len_pos
);
18314 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18315 const uint ckey_len
= atoi (ckey_len_pos
);
18316 const uint public_key_len
= atoi (public_key_len_pos
);
18318 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18319 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18320 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18321 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18323 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18325 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18327 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18330 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18332 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18334 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18337 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18339 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18341 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18344 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18345 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18346 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18349 * store digest (should be unique enought, hopefully)
18352 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18353 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18354 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18355 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18361 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18363 const uint cry_rounds
= atoi (cry_rounds_pos
);
18365 salt
->salt_iter
= cry_rounds
- 1;
18367 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18369 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18371 salt
->salt_len
= salt_len
;
18373 return (PARSER_OK
);
18376 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18378 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18380 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18382 u32
*digest
= (u32
*) hash_buf
->digest
;
18384 salt_t
*salt
= hash_buf
->salt
;
18386 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18388 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18390 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18392 memcpy (temp_input_buf
, input_buf
, input_len
);
18396 char *URI_server_pos
= temp_input_buf
+ 6;
18398 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18400 if (URI_client_pos
== NULL
)
18402 myfree (temp_input_buf
);
18404 return (PARSER_SEPARATOR_UNMATCHED
);
18407 URI_client_pos
[0] = 0;
18410 uint URI_server_len
= strlen (URI_server_pos
);
18412 if (URI_server_len
> 512)
18414 myfree (temp_input_buf
);
18416 return (PARSER_SALT_LENGTH
);
18421 char *user_pos
= strchr (URI_client_pos
, '*');
18423 if (user_pos
== NULL
)
18425 myfree (temp_input_buf
);
18427 return (PARSER_SEPARATOR_UNMATCHED
);
18433 uint URI_client_len
= strlen (URI_client_pos
);
18435 if (URI_client_len
> 512)
18437 myfree (temp_input_buf
);
18439 return (PARSER_SALT_LENGTH
);
18444 char *realm_pos
= strchr (user_pos
, '*');
18446 if (realm_pos
== NULL
)
18448 myfree (temp_input_buf
);
18450 return (PARSER_SEPARATOR_UNMATCHED
);
18456 uint user_len
= strlen (user_pos
);
18458 if (user_len
> 116)
18460 myfree (temp_input_buf
);
18462 return (PARSER_SALT_LENGTH
);
18467 char *method_pos
= strchr (realm_pos
, '*');
18469 if (method_pos
== NULL
)
18471 myfree (temp_input_buf
);
18473 return (PARSER_SEPARATOR_UNMATCHED
);
18479 uint realm_len
= strlen (realm_pos
);
18481 if (realm_len
> 116)
18483 myfree (temp_input_buf
);
18485 return (PARSER_SALT_LENGTH
);
18490 char *URI_prefix_pos
= strchr (method_pos
, '*');
18492 if (URI_prefix_pos
== NULL
)
18494 myfree (temp_input_buf
);
18496 return (PARSER_SEPARATOR_UNMATCHED
);
18499 URI_prefix_pos
[0] = 0;
18502 uint method_len
= strlen (method_pos
);
18504 if (method_len
> 246)
18506 myfree (temp_input_buf
);
18508 return (PARSER_SALT_LENGTH
);
18513 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18515 if (URI_resource_pos
== NULL
)
18517 myfree (temp_input_buf
);
18519 return (PARSER_SEPARATOR_UNMATCHED
);
18522 URI_resource_pos
[0] = 0;
18523 URI_resource_pos
++;
18525 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18527 if (URI_prefix_len
> 245)
18529 myfree (temp_input_buf
);
18531 return (PARSER_SALT_LENGTH
);
18536 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18538 if (URI_suffix_pos
== NULL
)
18540 myfree (temp_input_buf
);
18542 return (PARSER_SEPARATOR_UNMATCHED
);
18545 URI_suffix_pos
[0] = 0;
18548 uint URI_resource_len
= strlen (URI_resource_pos
);
18550 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18552 myfree (temp_input_buf
);
18554 return (PARSER_SALT_LENGTH
);
18559 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18561 if (nonce_pos
== NULL
)
18563 myfree (temp_input_buf
);
18565 return (PARSER_SEPARATOR_UNMATCHED
);
18571 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18573 if (URI_suffix_len
> 245)
18575 myfree (temp_input_buf
);
18577 return (PARSER_SALT_LENGTH
);
18582 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18584 if (nonce_client_pos
== NULL
)
18586 myfree (temp_input_buf
);
18588 return (PARSER_SEPARATOR_UNMATCHED
);
18591 nonce_client_pos
[0] = 0;
18592 nonce_client_pos
++;
18594 uint nonce_len
= strlen (nonce_pos
);
18596 if (nonce_len
< 1 || nonce_len
> 50)
18598 myfree (temp_input_buf
);
18600 return (PARSER_SALT_LENGTH
);
18605 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18607 if (nonce_count_pos
== NULL
)
18609 myfree (temp_input_buf
);
18611 return (PARSER_SEPARATOR_UNMATCHED
);
18614 nonce_count_pos
[0] = 0;
18617 uint nonce_client_len
= strlen (nonce_client_pos
);
18619 if (nonce_client_len
> 50)
18621 myfree (temp_input_buf
);
18623 return (PARSER_SALT_LENGTH
);
18628 char *qop_pos
= strchr (nonce_count_pos
, '*');
18630 if (qop_pos
== NULL
)
18632 myfree (temp_input_buf
);
18634 return (PARSER_SEPARATOR_UNMATCHED
);
18640 uint nonce_count_len
= strlen (nonce_count_pos
);
18642 if (nonce_count_len
> 50)
18644 myfree (temp_input_buf
);
18646 return (PARSER_SALT_LENGTH
);
18651 char *directive_pos
= strchr (qop_pos
, '*');
18653 if (directive_pos
== NULL
)
18655 myfree (temp_input_buf
);
18657 return (PARSER_SEPARATOR_UNMATCHED
);
18660 directive_pos
[0] = 0;
18663 uint qop_len
= strlen (qop_pos
);
18667 myfree (temp_input_buf
);
18669 return (PARSER_SALT_LENGTH
);
18674 char *digest_pos
= strchr (directive_pos
, '*');
18676 if (digest_pos
== NULL
)
18678 myfree (temp_input_buf
);
18680 return (PARSER_SEPARATOR_UNMATCHED
);
18686 uint directive_len
= strlen (directive_pos
);
18688 if (directive_len
!= 3)
18690 myfree (temp_input_buf
);
18692 return (PARSER_SALT_LENGTH
);
18695 if (memcmp (directive_pos
, "MD5", 3))
18697 log_info ("ERROR: Only the MD5 directive is currently supported\n");
18699 myfree (temp_input_buf
);
18701 return (PARSER_SIP_AUTH_DIRECTIVE
);
18705 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18710 uint md5_max_len
= 4 * 64;
18712 uint md5_remaining_len
= md5_max_len
;
18714 uint tmp_md5_buf
[64] = { 0 };
18716 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18718 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18720 md5_len
+= method_len
+ 1;
18721 tmp_md5_ptr
+= method_len
+ 1;
18723 if (URI_prefix_len
> 0)
18725 md5_remaining_len
= md5_max_len
- md5_len
;
18727 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18729 md5_len
+= URI_prefix_len
+ 1;
18730 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18733 md5_remaining_len
= md5_max_len
- md5_len
;
18735 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18737 md5_len
+= URI_resource_len
;
18738 tmp_md5_ptr
+= URI_resource_len
;
18740 if (URI_suffix_len
> 0)
18742 md5_remaining_len
= md5_max_len
- md5_len
;
18744 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18746 md5_len
+= 1 + URI_suffix_len
;
18749 uint tmp_digest
[4] = { 0 };
18751 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18753 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18754 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18755 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18756 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18762 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18764 uint esalt_len
= 0;
18766 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18768 // there are 2 possibilities for the esalt:
18770 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18772 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18774 if (esalt_len
> max_esalt_len
)
18776 myfree (temp_input_buf
);
18778 return (PARSER_SALT_LENGTH
);
18781 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18793 esalt_len
= 1 + nonce_len
+ 1 + 32;
18795 if (esalt_len
> max_esalt_len
)
18797 myfree (temp_input_buf
);
18799 return (PARSER_SALT_LENGTH
);
18802 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18810 // add 0x80 to esalt
18812 esalt_buf_ptr
[esalt_len
] = 0x80;
18814 sip
->esalt_len
= esalt_len
;
18820 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18822 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18824 uint max_salt_len
= 119;
18826 if (salt_len
> max_salt_len
)
18828 myfree (temp_input_buf
);
18830 return (PARSER_SALT_LENGTH
);
18833 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18835 sip
->salt_len
= salt_len
;
18838 * fake salt (for sorting)
18841 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18845 uint fake_salt_len
= salt_len
;
18847 if (fake_salt_len
> max_salt_len
)
18849 fake_salt_len
= max_salt_len
;
18852 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18854 salt
->salt_len
= fake_salt_len
;
18860 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18861 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18862 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18863 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18865 digest
[0] = byte_swap_32 (digest
[0]);
18866 digest
[1] = byte_swap_32 (digest
[1]);
18867 digest
[2] = byte_swap_32 (digest
[2]);
18868 digest
[3] = byte_swap_32 (digest
[3]);
18870 myfree (temp_input_buf
);
18872 return (PARSER_OK
);
18875 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18877 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18879 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18881 u32
*digest
= (u32
*) hash_buf
->digest
;
18883 salt_t
*salt
= hash_buf
->salt
;
18887 char *digest_pos
= input_buf
;
18889 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18896 char *salt_buf
= input_buf
+ 8 + 1;
18900 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18902 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18904 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18906 salt
->salt_len
= salt_len
;
18908 return (PARSER_OK
);
18911 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18913 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18915 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18917 u32
*digest
= (u32
*) hash_buf
->digest
;
18919 salt_t
*salt
= hash_buf
->salt
;
18921 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18927 char *p_buf_pos
= input_buf
+ 4;
18929 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18931 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18933 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18935 NumCyclesPower_pos
++;
18937 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18939 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18941 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18945 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18947 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18949 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18953 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18955 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18957 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18961 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18963 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18965 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18969 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18971 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18973 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18977 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18979 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18981 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18985 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18987 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18989 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18993 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18995 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18997 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
19001 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;
19003 const uint iter
= atoi (NumCyclesPower_pos
);
19004 const uint crc
= atoi (crc_buf_pos
);
19005 const uint p_buf
= atoi (p_buf_pos
);
19006 const uint salt_len
= atoi (salt_len_pos
);
19007 const uint iv_len
= atoi (iv_len_pos
);
19008 const uint unpack_size
= atoi (unpack_size_pos
);
19009 const uint data_len
= atoi (data_len_pos
);
19015 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
19016 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
19018 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
19020 if (data_len
> 384) return (PARSER_SALT_VALUE
);
19022 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
19028 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
19029 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
19030 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
19031 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
19033 seven_zip
->iv_len
= iv_len
;
19035 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
19037 seven_zip
->salt_len
= 0;
19039 seven_zip
->crc
= crc
;
19041 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
19043 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
19045 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
19048 seven_zip
->data_len
= data_len
;
19050 seven_zip
->unpack_size
= unpack_size
;
19054 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
19055 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
19056 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
19057 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
19059 salt
->salt_len
= 16;
19061 salt
->salt_sign
[0] = iter
;
19063 salt
->salt_iter
= 1 << iter
;
19074 return (PARSER_OK
);
19077 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19079 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
19081 u32
*digest
= (u32
*) hash_buf
->digest
;
19083 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19084 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19085 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19086 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19087 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19088 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19089 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19090 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19092 digest
[0] = byte_swap_32 (digest
[0]);
19093 digest
[1] = byte_swap_32 (digest
[1]);
19094 digest
[2] = byte_swap_32 (digest
[2]);
19095 digest
[3] = byte_swap_32 (digest
[3]);
19096 digest
[4] = byte_swap_32 (digest
[4]);
19097 digest
[5] = byte_swap_32 (digest
[5]);
19098 digest
[6] = byte_swap_32 (digest
[6]);
19099 digest
[7] = byte_swap_32 (digest
[7]);
19101 return (PARSER_OK
);
19104 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19106 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
19108 u32
*digest
= (u32
*) hash_buf
->digest
;
19110 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19111 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19112 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
19113 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
19114 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
19115 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
19116 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
19117 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
19118 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
19119 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
19120 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
19121 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
19122 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
19123 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
19124 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
19125 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
19127 digest
[ 0] = byte_swap_32 (digest
[ 0]);
19128 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19129 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19130 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19131 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19132 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19133 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19134 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19135 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19136 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19137 digest
[10] = byte_swap_32 (digest
[10]);
19138 digest
[11] = byte_swap_32 (digest
[11]);
19139 digest
[12] = byte_swap_32 (digest
[12]);
19140 digest
[13] = byte_swap_32 (digest
[13]);
19141 digest
[14] = byte_swap_32 (digest
[14]);
19142 digest
[15] = byte_swap_32 (digest
[15]);
19144 return (PARSER_OK
);
19147 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19149 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19151 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19153 u32
*digest
= (u32
*) hash_buf
->digest
;
19155 salt_t
*salt
= hash_buf
->salt
;
19157 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19165 char *iter_pos
= input_buf
+ 4;
19167 u32 iter
= atoi (iter_pos
);
19169 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19170 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19172 // first is *raw* salt
19174 char *salt_pos
= strchr (iter_pos
, ':');
19176 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19180 char *hash_pos
= strchr (salt_pos
, ':');
19182 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19184 u32 salt_len
= hash_pos
- salt_pos
;
19186 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19190 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19192 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19196 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19198 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19200 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19202 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19203 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19205 salt
->salt_len
= salt_len
;
19206 salt
->salt_iter
= iter
- 1;
19210 u8 tmp_buf
[100] = { 0 };
19212 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19214 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19216 memcpy (digest
, tmp_buf
, 16);
19218 // add some stuff to normal salt to make sorted happy
19220 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19221 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19222 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19223 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19224 salt
->salt_buf
[4] = salt
->salt_iter
;
19226 return (PARSER_OK
);
19229 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19231 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19233 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19235 u32
*digest
= (u32
*) hash_buf
->digest
;
19237 salt_t
*salt
= hash_buf
->salt
;
19239 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19247 char *iter_pos
= input_buf
+ 5;
19249 u32 iter
= atoi (iter_pos
);
19251 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19252 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19254 // first is *raw* salt
19256 char *salt_pos
= strchr (iter_pos
, ':');
19258 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19262 char *hash_pos
= strchr (salt_pos
, ':');
19264 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19266 u32 salt_len
= hash_pos
- salt_pos
;
19268 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19272 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19274 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19278 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19280 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19282 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19284 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19285 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19287 salt
->salt_len
= salt_len
;
19288 salt
->salt_iter
= iter
- 1;
19292 u8 tmp_buf
[100] = { 0 };
19294 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19296 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19298 memcpy (digest
, tmp_buf
, 16);
19300 digest
[0] = byte_swap_32 (digest
[0]);
19301 digest
[1] = byte_swap_32 (digest
[1]);
19302 digest
[2] = byte_swap_32 (digest
[2]);
19303 digest
[3] = byte_swap_32 (digest
[3]);
19305 // add some stuff to normal salt to make sorted happy
19307 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19308 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19309 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19310 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19311 salt
->salt_buf
[4] = salt
->salt_iter
;
19313 return (PARSER_OK
);
19316 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19318 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19320 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19322 u64
*digest
= (u64
*) hash_buf
->digest
;
19324 salt_t
*salt
= hash_buf
->salt
;
19326 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19334 char *iter_pos
= input_buf
+ 7;
19336 u32 iter
= atoi (iter_pos
);
19338 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19339 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19341 // first is *raw* salt
19343 char *salt_pos
= strchr (iter_pos
, ':');
19345 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19349 char *hash_pos
= strchr (salt_pos
, ':');
19351 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19353 u32 salt_len
= hash_pos
- salt_pos
;
19355 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19359 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19361 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19365 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19367 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19369 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19371 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19372 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19374 salt
->salt_len
= salt_len
;
19375 salt
->salt_iter
= iter
- 1;
19379 u8 tmp_buf
[100] = { 0 };
19381 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19383 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19385 memcpy (digest
, tmp_buf
, 64);
19387 digest
[0] = byte_swap_64 (digest
[0]);
19388 digest
[1] = byte_swap_64 (digest
[1]);
19389 digest
[2] = byte_swap_64 (digest
[2]);
19390 digest
[3] = byte_swap_64 (digest
[3]);
19391 digest
[4] = byte_swap_64 (digest
[4]);
19392 digest
[5] = byte_swap_64 (digest
[5]);
19393 digest
[6] = byte_swap_64 (digest
[6]);
19394 digest
[7] = byte_swap_64 (digest
[7]);
19396 // add some stuff to normal salt to make sorted happy
19398 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19399 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19400 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19401 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19402 salt
->salt_buf
[4] = salt
->salt_iter
;
19404 return (PARSER_OK
);
19407 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19409 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19411 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19413 uint
*digest
= (uint
*) hash_buf
->digest
;
19415 salt_t
*salt
= hash_buf
->salt
;
19421 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19423 char *hash_pos
= strchr (salt_pos
, '$');
19425 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19427 u32 salt_len
= hash_pos
- salt_pos
;
19429 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19433 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19435 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19439 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19440 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19458 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19459 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19461 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19462 salt
->salt_len
= 8;
19464 return (PARSER_OK
);
19467 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19469 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19471 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19473 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19475 if (c19
& 3) return (PARSER_HASH_VALUE
);
19477 salt_t
*salt
= hash_buf
->salt
;
19479 u32
*digest
= (u32
*) hash_buf
->digest
;
19483 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19484 | itoa64_to_int (input_buf
[2]) << 6
19485 | itoa64_to_int (input_buf
[3]) << 12
19486 | itoa64_to_int (input_buf
[4]) << 18;
19490 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19491 | itoa64_to_int (input_buf
[6]) << 6
19492 | itoa64_to_int (input_buf
[7]) << 12
19493 | itoa64_to_int (input_buf
[8]) << 18;
19495 salt
->salt_len
= 4;
19497 u8 tmp_buf
[100] = { 0 };
19499 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19501 memcpy (digest
, tmp_buf
, 8);
19505 IP (digest
[0], digest
[1], tt
);
19507 digest
[0] = rotr32 (digest
[0], 31);
19508 digest
[1] = rotr32 (digest
[1], 31);
19512 return (PARSER_OK
);
19515 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19517 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19519 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19521 u32
*digest
= (u32
*) hash_buf
->digest
;
19523 salt_t
*salt
= hash_buf
->salt
;
19529 char *type_pos
= input_buf
+ 6 + 1;
19531 char *salt_pos
= strchr (type_pos
, '*');
19533 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19535 u32 type_len
= salt_pos
- type_pos
;
19537 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19541 char *crypted_pos
= strchr (salt_pos
, '*');
19543 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19545 u32 salt_len
= crypted_pos
- salt_pos
;
19547 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19551 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19553 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19559 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19560 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19562 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19563 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19565 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19566 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19567 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19568 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19570 salt
->salt_len
= 24;
19571 salt
->salt_iter
= ROUNDS_RAR3
;
19573 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19574 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19576 digest
[0] = 0xc43d7b00;
19577 digest
[1] = 0x40070000;
19581 return (PARSER_OK
);
19584 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19586 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19588 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19590 u32
*digest
= (u32
*) hash_buf
->digest
;
19592 salt_t
*salt
= hash_buf
->salt
;
19594 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19600 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19602 char *param1_pos
= strchr (param0_pos
, '$');
19604 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19606 u32 param0_len
= param1_pos
- param0_pos
;
19610 char *param2_pos
= strchr (param1_pos
, '$');
19612 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19614 u32 param1_len
= param2_pos
- param1_pos
;
19618 char *param3_pos
= strchr (param2_pos
, '$');
19620 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19622 u32 param2_len
= param3_pos
- param2_pos
;
19626 char *param4_pos
= strchr (param3_pos
, '$');
19628 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19630 u32 param3_len
= param4_pos
- param3_pos
;
19634 char *param5_pos
= strchr (param4_pos
, '$');
19636 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19638 u32 param4_len
= param5_pos
- param4_pos
;
19642 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19644 char *salt_buf
= param1_pos
;
19645 char *iv
= param3_pos
;
19646 char *pswcheck
= param5_pos
;
19648 const uint salt_len
= atoi (param0_pos
);
19649 const uint iterations
= atoi (param2_pos
);
19650 const uint pswcheck_len
= atoi (param4_pos
);
19656 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19657 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19658 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19660 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19661 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19662 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19668 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19669 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19670 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19671 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19673 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19674 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19675 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19676 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19678 salt
->salt_len
= 16;
19680 salt
->salt_sign
[0] = iterations
;
19682 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19688 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19689 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19693 return (PARSER_OK
);
19696 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19698 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19700 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19702 u32
*digest
= (u32
*) hash_buf
->digest
;
19704 salt_t
*salt
= hash_buf
->salt
;
19706 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19713 char *account_pos
= input_buf
+ 11 + 1;
19719 if (account_pos
[0] == '*')
19723 data_pos
= strchr (account_pos
, '*');
19728 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19730 uint account_len
= data_pos
- account_pos
+ 1;
19732 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19737 data_len
= input_len
- 11 - 1 - account_len
- 2;
19739 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19743 /* assume $krb5tgs$23$checksum$edata2 */
19744 data_pos
= account_pos
;
19746 memcpy (krb5tgs
->account_info
, "**", 3);
19748 data_len
= input_len
- 11 - 1 - 1;
19751 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19753 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19755 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19757 const char p0
= data_pos
[i
+ 0];
19758 const char p1
= data_pos
[i
+ 1];
19760 *checksum_ptr
++ = hex_convert (p1
) << 0
19761 | hex_convert (p0
) << 4;
19764 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19766 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19769 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19771 const char p0
= data_pos
[i
+ 0];
19772 const char p1
= data_pos
[i
+ 1];
19773 *edata_ptr
++ = hex_convert (p1
) << 0
19774 | hex_convert (p0
) << 4;
19777 /* this is needed for hmac_md5 */
19778 *edata_ptr
++ = 0x80;
19780 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19781 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19782 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19783 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19785 salt
->salt_len
= 32;
19787 digest
[0] = krb5tgs
->checksum
[0];
19788 digest
[1] = krb5tgs
->checksum
[1];
19789 digest
[2] = krb5tgs
->checksum
[2];
19790 digest
[3] = krb5tgs
->checksum
[3];
19792 return (PARSER_OK
);
19795 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19797 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19799 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19801 u32
*digest
= (u32
*) hash_buf
->digest
;
19803 salt_t
*salt
= hash_buf
->salt
;
19810 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19814 char *wrapped_key_pos
;
19818 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19820 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19822 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19824 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19829 data_pos
= salt_pos
;
19831 wrapped_key_pos
= strchr (salt_pos
, '*');
19833 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19835 uint salt_len
= wrapped_key_pos
- salt_pos
;
19837 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19842 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19844 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19846 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19847 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19848 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19849 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19853 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19854 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19855 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19856 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19857 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19858 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19860 salt
->salt_len
= 40;
19862 digest
[0] = salt
->salt_buf
[0];
19863 digest
[1] = salt
->salt_buf
[1];
19864 digest
[2] = salt
->salt_buf
[2];
19865 digest
[3] = salt
->salt_buf
[3];
19867 return (PARSER_OK
);
19870 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19872 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19874 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19876 u32
*digest
= (u32
*) hash_buf
->digest
;
19878 salt_t
*salt
= hash_buf
->salt
;
19880 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19890 char *algorithm_pos
;
19892 char *final_random_seed_pos
;
19893 u32 final_random_seed_len
;
19895 char *transf_random_seed_pos
;
19896 u32 transf_random_seed_len
;
19901 /* default is no keyfile provided */
19902 char *keyfile_len_pos
;
19903 u32 keyfile_len
= 0;
19904 u32 is_keyfile_present
= 0;
19905 char *keyfile_inline_pos
;
19908 /* specific to version 1 */
19909 char *contents_len_pos
;
19911 char *contents_pos
;
19913 /* specific to version 2 */
19914 char *expected_bytes_pos
;
19915 u32 expected_bytes_len
;
19917 char *contents_hash_pos
;
19918 u32 contents_hash_len
;
19920 version_pos
= input_buf
+ 8 + 1 + 1;
19922 keepass
->version
= atoi (version_pos
);
19924 rounds_pos
= strchr (version_pos
, '*');
19926 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19930 salt
->salt_iter
= (atoi (rounds_pos
));
19932 algorithm_pos
= strchr (rounds_pos
, '*');
19934 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19938 keepass
->algorithm
= atoi (algorithm_pos
);
19940 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19942 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19944 final_random_seed_pos
++;
19946 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19947 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19948 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19949 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19951 if (keepass
->version
== 2)
19953 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19954 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19955 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19956 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19959 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19961 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19963 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19965 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19966 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19968 transf_random_seed_pos
++;
19970 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19971 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19972 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19973 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19974 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19975 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19976 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19977 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19979 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19981 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19983 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19985 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19989 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19990 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19991 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19992 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19994 if (keepass
->version
== 1)
19996 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19998 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20000 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
20002 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
20004 contents_hash_pos
++;
20006 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
20007 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
20008 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
20009 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20010 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20011 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20012 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20013 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20015 /* get length of contents following */
20016 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
20018 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20020 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
20022 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20026 u32 inline_flag
= atoi (inline_flag_pos
);
20028 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
20030 contents_len_pos
= strchr (inline_flag_pos
, '*');
20032 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20034 contents_len_pos
++;
20036 contents_len
= atoi (contents_len_pos
);
20038 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
20040 contents_pos
= strchr (contents_len_pos
, '*');
20042 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20048 keepass
->contents_len
= contents_len
;
20050 contents_len
= contents_len
/ 4;
20052 keyfile_inline_pos
= strchr (contents_pos
, '*');
20054 u32 real_contents_len
;
20056 if (keyfile_inline_pos
== NULL
)
20057 real_contents_len
= input_len
- (contents_pos
- input_buf
);
20060 real_contents_len
= keyfile_inline_pos
- contents_pos
;
20061 keyfile_inline_pos
++;
20062 is_keyfile_present
= 1;
20065 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
20067 for (i
= 0; i
< contents_len
; i
++)
20068 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
20070 else if (keepass
->version
== 2)
20072 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
20074 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20076 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
20078 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
20080 expected_bytes_pos
++;
20082 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
20083 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
20084 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
20085 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
20086 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
20087 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
20088 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
20089 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
20091 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
20093 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20095 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
20097 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
20099 contents_hash_pos
++;
20101 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
20102 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
20103 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
20104 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20105 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20106 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20107 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20108 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20110 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
20112 if (keyfile_inline_pos
== NULL
)
20113 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
20116 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
20117 keyfile_inline_pos
++;
20118 is_keyfile_present
= 1;
20120 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20123 if (is_keyfile_present
!= 0)
20125 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20129 keyfile_len
= atoi (keyfile_len_pos
);
20131 keepass
->keyfile_len
= keyfile_len
;
20133 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20135 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20137 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20141 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20143 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20145 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20146 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20147 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20148 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20149 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20150 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20151 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20152 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20155 digest
[0] = keepass
->enc_iv
[0];
20156 digest
[1] = keepass
->enc_iv
[1];
20157 digest
[2] = keepass
->enc_iv
[2];
20158 digest
[3] = keepass
->enc_iv
[3];
20160 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20161 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20162 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20163 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20164 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20165 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20166 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20167 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20169 return (PARSER_OK
);
20172 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20174 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20176 u32
*digest
= (u32
*) hash_buf
->digest
;
20178 salt_t
*salt
= hash_buf
->salt
;
20180 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20181 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20182 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20183 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20184 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20185 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20186 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20187 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20189 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20191 uint salt_len
= input_len
- 64 - 1;
20193 char *salt_buf
= input_buf
+ 64 + 1;
20195 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20197 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20199 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20201 salt
->salt_len
= salt_len
;
20204 * we can precompute the first sha256 transform
20207 uint w
[16] = { 0 };
20209 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20210 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20211 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20212 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20213 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20214 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20215 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20216 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20217 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20218 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20219 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20220 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20221 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20222 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20223 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20224 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20226 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20228 sha256_64 (w
, pc256
);
20230 salt
->salt_buf_pc
[0] = pc256
[0];
20231 salt
->salt_buf_pc
[1] = pc256
[1];
20232 salt
->salt_buf_pc
[2] = pc256
[2];
20233 salt
->salt_buf_pc
[3] = pc256
[3];
20234 salt
->salt_buf_pc
[4] = pc256
[4];
20235 salt
->salt_buf_pc
[5] = pc256
[5];
20236 salt
->salt_buf_pc
[6] = pc256
[6];
20237 salt
->salt_buf_pc
[7] = pc256
[7];
20239 digest
[0] -= pc256
[0];
20240 digest
[1] -= pc256
[1];
20241 digest
[2] -= pc256
[2];
20242 digest
[3] -= pc256
[3];
20243 digest
[4] -= pc256
[4];
20244 digest
[5] -= pc256
[5];
20245 digest
[6] -= pc256
[6];
20246 digest
[7] -= pc256
[7];
20248 return (PARSER_OK
);
20251 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20253 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20255 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20257 u32
*digest
= (u32
*) hash_buf
->digest
;
20259 salt_t
*salt
= hash_buf
->salt
;
20265 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20267 char *data_buf_pos
= strchr (data_len_pos
, '$');
20269 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20271 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20273 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20274 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20278 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20280 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20282 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20284 u32 data_len
= atoi (data_len_pos
);
20286 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20292 char *salt_pos
= data_buf_pos
;
20294 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20295 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20296 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20297 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20299 // this is actually the CT, which is also the hash later (if matched)
20301 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20302 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20303 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20304 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20306 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20308 salt
->salt_iter
= 10 - 1;
20314 digest
[0] = salt
->salt_buf
[4];
20315 digest
[1] = salt
->salt_buf
[5];
20316 digest
[2] = salt
->salt_buf
[6];
20317 digest
[3] = salt
->salt_buf
[7];
20319 return (PARSER_OK
);
20322 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20324 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20326 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20328 u32
*digest
= (u32
*) hash_buf
->digest
;
20330 salt_t
*salt
= hash_buf
->salt
;
20336 char *salt_pos
= input_buf
+ 11 + 1;
20338 char *iter_pos
= strchr (salt_pos
, ',');
20340 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20342 u32 salt_len
= iter_pos
- salt_pos
;
20344 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20348 char *hash_pos
= strchr (iter_pos
, ',');
20350 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20352 u32 iter_len
= hash_pos
- iter_pos
;
20354 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20358 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20360 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20366 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20367 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20368 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20369 salt
->salt_buf
[3] = 0x00018000;
20371 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20372 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20373 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20374 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20376 salt
->salt_len
= salt_len
/ 2;
20378 salt
->salt_iter
= atoi (iter_pos
) - 1;
20384 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20385 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20386 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20387 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20388 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20389 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20390 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20391 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20393 return (PARSER_OK
);
20396 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20398 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20400 u32
*digest
= (u32
*) hash_buf
->digest
;
20402 salt_t
*salt
= hash_buf
->salt
;
20408 char *hash_pos
= input_buf
+ 64;
20409 char *salt1_pos
= input_buf
+ 128;
20410 char *salt2_pos
= input_buf
;
20416 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20417 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20418 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20419 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20421 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20422 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20423 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20424 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20426 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20427 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20428 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20429 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20431 salt
->salt_len
= 48;
20433 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20439 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20440 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20441 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20442 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20443 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20444 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20445 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20446 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20448 return (PARSER_OK
);
20451 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20453 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20455 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20456 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20458 u32
*digest
= (u32
*) hash_buf
->digest
;
20460 salt_t
*salt
= hash_buf
->salt
;
20462 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20468 char *param0_pos
= input_buf
+ 6 + 1;
20470 char *param1_pos
= strchr (param0_pos
, '*');
20472 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20474 u32 param0_len
= param1_pos
- param0_pos
;
20478 char *param2_pos
= strchr (param1_pos
, '*');
20480 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20482 u32 param1_len
= param2_pos
- param1_pos
;
20486 char *param3_pos
= strchr (param2_pos
, '*');
20488 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20490 u32 param2_len
= param3_pos
- param2_pos
;
20494 char *param4_pos
= strchr (param3_pos
, '*');
20496 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20498 u32 param3_len
= param4_pos
- param3_pos
;
20502 char *param5_pos
= strchr (param4_pos
, '*');
20504 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20506 u32 param4_len
= param5_pos
- param4_pos
;
20510 char *param6_pos
= strchr (param5_pos
, '*');
20512 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20514 u32 param5_len
= param6_pos
- param5_pos
;
20518 char *param7_pos
= strchr (param6_pos
, '*');
20520 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20522 u32 param6_len
= param7_pos
- param6_pos
;
20526 char *param8_pos
= strchr (param7_pos
, '*');
20528 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20530 u32 param7_len
= param8_pos
- param7_pos
;
20534 const uint type
= atoi (param0_pos
);
20535 const uint mode
= atoi (param1_pos
);
20536 const uint magic
= atoi (param2_pos
);
20538 char *salt_buf
= param3_pos
;
20540 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20542 const uint compress_length
= atoi (param5_pos
);
20544 char *data_buf
= param6_pos
;
20545 char *auth
= param7_pos
;
20551 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20553 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20555 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20557 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20559 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20561 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20563 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20565 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20567 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20569 if (type
!= 0) return (PARSER_SALT_VALUE
);
20571 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20573 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20575 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20583 zip2
->magic
= magic
;
20587 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20588 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20589 zip2
->salt_buf
[2] = 0;
20590 zip2
->salt_buf
[3] = 0;
20592 zip2
->salt_len
= 8;
20594 else if (mode
== 2)
20596 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20597 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20598 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20599 zip2
->salt_buf
[3] = 0;
20601 zip2
->salt_len
= 12;
20603 else if (mode
== 3)
20605 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20606 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20607 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20608 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20610 zip2
->salt_len
= 16;
20613 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20614 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20615 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20616 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20618 zip2
->verify_bytes
= verify_bytes
;
20620 zip2
->compress_length
= compress_length
;
20622 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20624 for (uint i
= 0; i
< param6_len
; i
+= 2)
20626 const char p0
= data_buf
[i
+ 0];
20627 const char p1
= data_buf
[i
+ 1];
20629 *data_buf_ptr
++ = hex_convert (p1
) << 0
20630 | hex_convert (p0
) << 4;
20635 *data_buf_ptr
= 0x80;
20637 char *auth_ptr
= (char *) zip2
->auth_buf
;
20639 for (uint i
= 0; i
< param7_len
; i
+= 2)
20641 const char p0
= auth
[i
+ 0];
20642 const char p1
= auth
[i
+ 1];
20644 *auth_ptr
++ = hex_convert (p1
) << 0
20645 | hex_convert (p0
) << 4;
20654 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20655 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20656 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20657 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20658 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20659 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20660 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20661 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20663 salt
->salt_len
= 32;
20665 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20668 * digest buf (fake)
20671 digest
[0] = zip2
->auth_buf
[0];
20672 digest
[1] = zip2
->auth_buf
[1];
20673 digest
[2] = zip2
->auth_buf
[2];
20674 digest
[3] = zip2
->auth_buf
[3];
20676 return (PARSER_OK
);
20679 int win8phone_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20681 if ((input_len
< DISPLAY_LEN_MIN_13800
) || (input_len
> DISPLAY_LEN_MAX_13800
)) return (PARSER_GLOBAL_LENGTH
);
20683 u32
*digest
= (u32
*) hash_buf
->digest
;
20685 salt_t
*salt
= hash_buf
->salt
;
20687 win8phone_t
*esalt
= hash_buf
->esalt
;
20689 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20690 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20691 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20692 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20693 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20694 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20695 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20696 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20698 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20700 char *salt_buf_ptr
= input_buf
+ 64 + 1;
20702 u32
*salt_buf
= esalt
->salt_buf
;
20704 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
20706 salt_buf
[i
] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[j
]);
20709 salt
->salt_buf
[0] = salt_buf
[0];
20710 salt
->salt_buf
[1] = salt_buf
[1];
20711 salt
->salt_buf
[2] = salt_buf
[2];
20712 salt
->salt_buf
[3] = salt_buf
[3];
20713 salt
->salt_buf
[4] = salt_buf
[4];
20714 salt
->salt_buf
[5] = salt_buf
[5];
20715 salt
->salt_buf
[6] = salt_buf
[6];
20716 salt
->salt_buf
[7] = salt_buf
[7];
20718 salt
->salt_len
= 64;
20720 return (PARSER_OK
);
20724 * parallel running threads
20729 BOOL WINAPI
sigHandler_default (DWORD sig
)
20733 case CTRL_CLOSE_EVENT
:
20736 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20737 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20738 * function otherwise it is too late (e.g. after returning from this function)
20743 SetConsoleCtrlHandler (NULL
, TRUE
);
20750 case CTRL_LOGOFF_EVENT
:
20751 case CTRL_SHUTDOWN_EVENT
:
20755 SetConsoleCtrlHandler (NULL
, TRUE
);
20763 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20767 case CTRL_CLOSE_EVENT
:
20771 SetConsoleCtrlHandler (NULL
, TRUE
);
20778 case CTRL_LOGOFF_EVENT
:
20779 case CTRL_SHUTDOWN_EVENT
:
20783 SetConsoleCtrlHandler (NULL
, TRUE
);
20791 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20793 if (callback
== NULL
)
20795 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20799 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20805 void sigHandler_default (int sig
)
20809 signal (sig
, NULL
);
20812 void sigHandler_benchmark (int sig
)
20816 signal (sig
, NULL
);
20819 void hc_signal (void (callback
) (int))
20821 if (callback
== NULL
) callback
= SIG_DFL
;
20823 signal (SIGINT
, callback
);
20824 signal (SIGTERM
, callback
);
20825 signal (SIGABRT
, callback
);
20830 void status_display ();
20832 void *thread_keypress (void *p
)
20834 uint quiet
= data
.quiet
;
20838 while (data
.shutdown_outer
== 0)
20840 int ch
= tty_getchar();
20842 if (ch
== -1) break;
20844 if (ch
== 0) continue;
20846 //https://github.com/hashcat/hashcat/issues/302
20851 hc_thread_mutex_lock (mux_display
);
20867 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20868 if (quiet
== 0) fflush (stdout
);
20880 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20881 if (quiet
== 0) fflush (stdout
);
20893 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20894 if (quiet
== 0) fflush (stdout
);
20906 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20907 if (quiet
== 0) fflush (stdout
);
20915 stop_at_checkpoint ();
20919 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20920 if (quiet
== 0) fflush (stdout
);
20933 //https://github.com/hashcat/hashcat/issues/302
20938 hc_thread_mutex_unlock (mux_display
);
20950 bool class_num (const u8 c
)
20952 return ((c
>= '0') && (c
<= '9'));
20955 bool class_lower (const u8 c
)
20957 return ((c
>= 'a') && (c
<= 'z'));
20960 bool class_upper (const u8 c
)
20962 return ((c
>= 'A') && (c
<= 'Z'));
20965 bool class_alpha (const u8 c
)
20967 return (class_lower (c
) || class_upper (c
));
20970 int conv_ctoi (const u8 c
)
20976 else if (class_upper (c
))
20978 return c
- 'A' + 10;
20984 int conv_itoc (const u8 c
)
20992 return c
+ 'A' - 10;
21002 #define INCR_POS if (++rule_pos == rule_len) return (-1)
21003 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
21004 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
21005 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
21006 #define MAX_KERNEL_RULES 255
21007 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
21008 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
21009 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
21011 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
21012 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
21013 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
21014 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
21016 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
21021 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21023 switch (rule_buf
[rule_pos
])
21029 case RULE_OP_MANGLE_NOOP
:
21030 SET_NAME (rule
, rule_buf
[rule_pos
]);
21033 case RULE_OP_MANGLE_LREST
:
21034 SET_NAME (rule
, rule_buf
[rule_pos
]);
21037 case RULE_OP_MANGLE_UREST
:
21038 SET_NAME (rule
, rule_buf
[rule_pos
]);
21041 case RULE_OP_MANGLE_LREST_UFIRST
:
21042 SET_NAME (rule
, rule_buf
[rule_pos
]);
21045 case RULE_OP_MANGLE_UREST_LFIRST
:
21046 SET_NAME (rule
, rule_buf
[rule_pos
]);
21049 case RULE_OP_MANGLE_TREST
:
21050 SET_NAME (rule
, rule_buf
[rule_pos
]);
21053 case RULE_OP_MANGLE_TOGGLE_AT
:
21054 SET_NAME (rule
, rule_buf
[rule_pos
]);
21055 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21058 case RULE_OP_MANGLE_REVERSE
:
21059 SET_NAME (rule
, rule_buf
[rule_pos
]);
21062 case RULE_OP_MANGLE_DUPEWORD
:
21063 SET_NAME (rule
, rule_buf
[rule_pos
]);
21066 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21067 SET_NAME (rule
, rule_buf
[rule_pos
]);
21068 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21071 case RULE_OP_MANGLE_REFLECT
:
21072 SET_NAME (rule
, rule_buf
[rule_pos
]);
21075 case RULE_OP_MANGLE_ROTATE_LEFT
:
21076 SET_NAME (rule
, rule_buf
[rule_pos
]);
21079 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21080 SET_NAME (rule
, rule_buf
[rule_pos
]);
21083 case RULE_OP_MANGLE_APPEND
:
21084 SET_NAME (rule
, rule_buf
[rule_pos
]);
21085 SET_P0 (rule
, rule_buf
[rule_pos
]);
21088 case RULE_OP_MANGLE_PREPEND
:
21089 SET_NAME (rule
, rule_buf
[rule_pos
]);
21090 SET_P0 (rule
, rule_buf
[rule_pos
]);
21093 case RULE_OP_MANGLE_DELETE_FIRST
:
21094 SET_NAME (rule
, rule_buf
[rule_pos
]);
21097 case RULE_OP_MANGLE_DELETE_LAST
:
21098 SET_NAME (rule
, rule_buf
[rule_pos
]);
21101 case RULE_OP_MANGLE_DELETE_AT
:
21102 SET_NAME (rule
, rule_buf
[rule_pos
]);
21103 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21106 case RULE_OP_MANGLE_EXTRACT
:
21107 SET_NAME (rule
, rule_buf
[rule_pos
]);
21108 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21109 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21112 case RULE_OP_MANGLE_OMIT
:
21113 SET_NAME (rule
, rule_buf
[rule_pos
]);
21114 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21115 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21118 case RULE_OP_MANGLE_INSERT
:
21119 SET_NAME (rule
, rule_buf
[rule_pos
]);
21120 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21121 SET_P1 (rule
, rule_buf
[rule_pos
]);
21124 case RULE_OP_MANGLE_OVERSTRIKE
:
21125 SET_NAME (rule
, rule_buf
[rule_pos
]);
21126 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21127 SET_P1 (rule
, rule_buf
[rule_pos
]);
21130 case RULE_OP_MANGLE_TRUNCATE_AT
:
21131 SET_NAME (rule
, rule_buf
[rule_pos
]);
21132 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21135 case RULE_OP_MANGLE_REPLACE
:
21136 SET_NAME (rule
, rule_buf
[rule_pos
]);
21137 SET_P0 (rule
, rule_buf
[rule_pos
]);
21138 SET_P1 (rule
, rule_buf
[rule_pos
]);
21141 case RULE_OP_MANGLE_PURGECHAR
:
21145 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21149 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21150 SET_NAME (rule
, rule_buf
[rule_pos
]);
21151 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21154 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21155 SET_NAME (rule
, rule_buf
[rule_pos
]);
21156 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21159 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21160 SET_NAME (rule
, rule_buf
[rule_pos
]);
21163 case RULE_OP_MANGLE_SWITCH_FIRST
:
21164 SET_NAME (rule
, rule_buf
[rule_pos
]);
21167 case RULE_OP_MANGLE_SWITCH_LAST
:
21168 SET_NAME (rule
, rule_buf
[rule_pos
]);
21171 case RULE_OP_MANGLE_SWITCH_AT
:
21172 SET_NAME (rule
, rule_buf
[rule_pos
]);
21173 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21174 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21177 case RULE_OP_MANGLE_CHR_SHIFTL
:
21178 SET_NAME (rule
, rule_buf
[rule_pos
]);
21179 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21182 case RULE_OP_MANGLE_CHR_SHIFTR
:
21183 SET_NAME (rule
, rule_buf
[rule_pos
]);
21184 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21187 case RULE_OP_MANGLE_CHR_INCR
:
21188 SET_NAME (rule
, rule_buf
[rule_pos
]);
21189 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21192 case RULE_OP_MANGLE_CHR_DECR
:
21193 SET_NAME (rule
, rule_buf
[rule_pos
]);
21194 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21197 case RULE_OP_MANGLE_REPLACE_NP1
:
21198 SET_NAME (rule
, rule_buf
[rule_pos
]);
21199 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21202 case RULE_OP_MANGLE_REPLACE_NM1
:
21203 SET_NAME (rule
, rule_buf
[rule_pos
]);
21204 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21207 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21208 SET_NAME (rule
, rule_buf
[rule_pos
]);
21209 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21212 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21213 SET_NAME (rule
, rule_buf
[rule_pos
]);
21214 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21217 case RULE_OP_MANGLE_TITLE
:
21218 SET_NAME (rule
, rule_buf
[rule_pos
]);
21227 if (rule_pos
< rule_len
) return -1;
21232 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21236 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21240 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21244 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21248 case RULE_OP_MANGLE_NOOP
:
21249 rule_buf
[rule_pos
] = rule_cmd
;
21252 case RULE_OP_MANGLE_LREST
:
21253 rule_buf
[rule_pos
] = rule_cmd
;
21256 case RULE_OP_MANGLE_UREST
:
21257 rule_buf
[rule_pos
] = rule_cmd
;
21260 case RULE_OP_MANGLE_LREST_UFIRST
:
21261 rule_buf
[rule_pos
] = rule_cmd
;
21264 case RULE_OP_MANGLE_UREST_LFIRST
:
21265 rule_buf
[rule_pos
] = rule_cmd
;
21268 case RULE_OP_MANGLE_TREST
:
21269 rule_buf
[rule_pos
] = rule_cmd
;
21272 case RULE_OP_MANGLE_TOGGLE_AT
:
21273 rule_buf
[rule_pos
] = rule_cmd
;
21274 GET_P0_CONV (rule
);
21277 case RULE_OP_MANGLE_REVERSE
:
21278 rule_buf
[rule_pos
] = rule_cmd
;
21281 case RULE_OP_MANGLE_DUPEWORD
:
21282 rule_buf
[rule_pos
] = rule_cmd
;
21285 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21286 rule_buf
[rule_pos
] = rule_cmd
;
21287 GET_P0_CONV (rule
);
21290 case RULE_OP_MANGLE_REFLECT
:
21291 rule_buf
[rule_pos
] = rule_cmd
;
21294 case RULE_OP_MANGLE_ROTATE_LEFT
:
21295 rule_buf
[rule_pos
] = rule_cmd
;
21298 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21299 rule_buf
[rule_pos
] = rule_cmd
;
21302 case RULE_OP_MANGLE_APPEND
:
21303 rule_buf
[rule_pos
] = rule_cmd
;
21307 case RULE_OP_MANGLE_PREPEND
:
21308 rule_buf
[rule_pos
] = rule_cmd
;
21312 case RULE_OP_MANGLE_DELETE_FIRST
:
21313 rule_buf
[rule_pos
] = rule_cmd
;
21316 case RULE_OP_MANGLE_DELETE_LAST
:
21317 rule_buf
[rule_pos
] = rule_cmd
;
21320 case RULE_OP_MANGLE_DELETE_AT
:
21321 rule_buf
[rule_pos
] = rule_cmd
;
21322 GET_P0_CONV (rule
);
21325 case RULE_OP_MANGLE_EXTRACT
:
21326 rule_buf
[rule_pos
] = rule_cmd
;
21327 GET_P0_CONV (rule
);
21328 GET_P1_CONV (rule
);
21331 case RULE_OP_MANGLE_OMIT
:
21332 rule_buf
[rule_pos
] = rule_cmd
;
21333 GET_P0_CONV (rule
);
21334 GET_P1_CONV (rule
);
21337 case RULE_OP_MANGLE_INSERT
:
21338 rule_buf
[rule_pos
] = rule_cmd
;
21339 GET_P0_CONV (rule
);
21343 case RULE_OP_MANGLE_OVERSTRIKE
:
21344 rule_buf
[rule_pos
] = rule_cmd
;
21345 GET_P0_CONV (rule
);
21349 case RULE_OP_MANGLE_TRUNCATE_AT
:
21350 rule_buf
[rule_pos
] = rule_cmd
;
21351 GET_P0_CONV (rule
);
21354 case RULE_OP_MANGLE_REPLACE
:
21355 rule_buf
[rule_pos
] = rule_cmd
;
21360 case RULE_OP_MANGLE_PURGECHAR
:
21364 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21368 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21369 rule_buf
[rule_pos
] = rule_cmd
;
21370 GET_P0_CONV (rule
);
21373 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21374 rule_buf
[rule_pos
] = rule_cmd
;
21375 GET_P0_CONV (rule
);
21378 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21379 rule_buf
[rule_pos
] = rule_cmd
;
21382 case RULE_OP_MANGLE_SWITCH_FIRST
:
21383 rule_buf
[rule_pos
] = rule_cmd
;
21386 case RULE_OP_MANGLE_SWITCH_LAST
:
21387 rule_buf
[rule_pos
] = rule_cmd
;
21390 case RULE_OP_MANGLE_SWITCH_AT
:
21391 rule_buf
[rule_pos
] = rule_cmd
;
21392 GET_P0_CONV (rule
);
21393 GET_P1_CONV (rule
);
21396 case RULE_OP_MANGLE_CHR_SHIFTL
:
21397 rule_buf
[rule_pos
] = rule_cmd
;
21398 GET_P0_CONV (rule
);
21401 case RULE_OP_MANGLE_CHR_SHIFTR
:
21402 rule_buf
[rule_pos
] = rule_cmd
;
21403 GET_P0_CONV (rule
);
21406 case RULE_OP_MANGLE_CHR_INCR
:
21407 rule_buf
[rule_pos
] = rule_cmd
;
21408 GET_P0_CONV (rule
);
21411 case RULE_OP_MANGLE_CHR_DECR
:
21412 rule_buf
[rule_pos
] = rule_cmd
;
21413 GET_P0_CONV (rule
);
21416 case RULE_OP_MANGLE_REPLACE_NP1
:
21417 rule_buf
[rule_pos
] = rule_cmd
;
21418 GET_P0_CONV (rule
);
21421 case RULE_OP_MANGLE_REPLACE_NM1
:
21422 rule_buf
[rule_pos
] = rule_cmd
;
21423 GET_P0_CONV (rule
);
21426 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21427 rule_buf
[rule_pos
] = rule_cmd
;
21428 GET_P0_CONV (rule
);
21431 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21432 rule_buf
[rule_pos
] = rule_cmd
;
21433 GET_P0_CONV (rule
);
21436 case RULE_OP_MANGLE_TITLE
:
21437 rule_buf
[rule_pos
] = rule_cmd
;
21441 return rule_pos
- 1;
21459 * CPU rules : this is from hashcat sources, cpu based rules
21462 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21463 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21465 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21466 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21467 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21469 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21470 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21471 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21473 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21477 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21482 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21486 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21491 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21495 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21500 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21505 for (l
= 0; l
< arr_len
; l
++)
21507 r
= arr_len
- 1 - l
;
21511 MANGLE_SWITCH (arr
, l
, r
);
21517 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21519 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21521 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21523 return (arr_len
* 2);
21526 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21528 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21530 int orig_len
= arr_len
;
21534 for (i
= 0; i
< times
; i
++)
21536 memcpy (&arr
[arr_len
], arr
, orig_len
);
21538 arr_len
+= orig_len
;
21544 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21546 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21548 mangle_double (arr
, arr_len
);
21550 mangle_reverse (arr
+ arr_len
, arr_len
);
21552 return (arr_len
* 2);
21555 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21560 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21562 MANGLE_SWITCH (arr
, l
, r
);
21568 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21573 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21575 MANGLE_SWITCH (arr
, l
, r
);
21581 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21583 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21587 return (arr_len
+ 1);
21590 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21592 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21596 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21598 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21603 return (arr_len
+ 1);
21606 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21608 if (upos
>= arr_len
) return (arr_len
);
21612 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21614 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21617 return (arr_len
- 1);
21620 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21622 if (upos
>= arr_len
) return (arr_len
);
21624 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21628 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21630 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21636 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21638 if (upos
>= arr_len
) return (arr_len
);
21640 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21644 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21646 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21649 return (arr_len
- ulen
);
21652 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21654 if (upos
>= arr_len
) return (arr_len
);
21656 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21660 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21662 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21667 return (arr_len
+ 1);
21670 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
)
21672 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21674 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21676 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21678 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21680 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21682 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21684 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21686 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21688 return (arr_len
+ arr2_cpy
);
21691 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21693 if (upos
>= arr_len
) return (arr_len
);
21700 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21702 if (upos
>= arr_len
) return (arr_len
);
21704 memset (arr
+ upos
, 0, arr_len
- upos
);
21709 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21713 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21715 if (arr
[arr_pos
] != oldc
) continue;
21717 arr
[arr_pos
] = newc
;
21723 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21729 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21731 if (arr
[arr_pos
] == c
) continue;
21733 arr
[ret_len
] = arr
[arr_pos
];
21741 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21743 if (ulen
> arr_len
) return (arr_len
);
21745 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21747 char cs
[100] = { 0 };
21749 memcpy (cs
, arr
, ulen
);
21753 for (i
= 0; i
< ulen
; i
++)
21757 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21763 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21765 if (ulen
> arr_len
) return (arr_len
);
21767 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21769 int upos
= arr_len
- ulen
;
21773 for (i
= 0; i
< ulen
; i
++)
21775 char c
= arr
[upos
+ i
];
21777 arr_len
= mangle_append (arr
, arr_len
, c
);
21783 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21785 if ( arr_len
== 0) return (arr_len
);
21786 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21788 char c
= arr
[upos
];
21792 for (i
= 0; i
< ulen
; i
++)
21794 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21800 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21802 if ( arr_len
== 0) return (arr_len
);
21803 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21807 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21809 int new_pos
= arr_pos
* 2;
21811 arr
[new_pos
] = arr
[arr_pos
];
21813 arr
[new_pos
+ 1] = arr
[arr_pos
];
21816 return (arr_len
* 2);
21819 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21821 if (upos
>= arr_len
) return (arr_len
);
21822 if (upos2
>= arr_len
) return (arr_len
);
21824 MANGLE_SWITCH (arr
, upos
, upos2
);
21829 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21831 MANGLE_SWITCH (arr
, upos
, upos2
);
21836 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21838 if (upos
>= arr_len
) return (arr_len
);
21845 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21847 if (upos
>= arr_len
) return (arr_len
);
21854 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21856 if (upos
>= arr_len
) return (arr_len
);
21863 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21865 if (upos
>= arr_len
) return (arr_len
);
21872 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21874 int upper_next
= 1;
21878 for (pos
= 0; pos
< arr_len
; pos
++)
21880 if (arr
[pos
] == ' ')
21891 MANGLE_UPPER_AT (arr
, pos
);
21895 MANGLE_LOWER_AT (arr
, pos
);
21902 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21904 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21910 for (j
= 0; j
< rp_gen_num
; j
++)
21917 switch ((char) get_random_num (0, 9))
21920 r
= get_random_num (0, sizeof (grp_op_nop
));
21921 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21925 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21926 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21927 p1
= get_random_num (0, sizeof (grp_pos
));
21928 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21932 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21933 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21934 p1
= get_random_num (1, 6);
21935 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21939 r
= get_random_num (0, sizeof (grp_op_chr
));
21940 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21941 p1
= get_random_num (0x20, 0x7e);
21942 rule_buf
[rule_pos
++] = (char) p1
;
21946 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21947 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21948 p1
= get_random_num (0x20, 0x7e);
21949 rule_buf
[rule_pos
++] = (char) p1
;
21950 p2
= get_random_num (0x20, 0x7e);
21952 p2
= get_random_num (0x20, 0x7e);
21953 rule_buf
[rule_pos
++] = (char) p2
;
21957 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21958 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21959 p1
= get_random_num (0, sizeof (grp_pos
));
21960 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21961 p2
= get_random_num (0x20, 0x7e);
21962 rule_buf
[rule_pos
++] = (char) p2
;
21966 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21967 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21968 p1
= get_random_num (0, sizeof (grp_pos
));
21969 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21970 p2
= get_random_num (0, sizeof (grp_pos
));
21972 p2
= get_random_num (0, sizeof (grp_pos
));
21973 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21977 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21978 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21979 p1
= get_random_num (0, sizeof (grp_pos
));
21980 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21981 p2
= get_random_num (1, sizeof (grp_pos
));
21983 p2
= get_random_num (1, sizeof (grp_pos
));
21984 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21988 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21989 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21990 p1
= get_random_num (0, sizeof (grp_pos
));
21991 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21992 p2
= get_random_num (1, sizeof (grp_pos
));
21993 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21994 p3
= get_random_num (0, sizeof (grp_pos
));
21995 rule_buf
[rule_pos
++] = grp_pos
[p3
];
22003 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
22005 char mem
[BLOCK_SIZE
] = { 0 };
22007 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
22009 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
22011 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22013 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
22015 int out_len
= in_len
;
22016 int mem_len
= in_len
;
22018 memcpy (out
, in
, out_len
);
22022 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
22027 switch (rule
[rule_pos
])
22032 case RULE_OP_MANGLE_NOOP
:
22035 case RULE_OP_MANGLE_LREST
:
22036 out_len
= mangle_lrest (out
, out_len
);
22039 case RULE_OP_MANGLE_UREST
:
22040 out_len
= mangle_urest (out
, out_len
);
22043 case RULE_OP_MANGLE_LREST_UFIRST
:
22044 out_len
= mangle_lrest (out
, out_len
);
22045 if (out_len
) MANGLE_UPPER_AT (out
, 0);
22048 case RULE_OP_MANGLE_UREST_LFIRST
:
22049 out_len
= mangle_urest (out
, out_len
);
22050 if (out_len
) MANGLE_LOWER_AT (out
, 0);
22053 case RULE_OP_MANGLE_TREST
:
22054 out_len
= mangle_trest (out
, out_len
);
22057 case RULE_OP_MANGLE_TOGGLE_AT
:
22058 NEXT_RULEPOS (rule_pos
);
22059 NEXT_RPTOI (rule
, rule_pos
, upos
);
22060 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
22063 case RULE_OP_MANGLE_REVERSE
:
22064 out_len
= mangle_reverse (out
, out_len
);
22067 case RULE_OP_MANGLE_DUPEWORD
:
22068 out_len
= mangle_double (out
, out_len
);
22071 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
22072 NEXT_RULEPOS (rule_pos
);
22073 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22074 out_len
= mangle_double_times (out
, out_len
, ulen
);
22077 case RULE_OP_MANGLE_REFLECT
:
22078 out_len
= mangle_reflect (out
, out_len
);
22081 case RULE_OP_MANGLE_ROTATE_LEFT
:
22082 mangle_rotate_left (out
, out_len
);
22085 case RULE_OP_MANGLE_ROTATE_RIGHT
:
22086 mangle_rotate_right (out
, out_len
);
22089 case RULE_OP_MANGLE_APPEND
:
22090 NEXT_RULEPOS (rule_pos
);
22091 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
22094 case RULE_OP_MANGLE_PREPEND
:
22095 NEXT_RULEPOS (rule_pos
);
22096 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
22099 case RULE_OP_MANGLE_DELETE_FIRST
:
22100 out_len
= mangle_delete_at (out
, out_len
, 0);
22103 case RULE_OP_MANGLE_DELETE_LAST
:
22104 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
22107 case RULE_OP_MANGLE_DELETE_AT
:
22108 NEXT_RULEPOS (rule_pos
);
22109 NEXT_RPTOI (rule
, rule_pos
, upos
);
22110 out_len
= mangle_delete_at (out
, out_len
, upos
);
22113 case RULE_OP_MANGLE_EXTRACT
:
22114 NEXT_RULEPOS (rule_pos
);
22115 NEXT_RPTOI (rule
, rule_pos
, upos
);
22116 NEXT_RULEPOS (rule_pos
);
22117 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22118 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
22121 case RULE_OP_MANGLE_OMIT
:
22122 NEXT_RULEPOS (rule_pos
);
22123 NEXT_RPTOI (rule
, rule_pos
, upos
);
22124 NEXT_RULEPOS (rule_pos
);
22125 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22126 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
22129 case RULE_OP_MANGLE_INSERT
:
22130 NEXT_RULEPOS (rule_pos
);
22131 NEXT_RPTOI (rule
, rule_pos
, upos
);
22132 NEXT_RULEPOS (rule_pos
);
22133 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22136 case RULE_OP_MANGLE_OVERSTRIKE
:
22137 NEXT_RULEPOS (rule_pos
);
22138 NEXT_RPTOI (rule
, rule_pos
, upos
);
22139 NEXT_RULEPOS (rule_pos
);
22140 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22143 case RULE_OP_MANGLE_TRUNCATE_AT
:
22144 NEXT_RULEPOS (rule_pos
);
22145 NEXT_RPTOI (rule
, rule_pos
, upos
);
22146 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22149 case RULE_OP_MANGLE_REPLACE
:
22150 NEXT_RULEPOS (rule_pos
);
22151 NEXT_RULEPOS (rule_pos
);
22152 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22155 case RULE_OP_MANGLE_PURGECHAR
:
22156 NEXT_RULEPOS (rule_pos
);
22157 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22160 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22164 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22165 NEXT_RULEPOS (rule_pos
);
22166 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22167 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22170 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22171 NEXT_RULEPOS (rule_pos
);
22172 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22173 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22176 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22177 out_len
= mangle_dupechar (out
, out_len
);
22180 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22181 NEXT_RULEPOS (rule_pos
);
22182 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22183 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22186 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22187 NEXT_RULEPOS (rule_pos
);
22188 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22189 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22192 case RULE_OP_MANGLE_SWITCH_FIRST
:
22193 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22196 case RULE_OP_MANGLE_SWITCH_LAST
:
22197 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22200 case RULE_OP_MANGLE_SWITCH_AT
:
22201 NEXT_RULEPOS (rule_pos
);
22202 NEXT_RPTOI (rule
, rule_pos
, upos
);
22203 NEXT_RULEPOS (rule_pos
);
22204 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22205 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22208 case RULE_OP_MANGLE_CHR_SHIFTL
:
22209 NEXT_RULEPOS (rule_pos
);
22210 NEXT_RPTOI (rule
, rule_pos
, upos
);
22211 mangle_chr_shiftl (out
, out_len
, upos
);
22214 case RULE_OP_MANGLE_CHR_SHIFTR
:
22215 NEXT_RULEPOS (rule_pos
);
22216 NEXT_RPTOI (rule
, rule_pos
, upos
);
22217 mangle_chr_shiftr (out
, out_len
, upos
);
22220 case RULE_OP_MANGLE_CHR_INCR
:
22221 NEXT_RULEPOS (rule_pos
);
22222 NEXT_RPTOI (rule
, rule_pos
, upos
);
22223 mangle_chr_incr (out
, out_len
, upos
);
22226 case RULE_OP_MANGLE_CHR_DECR
:
22227 NEXT_RULEPOS (rule_pos
);
22228 NEXT_RPTOI (rule
, rule_pos
, upos
);
22229 mangle_chr_decr (out
, out_len
, upos
);
22232 case RULE_OP_MANGLE_REPLACE_NP1
:
22233 NEXT_RULEPOS (rule_pos
);
22234 NEXT_RPTOI (rule
, rule_pos
, upos
);
22235 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22238 case RULE_OP_MANGLE_REPLACE_NM1
:
22239 NEXT_RULEPOS (rule_pos
);
22240 NEXT_RPTOI (rule
, rule_pos
, upos
);
22241 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22244 case RULE_OP_MANGLE_TITLE
:
22245 out_len
= mangle_title (out
, out_len
);
22248 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22249 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22250 NEXT_RULEPOS (rule_pos
);
22251 NEXT_RPTOI (rule
, rule_pos
, upos
);
22252 NEXT_RULEPOS (rule_pos
);
22253 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22254 NEXT_RULEPOS (rule_pos
);
22255 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22256 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22259 case RULE_OP_MANGLE_APPEND_MEMORY
:
22260 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22261 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22262 memcpy (out
+ out_len
, mem
, mem_len
);
22263 out_len
+= mem_len
;
22266 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22267 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22268 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22269 memcpy (mem
+ mem_len
, out
, out_len
);
22270 out_len
+= mem_len
;
22271 memcpy (out
, mem
, out_len
);
22274 case RULE_OP_MEMORIZE_WORD
:
22275 memcpy (mem
, out
, out_len
);
22279 case RULE_OP_REJECT_LESS
:
22280 NEXT_RULEPOS (rule_pos
);
22281 NEXT_RPTOI (rule
, rule_pos
, upos
);
22282 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22285 case RULE_OP_REJECT_GREATER
:
22286 NEXT_RULEPOS (rule_pos
);
22287 NEXT_RPTOI (rule
, rule_pos
, upos
);
22288 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22291 case RULE_OP_REJECT_CONTAIN
:
22292 NEXT_RULEPOS (rule_pos
);
22293 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22296 case RULE_OP_REJECT_NOT_CONTAIN
:
22297 NEXT_RULEPOS (rule_pos
);
22298 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22301 case RULE_OP_REJECT_EQUAL_FIRST
:
22302 NEXT_RULEPOS (rule_pos
);
22303 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22306 case RULE_OP_REJECT_EQUAL_LAST
:
22307 NEXT_RULEPOS (rule_pos
);
22308 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22311 case RULE_OP_REJECT_EQUAL_AT
:
22312 NEXT_RULEPOS (rule_pos
);
22313 NEXT_RPTOI (rule
, rule_pos
, upos
);
22314 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22315 NEXT_RULEPOS (rule_pos
);
22316 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22319 case RULE_OP_REJECT_CONTAINS
:
22320 NEXT_RULEPOS (rule_pos
);
22321 NEXT_RPTOI (rule
, rule_pos
, upos
);
22322 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22323 NEXT_RULEPOS (rule_pos
);
22324 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22325 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22328 case RULE_OP_REJECT_MEMORY
:
22329 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22333 return (RULE_RC_SYNTAX_ERROR
);
22338 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);