2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
15 #include <pthread_np.h>
25 u32
is_power_of_2(u32 v
)
27 return (v
&& !(v
& (v
- 1)));
30 u32
rotl32 (const u32 a
, const u32 n
)
32 return ((a
<< n
) | (a
>> (32 - n
)));
35 u32
rotr32 (const u32 a
, const u32 n
)
37 return ((a
>> n
) | (a
<< (32 - n
)));
40 u64
rotl64 (const u64 a
, const u64 n
)
42 return ((a
<< n
) | (a
>> (64 - n
)));
45 u64
rotr64 (const u64 a
, const u64 n
)
47 return ((a
>> n
) | (a
<< (64 - n
)));
50 u32
byte_swap_32 (const u32 n
)
52 return (n
& 0xff000000) >> 24
53 | (n
& 0x00ff0000) >> 8
54 | (n
& 0x0000ff00) << 8
55 | (n
& 0x000000ff) << 24;
58 u64
byte_swap_64 (const u64 n
)
60 return (n
& 0xff00000000000000ULL
) >> 56
61 | (n
& 0x00ff000000000000ULL
) >> 40
62 | (n
& 0x0000ff0000000000ULL
) >> 24
63 | (n
& 0x000000ff00000000ULL
) >> 8
64 | (n
& 0x00000000ff000000ULL
) << 8
65 | (n
& 0x0000000000ff0000ULL
) << 24
66 | (n
& 0x000000000000ff00ULL
) << 40
67 | (n
& 0x00000000000000ffULL
) << 56;
71 * ciphers for use on cpu
78 * hashes for use on cpu
83 #include "cpu-sha256.c"
91 int log_final (FILE *fp
, const char *fmt
, va_list ap
)
97 for (int i
= 0; i
< last_len
; i
++)
105 char s
[4096] = { 0 };
107 int max_len
= (int) sizeof (s
);
109 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
111 if (len
> max_len
) len
= max_len
;
113 fwrite (s
, len
, 1, fp
);
122 int log_out_nn (FILE *fp
, const char *fmt
, ...)
124 if (SUPPRESS_OUTPUT
) return 0;
130 const int len
= log_final (fp
, fmt
, ap
);
137 int log_info_nn (const char *fmt
, ...)
139 if (SUPPRESS_OUTPUT
) return 0;
145 const int len
= log_final (stdout
, fmt
, ap
);
152 int log_error_nn (const char *fmt
, ...)
154 if (SUPPRESS_OUTPUT
) return 0;
160 const int len
= log_final (stderr
, fmt
, ap
);
167 int log_out (FILE *fp
, const char *fmt
, ...)
169 if (SUPPRESS_OUTPUT
) return 0;
175 const int len
= log_final (fp
, fmt
, ap
);
186 int log_info (const char *fmt
, ...)
188 if (SUPPRESS_OUTPUT
) return 0;
194 const int len
= log_final (stdout
, fmt
, ap
);
198 fputc ('\n', stdout
);
205 int log_error (const char *fmt
, ...)
207 if (SUPPRESS_OUTPUT
) return 0;
209 fputc ('\n', stderr
);
210 fputc ('\n', stderr
);
216 const int len
= log_final (stderr
, fmt
, ap
);
220 fputc ('\n', stderr
);
221 fputc ('\n', stderr
);
232 u8
int_to_base32 (const u8 c
)
234 static const u8 tbl
[0x20] =
236 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
237 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
243 u8
base32_to_int (const u8 c
)
245 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
246 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
251 u8
int_to_itoa32 (const u8 c
)
253 static const u8 tbl
[0x20] =
255 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
256 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
262 u8
itoa32_to_int (const u8 c
)
264 if ((c
>= '0') && (c
<= '9')) return c
- '0';
265 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
270 u8
int_to_itoa64 (const u8 c
)
272 static const u8 tbl
[0x40] =
274 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
275 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
276 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
277 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
283 u8
itoa64_to_int (const u8 c
)
285 static const u8 tbl
[0x100] =
287 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
288 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
289 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
290 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
291 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
292 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
293 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
294 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
295 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
296 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
297 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
298 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
299 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
300 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
301 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
302 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
308 u8
int_to_base64 (const u8 c
)
310 static const u8 tbl
[0x40] =
312 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
313 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
314 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
315 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
321 u8
base64_to_int (const u8 c
)
323 static const u8 tbl
[0x100] =
325 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
326 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
327 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
328 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
329 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
330 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
331 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
332 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
333 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
334 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
335 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
336 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
337 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
338 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
339 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
340 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
346 u8
int_to_bf64 (const u8 c
)
348 static const u8 tbl
[0x40] =
350 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
351 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
352 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
353 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
359 u8
bf64_to_int (const u8 c
)
361 static const u8 tbl
[0x100] =
363 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
364 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
365 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
366 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
367 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
368 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
369 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
370 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
371 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
372 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
373 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
374 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
375 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
376 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
377 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
378 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
384 u8
int_to_lotus64 (const u8 c
)
386 if (c
< 10) return '0' + c
;
387 else if (c
< 36) return 'A' + c
- 10;
388 else if (c
< 62) return 'a' + c
- 36;
389 else if (c
== 62) return '+';
390 else if (c
== 63) return '/';
395 u8
lotus64_to_int (const u8 c
)
397 if ((c
>= '0') && (c
<= '9')) return c
- '0';
398 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
399 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
400 else if (c
== '+') return 62;
401 else if (c
== '/') return 63;
407 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
409 const u8
*in_ptr
= in_buf
;
411 u8
*out_ptr
= out_buf
;
413 for (int i
= 0; i
< in_len
; i
+= 8)
415 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
416 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
417 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
418 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
419 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
420 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
421 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
422 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
424 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
425 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
426 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
427 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
428 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
434 for (int i
= 0; i
< in_len
; i
++)
436 if (in_buf
[i
] != '=') continue;
441 int out_len
= (in_len
* 5) / 8;
446 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
448 const u8
*in_ptr
= in_buf
;
450 u8
*out_ptr
= out_buf
;
452 for (int i
= 0; i
< in_len
; i
+= 5)
454 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
455 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
456 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
457 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
458 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
459 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
460 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
461 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
463 out_ptr
[0] = out_val0
& 0x7f;
464 out_ptr
[1] = out_val1
& 0x7f;
465 out_ptr
[2] = out_val2
& 0x7f;
466 out_ptr
[3] = out_val3
& 0x7f;
467 out_ptr
[4] = out_val4
& 0x7f;
468 out_ptr
[5] = out_val5
& 0x7f;
469 out_ptr
[6] = out_val6
& 0x7f;
470 out_ptr
[7] = out_val7
& 0x7f;
476 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
480 out_buf
[out_len
] = '=';
488 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
490 const u8
*in_ptr
= in_buf
;
492 u8
*out_ptr
= out_buf
;
494 for (int i
= 0; i
< in_len
; i
+= 4)
496 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
497 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
498 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
499 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
501 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
502 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
503 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
509 for (int i
= 0; i
< in_len
; i
++)
511 if (in_buf
[i
] != '=') continue;
516 int out_len
= (in_len
* 6) / 8;
521 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
523 const u8
*in_ptr
= in_buf
;
525 u8
*out_ptr
= out_buf
;
527 for (int i
= 0; i
< in_len
; i
+= 3)
529 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
530 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
531 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
532 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
534 out_ptr
[0] = out_val0
& 0x7f;
535 out_ptr
[1] = out_val1
& 0x7f;
536 out_ptr
[2] = out_val2
& 0x7f;
537 out_ptr
[3] = out_val3
& 0x7f;
543 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
547 out_buf
[out_len
] = '=';
555 int is_valid_hex_char (const u8 c
)
557 if ((c
>= '0') && (c
<= '9')) return 1;
558 if ((c
>= 'A') && (c
<= 'F')) return 1;
559 if ((c
>= 'a') && (c
<= 'f')) return 1;
564 u8
hex_convert (const u8 c
)
566 return (c
& 15) + (c
>> 6) * 9;
569 u8
hex_to_u8 (const u8 hex
[2])
573 v
|= (hex_convert (hex
[1]) << 0);
574 v
|= (hex_convert (hex
[0]) << 4);
579 u32
hex_to_u32 (const u8 hex
[8])
583 v
|= ((u32
) hex_convert (hex
[7])) << 0;
584 v
|= ((u32
) hex_convert (hex
[6])) << 4;
585 v
|= ((u32
) hex_convert (hex
[5])) << 8;
586 v
|= ((u32
) hex_convert (hex
[4])) << 12;
587 v
|= ((u32
) hex_convert (hex
[3])) << 16;
588 v
|= ((u32
) hex_convert (hex
[2])) << 20;
589 v
|= ((u32
) hex_convert (hex
[1])) << 24;
590 v
|= ((u32
) hex_convert (hex
[0])) << 28;
595 u64
hex_to_u64 (const u8 hex
[16])
599 v
|= ((u64
) hex_convert (hex
[15]) << 0);
600 v
|= ((u64
) hex_convert (hex
[14]) << 4);
601 v
|= ((u64
) hex_convert (hex
[13]) << 8);
602 v
|= ((u64
) hex_convert (hex
[12]) << 12);
603 v
|= ((u64
) hex_convert (hex
[11]) << 16);
604 v
|= ((u64
) hex_convert (hex
[10]) << 20);
605 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
606 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
607 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
608 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
609 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
610 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
611 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
612 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
613 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
614 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
619 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
621 hex
[0] = v
>> 28 & 15;
622 hex
[1] = v
>> 24 & 15;
623 hex
[2] = v
>> 20 & 15;
624 hex
[3] = v
>> 16 & 15;
625 hex
[4] = v
>> 12 & 15;
626 hex
[5] = v
>> 8 & 15;
627 hex
[6] = v
>> 4 & 15;
628 hex
[7] = v
>> 0 & 15;
632 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
633 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
634 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
635 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
636 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
637 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
638 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
639 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
646 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
650 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
659 for (int i
= 0; i
< 16; i
+= 4)
669 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
676 out
[i
+ 0] = _out
[0];
677 out
[i
+ 1] = _out
[1];
678 out
[i
+ 2] = _out
[2];
679 out
[i
+ 3] = _out
[3];
688 static void juniper_decrypt_hash (char *in
, char *out
)
692 u8 base64_buf
[100] = { 0 };
694 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
698 u32 juniper_iv
[4] = { 0 };
700 memcpy (juniper_iv
, base64_buf
, 12);
702 memcpy (out
, juniper_iv
, 12);
706 u32 juniper_key
[4] = { 0 };
708 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
709 juniper_key
[1] = byte_swap_32 (0x8df91059);
710 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
711 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
715 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
716 u32
*out_ptr
= (u32
*) (out
+ 12);
718 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
721 void phpass_decode (u8 digest
[16], u8 buf
[22])
725 l
= itoa64_to_int (buf
[ 0]) << 0;
726 l
|= itoa64_to_int (buf
[ 1]) << 6;
727 l
|= itoa64_to_int (buf
[ 2]) << 12;
728 l
|= itoa64_to_int (buf
[ 3]) << 18;
730 digest
[ 0] = (l
>> 0) & 0xff;
731 digest
[ 1] = (l
>> 8) & 0xff;
732 digest
[ 2] = (l
>> 16) & 0xff;
734 l
= itoa64_to_int (buf
[ 4]) << 0;
735 l
|= itoa64_to_int (buf
[ 5]) << 6;
736 l
|= itoa64_to_int (buf
[ 6]) << 12;
737 l
|= itoa64_to_int (buf
[ 7]) << 18;
739 digest
[ 3] = (l
>> 0) & 0xff;
740 digest
[ 4] = (l
>> 8) & 0xff;
741 digest
[ 5] = (l
>> 16) & 0xff;
743 l
= itoa64_to_int (buf
[ 8]) << 0;
744 l
|= itoa64_to_int (buf
[ 9]) << 6;
745 l
|= itoa64_to_int (buf
[10]) << 12;
746 l
|= itoa64_to_int (buf
[11]) << 18;
748 digest
[ 6] = (l
>> 0) & 0xff;
749 digest
[ 7] = (l
>> 8) & 0xff;
750 digest
[ 8] = (l
>> 16) & 0xff;
752 l
= itoa64_to_int (buf
[12]) << 0;
753 l
|= itoa64_to_int (buf
[13]) << 6;
754 l
|= itoa64_to_int (buf
[14]) << 12;
755 l
|= itoa64_to_int (buf
[15]) << 18;
757 digest
[ 9] = (l
>> 0) & 0xff;
758 digest
[10] = (l
>> 8) & 0xff;
759 digest
[11] = (l
>> 16) & 0xff;
761 l
= itoa64_to_int (buf
[16]) << 0;
762 l
|= itoa64_to_int (buf
[17]) << 6;
763 l
|= itoa64_to_int (buf
[18]) << 12;
764 l
|= itoa64_to_int (buf
[19]) << 18;
766 digest
[12] = (l
>> 0) & 0xff;
767 digest
[13] = (l
>> 8) & 0xff;
768 digest
[14] = (l
>> 16) & 0xff;
770 l
= itoa64_to_int (buf
[20]) << 0;
771 l
|= itoa64_to_int (buf
[21]) << 6;
773 digest
[15] = (l
>> 0) & 0xff;
776 void phpass_encode (u8 digest
[16], u8 buf
[22])
780 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
782 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
783 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
784 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
787 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
789 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
790 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
791 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
794 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
796 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
797 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
798 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[11] = int_to_itoa64 (l
& 0x3f);
801 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
803 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
804 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
805 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
806 buf
[15] = int_to_itoa64 (l
& 0x3f);
808 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
810 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
811 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
812 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
813 buf
[19] = int_to_itoa64 (l
& 0x3f);
815 l
= (digest
[15] << 0);
817 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
818 buf
[21] = int_to_itoa64 (l
& 0x3f);
821 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
825 l
= itoa64_to_int (buf
[ 0]) << 0;
826 l
|= itoa64_to_int (buf
[ 1]) << 6;
827 l
|= itoa64_to_int (buf
[ 2]) << 12;
828 l
|= itoa64_to_int (buf
[ 3]) << 18;
830 digest
[ 0] = (l
>> 16) & 0xff;
831 digest
[ 6] = (l
>> 8) & 0xff;
832 digest
[12] = (l
>> 0) & 0xff;
834 l
= itoa64_to_int (buf
[ 4]) << 0;
835 l
|= itoa64_to_int (buf
[ 5]) << 6;
836 l
|= itoa64_to_int (buf
[ 6]) << 12;
837 l
|= itoa64_to_int (buf
[ 7]) << 18;
839 digest
[ 1] = (l
>> 16) & 0xff;
840 digest
[ 7] = (l
>> 8) & 0xff;
841 digest
[13] = (l
>> 0) & 0xff;
843 l
= itoa64_to_int (buf
[ 8]) << 0;
844 l
|= itoa64_to_int (buf
[ 9]) << 6;
845 l
|= itoa64_to_int (buf
[10]) << 12;
846 l
|= itoa64_to_int (buf
[11]) << 18;
848 digest
[ 2] = (l
>> 16) & 0xff;
849 digest
[ 8] = (l
>> 8) & 0xff;
850 digest
[14] = (l
>> 0) & 0xff;
852 l
= itoa64_to_int (buf
[12]) << 0;
853 l
|= itoa64_to_int (buf
[13]) << 6;
854 l
|= itoa64_to_int (buf
[14]) << 12;
855 l
|= itoa64_to_int (buf
[15]) << 18;
857 digest
[ 3] = (l
>> 16) & 0xff;
858 digest
[ 9] = (l
>> 8) & 0xff;
859 digest
[15] = (l
>> 0) & 0xff;
861 l
= itoa64_to_int (buf
[16]) << 0;
862 l
|= itoa64_to_int (buf
[17]) << 6;
863 l
|= itoa64_to_int (buf
[18]) << 12;
864 l
|= itoa64_to_int (buf
[19]) << 18;
866 digest
[ 4] = (l
>> 16) & 0xff;
867 digest
[10] = (l
>> 8) & 0xff;
868 digest
[ 5] = (l
>> 0) & 0xff;
870 l
= itoa64_to_int (buf
[20]) << 0;
871 l
|= itoa64_to_int (buf
[21]) << 6;
873 digest
[11] = (l
>> 0) & 0xff;
876 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
880 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
882 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
883 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
884 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
889 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
890 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
891 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
896 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
897 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
898 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
901 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
903 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
904 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
905 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
906 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
908 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
910 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
911 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
912 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
913 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
915 l
= (digest
[11] << 0);
917 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
918 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
921 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
925 l
= itoa64_to_int (buf
[ 0]) << 0;
926 l
|= itoa64_to_int (buf
[ 1]) << 6;
927 l
|= itoa64_to_int (buf
[ 2]) << 12;
928 l
|= itoa64_to_int (buf
[ 3]) << 18;
930 digest
[ 0] = (l
>> 16) & 0xff;
931 digest
[21] = (l
>> 8) & 0xff;
932 digest
[42] = (l
>> 0) & 0xff;
934 l
= itoa64_to_int (buf
[ 4]) << 0;
935 l
|= itoa64_to_int (buf
[ 5]) << 6;
936 l
|= itoa64_to_int (buf
[ 6]) << 12;
937 l
|= itoa64_to_int (buf
[ 7]) << 18;
939 digest
[22] = (l
>> 16) & 0xff;
940 digest
[43] = (l
>> 8) & 0xff;
941 digest
[ 1] = (l
>> 0) & 0xff;
943 l
= itoa64_to_int (buf
[ 8]) << 0;
944 l
|= itoa64_to_int (buf
[ 9]) << 6;
945 l
|= itoa64_to_int (buf
[10]) << 12;
946 l
|= itoa64_to_int (buf
[11]) << 18;
948 digest
[44] = (l
>> 16) & 0xff;
949 digest
[ 2] = (l
>> 8) & 0xff;
950 digest
[23] = (l
>> 0) & 0xff;
952 l
= itoa64_to_int (buf
[12]) << 0;
953 l
|= itoa64_to_int (buf
[13]) << 6;
954 l
|= itoa64_to_int (buf
[14]) << 12;
955 l
|= itoa64_to_int (buf
[15]) << 18;
957 digest
[ 3] = (l
>> 16) & 0xff;
958 digest
[24] = (l
>> 8) & 0xff;
959 digest
[45] = (l
>> 0) & 0xff;
961 l
= itoa64_to_int (buf
[16]) << 0;
962 l
|= itoa64_to_int (buf
[17]) << 6;
963 l
|= itoa64_to_int (buf
[18]) << 12;
964 l
|= itoa64_to_int (buf
[19]) << 18;
966 digest
[25] = (l
>> 16) & 0xff;
967 digest
[46] = (l
>> 8) & 0xff;
968 digest
[ 4] = (l
>> 0) & 0xff;
970 l
= itoa64_to_int (buf
[20]) << 0;
971 l
|= itoa64_to_int (buf
[21]) << 6;
972 l
|= itoa64_to_int (buf
[22]) << 12;
973 l
|= itoa64_to_int (buf
[23]) << 18;
975 digest
[47] = (l
>> 16) & 0xff;
976 digest
[ 5] = (l
>> 8) & 0xff;
977 digest
[26] = (l
>> 0) & 0xff;
979 l
= itoa64_to_int (buf
[24]) << 0;
980 l
|= itoa64_to_int (buf
[25]) << 6;
981 l
|= itoa64_to_int (buf
[26]) << 12;
982 l
|= itoa64_to_int (buf
[27]) << 18;
984 digest
[ 6] = (l
>> 16) & 0xff;
985 digest
[27] = (l
>> 8) & 0xff;
986 digest
[48] = (l
>> 0) & 0xff;
988 l
= itoa64_to_int (buf
[28]) << 0;
989 l
|= itoa64_to_int (buf
[29]) << 6;
990 l
|= itoa64_to_int (buf
[30]) << 12;
991 l
|= itoa64_to_int (buf
[31]) << 18;
993 digest
[28] = (l
>> 16) & 0xff;
994 digest
[49] = (l
>> 8) & 0xff;
995 digest
[ 7] = (l
>> 0) & 0xff;
997 l
= itoa64_to_int (buf
[32]) << 0;
998 l
|= itoa64_to_int (buf
[33]) << 6;
999 l
|= itoa64_to_int (buf
[34]) << 12;
1000 l
|= itoa64_to_int (buf
[35]) << 18;
1002 digest
[50] = (l
>> 16) & 0xff;
1003 digest
[ 8] = (l
>> 8) & 0xff;
1004 digest
[29] = (l
>> 0) & 0xff;
1006 l
= itoa64_to_int (buf
[36]) << 0;
1007 l
|= itoa64_to_int (buf
[37]) << 6;
1008 l
|= itoa64_to_int (buf
[38]) << 12;
1009 l
|= itoa64_to_int (buf
[39]) << 18;
1011 digest
[ 9] = (l
>> 16) & 0xff;
1012 digest
[30] = (l
>> 8) & 0xff;
1013 digest
[51] = (l
>> 0) & 0xff;
1015 l
= itoa64_to_int (buf
[40]) << 0;
1016 l
|= itoa64_to_int (buf
[41]) << 6;
1017 l
|= itoa64_to_int (buf
[42]) << 12;
1018 l
|= itoa64_to_int (buf
[43]) << 18;
1020 digest
[31] = (l
>> 16) & 0xff;
1021 digest
[52] = (l
>> 8) & 0xff;
1022 digest
[10] = (l
>> 0) & 0xff;
1024 l
= itoa64_to_int (buf
[44]) << 0;
1025 l
|= itoa64_to_int (buf
[45]) << 6;
1026 l
|= itoa64_to_int (buf
[46]) << 12;
1027 l
|= itoa64_to_int (buf
[47]) << 18;
1029 digest
[53] = (l
>> 16) & 0xff;
1030 digest
[11] = (l
>> 8) & 0xff;
1031 digest
[32] = (l
>> 0) & 0xff;
1033 l
= itoa64_to_int (buf
[48]) << 0;
1034 l
|= itoa64_to_int (buf
[49]) << 6;
1035 l
|= itoa64_to_int (buf
[50]) << 12;
1036 l
|= itoa64_to_int (buf
[51]) << 18;
1038 digest
[12] = (l
>> 16) & 0xff;
1039 digest
[33] = (l
>> 8) & 0xff;
1040 digest
[54] = (l
>> 0) & 0xff;
1042 l
= itoa64_to_int (buf
[52]) << 0;
1043 l
|= itoa64_to_int (buf
[53]) << 6;
1044 l
|= itoa64_to_int (buf
[54]) << 12;
1045 l
|= itoa64_to_int (buf
[55]) << 18;
1047 digest
[34] = (l
>> 16) & 0xff;
1048 digest
[55] = (l
>> 8) & 0xff;
1049 digest
[13] = (l
>> 0) & 0xff;
1051 l
= itoa64_to_int (buf
[56]) << 0;
1052 l
|= itoa64_to_int (buf
[57]) << 6;
1053 l
|= itoa64_to_int (buf
[58]) << 12;
1054 l
|= itoa64_to_int (buf
[59]) << 18;
1056 digest
[56] = (l
>> 16) & 0xff;
1057 digest
[14] = (l
>> 8) & 0xff;
1058 digest
[35] = (l
>> 0) & 0xff;
1060 l
= itoa64_to_int (buf
[60]) << 0;
1061 l
|= itoa64_to_int (buf
[61]) << 6;
1062 l
|= itoa64_to_int (buf
[62]) << 12;
1063 l
|= itoa64_to_int (buf
[63]) << 18;
1065 digest
[15] = (l
>> 16) & 0xff;
1066 digest
[36] = (l
>> 8) & 0xff;
1067 digest
[57] = (l
>> 0) & 0xff;
1069 l
= itoa64_to_int (buf
[64]) << 0;
1070 l
|= itoa64_to_int (buf
[65]) << 6;
1071 l
|= itoa64_to_int (buf
[66]) << 12;
1072 l
|= itoa64_to_int (buf
[67]) << 18;
1074 digest
[37] = (l
>> 16) & 0xff;
1075 digest
[58] = (l
>> 8) & 0xff;
1076 digest
[16] = (l
>> 0) & 0xff;
1078 l
= itoa64_to_int (buf
[68]) << 0;
1079 l
|= itoa64_to_int (buf
[69]) << 6;
1080 l
|= itoa64_to_int (buf
[70]) << 12;
1081 l
|= itoa64_to_int (buf
[71]) << 18;
1083 digest
[59] = (l
>> 16) & 0xff;
1084 digest
[17] = (l
>> 8) & 0xff;
1085 digest
[38] = (l
>> 0) & 0xff;
1087 l
= itoa64_to_int (buf
[72]) << 0;
1088 l
|= itoa64_to_int (buf
[73]) << 6;
1089 l
|= itoa64_to_int (buf
[74]) << 12;
1090 l
|= itoa64_to_int (buf
[75]) << 18;
1092 digest
[18] = (l
>> 16) & 0xff;
1093 digest
[39] = (l
>> 8) & 0xff;
1094 digest
[60] = (l
>> 0) & 0xff;
1096 l
= itoa64_to_int (buf
[76]) << 0;
1097 l
|= itoa64_to_int (buf
[77]) << 6;
1098 l
|= itoa64_to_int (buf
[78]) << 12;
1099 l
|= itoa64_to_int (buf
[79]) << 18;
1101 digest
[40] = (l
>> 16) & 0xff;
1102 digest
[61] = (l
>> 8) & 0xff;
1103 digest
[19] = (l
>> 0) & 0xff;
1105 l
= itoa64_to_int (buf
[80]) << 0;
1106 l
|= itoa64_to_int (buf
[81]) << 6;
1107 l
|= itoa64_to_int (buf
[82]) << 12;
1108 l
|= itoa64_to_int (buf
[83]) << 18;
1110 digest
[62] = (l
>> 16) & 0xff;
1111 digest
[20] = (l
>> 8) & 0xff;
1112 digest
[41] = (l
>> 0) & 0xff;
1114 l
= itoa64_to_int (buf
[84]) << 0;
1115 l
|= itoa64_to_int (buf
[85]) << 6;
1117 digest
[63] = (l
>> 0) & 0xff;
1120 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1124 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1126 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1127 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1128 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1133 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1134 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1135 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1140 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1141 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1142 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1147 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1148 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1149 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1154 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1155 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1156 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1161 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1162 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1163 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1168 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1169 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1170 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1175 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1176 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1177 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1182 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1183 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1184 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1189 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1190 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1191 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1196 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1197 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1198 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1203 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1204 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1205 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1210 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1211 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1212 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1217 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1218 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1219 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1224 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1225 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1226 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1231 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1232 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1233 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1238 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1239 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1240 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1245 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1246 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1247 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1252 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1253 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1254 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1257 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1259 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1260 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1261 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1262 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1264 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1266 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1267 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1268 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1269 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1271 l
= 0 | 0 | (digest
[63] << 0);
1273 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1274 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1277 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1281 l
= itoa64_to_int (buf
[ 0]) << 0;
1282 l
|= itoa64_to_int (buf
[ 1]) << 6;
1283 l
|= itoa64_to_int (buf
[ 2]) << 12;
1284 l
|= itoa64_to_int (buf
[ 3]) << 18;
1286 digest
[ 2] = (l
>> 0) & 0xff;
1287 digest
[ 1] = (l
>> 8) & 0xff;
1288 digest
[ 0] = (l
>> 16) & 0xff;
1290 l
= itoa64_to_int (buf
[ 4]) << 0;
1291 l
|= itoa64_to_int (buf
[ 5]) << 6;
1292 l
|= itoa64_to_int (buf
[ 6]) << 12;
1293 l
|= itoa64_to_int (buf
[ 7]) << 18;
1295 digest
[ 5] = (l
>> 0) & 0xff;
1296 digest
[ 4] = (l
>> 8) & 0xff;
1297 digest
[ 3] = (l
>> 16) & 0xff;
1299 l
= itoa64_to_int (buf
[ 8]) << 0;
1300 l
|= itoa64_to_int (buf
[ 9]) << 6;
1301 l
|= itoa64_to_int (buf
[10]) << 12;
1302 l
|= itoa64_to_int (buf
[11]) << 18;
1304 digest
[ 8] = (l
>> 0) & 0xff;
1305 digest
[ 7] = (l
>> 8) & 0xff;
1306 digest
[ 6] = (l
>> 16) & 0xff;
1308 l
= itoa64_to_int (buf
[12]) << 0;
1309 l
|= itoa64_to_int (buf
[13]) << 6;
1310 l
|= itoa64_to_int (buf
[14]) << 12;
1311 l
|= itoa64_to_int (buf
[15]) << 18;
1313 digest
[11] = (l
>> 0) & 0xff;
1314 digest
[10] = (l
>> 8) & 0xff;
1315 digest
[ 9] = (l
>> 16) & 0xff;
1317 l
= itoa64_to_int (buf
[16]) << 0;
1318 l
|= itoa64_to_int (buf
[17]) << 6;
1319 l
|= itoa64_to_int (buf
[18]) << 12;
1320 l
|= itoa64_to_int (buf
[19]) << 18;
1322 digest
[14] = (l
>> 0) & 0xff;
1323 digest
[13] = (l
>> 8) & 0xff;
1324 digest
[12] = (l
>> 16) & 0xff;
1326 l
= itoa64_to_int (buf
[20]) << 0;
1327 l
|= itoa64_to_int (buf
[21]) << 6;
1328 l
|= itoa64_to_int (buf
[22]) << 12;
1329 l
|= itoa64_to_int (buf
[23]) << 18;
1331 digest
[17] = (l
>> 0) & 0xff;
1332 digest
[16] = (l
>> 8) & 0xff;
1333 digest
[15] = (l
>> 16) & 0xff;
1335 l
= itoa64_to_int (buf
[24]) << 0;
1336 l
|= itoa64_to_int (buf
[25]) << 6;
1337 l
|= itoa64_to_int (buf
[26]) << 12;
1339 digest
[19] = (l
>> 8) & 0xff;
1340 digest
[18] = (l
>> 16) & 0xff;
1343 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1347 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1349 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1350 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1351 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1354 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1356 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1357 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1358 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1361 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1363 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1364 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1365 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[11] = int_to_itoa64 (l
& 0x3f);
1368 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1370 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1371 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1372 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[15] = int_to_itoa64 (l
& 0x3f);
1375 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1377 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1378 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1379 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1380 buf
[19] = int_to_itoa64 (l
& 0x3f);
1382 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1384 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1385 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1386 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1387 buf
[23] = int_to_itoa64 (l
& 0x3f);
1389 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1391 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1392 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1393 buf
[26] = int_to_itoa64 (l
& 0x3f);
1396 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1400 l
= itoa64_to_int (buf
[ 0]) << 0;
1401 l
|= itoa64_to_int (buf
[ 1]) << 6;
1402 l
|= itoa64_to_int (buf
[ 2]) << 12;
1403 l
|= itoa64_to_int (buf
[ 3]) << 18;
1405 digest
[ 2] = (l
>> 0) & 0xff;
1406 digest
[ 1] = (l
>> 8) & 0xff;
1407 digest
[ 0] = (l
>> 16) & 0xff;
1409 l
= itoa64_to_int (buf
[ 4]) << 0;
1410 l
|= itoa64_to_int (buf
[ 5]) << 6;
1411 l
|= itoa64_to_int (buf
[ 6]) << 12;
1412 l
|= itoa64_to_int (buf
[ 7]) << 18;
1414 digest
[ 5] = (l
>> 0) & 0xff;
1415 digest
[ 4] = (l
>> 8) & 0xff;
1416 digest
[ 3] = (l
>> 16) & 0xff;
1418 l
= itoa64_to_int (buf
[ 8]) << 0;
1419 l
|= itoa64_to_int (buf
[ 9]) << 6;
1420 l
|= itoa64_to_int (buf
[10]) << 12;
1421 l
|= itoa64_to_int (buf
[11]) << 18;
1423 digest
[ 8] = (l
>> 0) & 0xff;
1424 digest
[ 7] = (l
>> 8) & 0xff;
1425 digest
[ 6] = (l
>> 16) & 0xff;
1427 l
= itoa64_to_int (buf
[12]) << 0;
1428 l
|= itoa64_to_int (buf
[13]) << 6;
1429 l
|= itoa64_to_int (buf
[14]) << 12;
1430 l
|= itoa64_to_int (buf
[15]) << 18;
1432 digest
[11] = (l
>> 0) & 0xff;
1433 digest
[10] = (l
>> 8) & 0xff;
1434 digest
[ 9] = (l
>> 16) & 0xff;
1436 l
= itoa64_to_int (buf
[16]) << 0;
1437 l
|= itoa64_to_int (buf
[17]) << 6;
1438 l
|= itoa64_to_int (buf
[18]) << 12;
1439 l
|= itoa64_to_int (buf
[19]) << 18;
1441 digest
[14] = (l
>> 0) & 0xff;
1442 digest
[13] = (l
>> 8) & 0xff;
1443 digest
[12] = (l
>> 16) & 0xff;
1445 l
= itoa64_to_int (buf
[20]) << 0;
1446 l
|= itoa64_to_int (buf
[21]) << 6;
1447 l
|= itoa64_to_int (buf
[22]) << 12;
1448 l
|= itoa64_to_int (buf
[23]) << 18;
1450 digest
[17] = (l
>> 0) & 0xff;
1451 digest
[16] = (l
>> 8) & 0xff;
1452 digest
[15] = (l
>> 16) & 0xff;
1454 l
= itoa64_to_int (buf
[24]) << 0;
1455 l
|= itoa64_to_int (buf
[25]) << 6;
1456 l
|= itoa64_to_int (buf
[26]) << 12;
1457 l
|= itoa64_to_int (buf
[27]) << 18;
1459 digest
[20] = (l
>> 0) & 0xff;
1460 digest
[19] = (l
>> 8) & 0xff;
1461 digest
[18] = (l
>> 16) & 0xff;
1463 l
= itoa64_to_int (buf
[28]) << 0;
1464 l
|= itoa64_to_int (buf
[29]) << 6;
1465 l
|= itoa64_to_int (buf
[30]) << 12;
1466 l
|= itoa64_to_int (buf
[31]) << 18;
1468 digest
[23] = (l
>> 0) & 0xff;
1469 digest
[22] = (l
>> 8) & 0xff;
1470 digest
[21] = (l
>> 16) & 0xff;
1472 l
= itoa64_to_int (buf
[32]) << 0;
1473 l
|= itoa64_to_int (buf
[33]) << 6;
1474 l
|= itoa64_to_int (buf
[34]) << 12;
1475 l
|= itoa64_to_int (buf
[35]) << 18;
1477 digest
[26] = (l
>> 0) & 0xff;
1478 digest
[25] = (l
>> 8) & 0xff;
1479 digest
[24] = (l
>> 16) & 0xff;
1481 l
= itoa64_to_int (buf
[36]) << 0;
1482 l
|= itoa64_to_int (buf
[37]) << 6;
1483 l
|= itoa64_to_int (buf
[38]) << 12;
1484 l
|= itoa64_to_int (buf
[39]) << 18;
1486 digest
[29] = (l
>> 0) & 0xff;
1487 digest
[28] = (l
>> 8) & 0xff;
1488 digest
[27] = (l
>> 16) & 0xff;
1490 l
= itoa64_to_int (buf
[40]) << 0;
1491 l
|= itoa64_to_int (buf
[41]) << 6;
1492 l
|= itoa64_to_int (buf
[42]) << 12;
1494 //digest[32] = (l >> 0) & 0xff;
1495 digest
[31] = (l
>> 8) & 0xff;
1496 digest
[30] = (l
>> 16) & 0xff;
1499 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1503 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1505 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1506 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1507 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1510 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1512 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1513 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1514 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1517 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1519 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1520 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1521 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[11] = int_to_itoa64 (l
& 0x3f);
1524 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1526 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1527 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1528 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[15] = int_to_itoa64 (l
& 0x3f);
1531 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1533 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1534 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1535 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[19] = int_to_itoa64 (l
& 0x3f);
1538 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1540 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1541 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1542 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[23] = int_to_itoa64 (l
& 0x3f);
1545 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1547 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1548 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1549 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[27] = int_to_itoa64 (l
& 0x3f);
1552 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1554 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1555 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1556 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[31] = int_to_itoa64 (l
& 0x3f);
1559 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1561 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1562 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1563 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1564 buf
[35] = int_to_itoa64 (l
& 0x3f);
1566 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1568 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1569 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1570 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1571 buf
[39] = int_to_itoa64 (l
& 0x3f);
1573 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1575 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1576 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1577 buf
[42] = int_to_itoa64 (l
& 0x3f);
1580 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1584 l
= itoa64_to_int (buf
[ 0]) << 0;
1585 l
|= itoa64_to_int (buf
[ 1]) << 6;
1586 l
|= itoa64_to_int (buf
[ 2]) << 12;
1587 l
|= itoa64_to_int (buf
[ 3]) << 18;
1589 digest
[ 2] = (l
>> 0) & 0xff;
1590 digest
[ 1] = (l
>> 8) & 0xff;
1591 digest
[ 0] = (l
>> 16) & 0xff;
1593 l
= itoa64_to_int (buf
[ 4]) << 0;
1594 l
|= itoa64_to_int (buf
[ 5]) << 6;
1595 l
|= itoa64_to_int (buf
[ 6]) << 12;
1596 l
|= itoa64_to_int (buf
[ 7]) << 18;
1598 digest
[ 5] = (l
>> 0) & 0xff;
1599 digest
[ 4] = (l
>> 8) & 0xff;
1600 digest
[ 3] = (l
>> 16) & 0xff;
1602 l
= itoa64_to_int (buf
[ 8]) << 0;
1603 l
|= itoa64_to_int (buf
[ 9]) << 6;
1604 l
|= itoa64_to_int (buf
[10]) << 12;
1605 l
|= itoa64_to_int (buf
[11]) << 18;
1607 digest
[ 8] = (l
>> 0) & 0xff;
1608 digest
[ 7] = (l
>> 8) & 0xff;
1609 digest
[ 6] = (l
>> 16) & 0xff;
1611 l
= itoa64_to_int (buf
[12]) << 0;
1612 l
|= itoa64_to_int (buf
[13]) << 6;
1613 l
|= itoa64_to_int (buf
[14]) << 12;
1614 l
|= itoa64_to_int (buf
[15]) << 18;
1616 digest
[11] = (l
>> 0) & 0xff;
1617 digest
[10] = (l
>> 8) & 0xff;
1618 digest
[ 9] = (l
>> 16) & 0xff;
1620 l
= itoa64_to_int (buf
[16]) << 0;
1621 l
|= itoa64_to_int (buf
[17]) << 6;
1622 l
|= itoa64_to_int (buf
[18]) << 12;
1623 l
|= itoa64_to_int (buf
[19]) << 18;
1625 digest
[14] = (l
>> 0) & 0xff;
1626 digest
[13] = (l
>> 8) & 0xff;
1627 digest
[12] = (l
>> 16) & 0xff;
1629 l
= itoa64_to_int (buf
[20]) << 0;
1630 l
|= itoa64_to_int (buf
[21]) << 6;
1631 l
|= itoa64_to_int (buf
[22]) << 12;
1632 l
|= itoa64_to_int (buf
[23]) << 18;
1634 digest
[17] = (l
>> 0) & 0xff;
1635 digest
[16] = (l
>> 8) & 0xff;
1636 digest
[15] = (l
>> 16) & 0xff;
1638 l
= itoa64_to_int (buf
[24]) << 0;
1639 l
|= itoa64_to_int (buf
[25]) << 6;
1640 l
|= itoa64_to_int (buf
[26]) << 12;
1641 l
|= itoa64_to_int (buf
[27]) << 18;
1643 digest
[20] = (l
>> 0) & 0xff;
1644 digest
[19] = (l
>> 8) & 0xff;
1645 digest
[18] = (l
>> 16) & 0xff;
1647 l
= itoa64_to_int (buf
[28]) << 0;
1648 l
|= itoa64_to_int (buf
[29]) << 6;
1649 l
|= itoa64_to_int (buf
[30]) << 12;
1650 l
|= itoa64_to_int (buf
[31]) << 18;
1652 digest
[23] = (l
>> 0) & 0xff;
1653 digest
[22] = (l
>> 8) & 0xff;
1654 digest
[21] = (l
>> 16) & 0xff;
1656 l
= itoa64_to_int (buf
[32]) << 0;
1657 l
|= itoa64_to_int (buf
[33]) << 6;
1658 l
|= itoa64_to_int (buf
[34]) << 12;
1659 l
|= itoa64_to_int (buf
[35]) << 18;
1661 digest
[26] = (l
>> 0) & 0xff;
1662 digest
[25] = (l
>> 8) & 0xff;
1663 digest
[24] = (l
>> 16) & 0xff;
1665 l
= itoa64_to_int (buf
[36]) << 0;
1666 l
|= itoa64_to_int (buf
[37]) << 6;
1667 l
|= itoa64_to_int (buf
[38]) << 12;
1668 l
|= itoa64_to_int (buf
[39]) << 18;
1670 digest
[29] = (l
>> 0) & 0xff;
1671 digest
[28] = (l
>> 8) & 0xff;
1672 digest
[27] = (l
>> 16) & 0xff;
1674 l
= itoa64_to_int (buf
[40]) << 0;
1675 l
|= itoa64_to_int (buf
[41]) << 6;
1676 l
|= itoa64_to_int (buf
[42]) << 12;
1677 l
|= itoa64_to_int (buf
[43]) << 18;
1679 digest
[32] = (l
>> 0) & 0xff;
1680 digest
[31] = (l
>> 8) & 0xff;
1681 digest
[30] = (l
>> 16) & 0xff;
1683 l
= itoa64_to_int (buf
[44]) << 0;
1684 l
|= itoa64_to_int (buf
[45]) << 6;
1685 l
|= itoa64_to_int (buf
[46]) << 12;
1686 l
|= itoa64_to_int (buf
[47]) << 18;
1688 digest
[35] = (l
>> 0) & 0xff;
1689 digest
[34] = (l
>> 8) & 0xff;
1690 digest
[33] = (l
>> 16) & 0xff;
1692 l
= itoa64_to_int (buf
[48]) << 0;
1693 l
|= itoa64_to_int (buf
[49]) << 6;
1694 l
|= itoa64_to_int (buf
[50]) << 12;
1695 l
|= itoa64_to_int (buf
[51]) << 18;
1697 digest
[38] = (l
>> 0) & 0xff;
1698 digest
[37] = (l
>> 8) & 0xff;
1699 digest
[36] = (l
>> 16) & 0xff;
1701 l
= itoa64_to_int (buf
[52]) << 0;
1702 l
|= itoa64_to_int (buf
[53]) << 6;
1703 l
|= itoa64_to_int (buf
[54]) << 12;
1704 l
|= itoa64_to_int (buf
[55]) << 18;
1706 digest
[41] = (l
>> 0) & 0xff;
1707 digest
[40] = (l
>> 8) & 0xff;
1708 digest
[39] = (l
>> 16) & 0xff;
1710 l
= itoa64_to_int (buf
[56]) << 0;
1711 l
|= itoa64_to_int (buf
[57]) << 6;
1712 l
|= itoa64_to_int (buf
[58]) << 12;
1713 l
|= itoa64_to_int (buf
[59]) << 18;
1715 digest
[44] = (l
>> 0) & 0xff;
1716 digest
[43] = (l
>> 8) & 0xff;
1717 digest
[42] = (l
>> 16) & 0xff;
1719 l
= itoa64_to_int (buf
[60]) << 0;
1720 l
|= itoa64_to_int (buf
[61]) << 6;
1721 l
|= itoa64_to_int (buf
[62]) << 12;
1722 l
|= itoa64_to_int (buf
[63]) << 18;
1724 digest
[47] = (l
>> 0) & 0xff;
1725 digest
[46] = (l
>> 8) & 0xff;
1726 digest
[45] = (l
>> 16) & 0xff;
1728 l
= itoa64_to_int (buf
[64]) << 0;
1729 l
|= itoa64_to_int (buf
[65]) << 6;
1730 l
|= itoa64_to_int (buf
[66]) << 12;
1731 l
|= itoa64_to_int (buf
[67]) << 18;
1733 digest
[50] = (l
>> 0) & 0xff;
1734 digest
[49] = (l
>> 8) & 0xff;
1735 digest
[48] = (l
>> 16) & 0xff;
1737 l
= itoa64_to_int (buf
[68]) << 0;
1738 l
|= itoa64_to_int (buf
[69]) << 6;
1739 l
|= itoa64_to_int (buf
[70]) << 12;
1740 l
|= itoa64_to_int (buf
[71]) << 18;
1742 digest
[53] = (l
>> 0) & 0xff;
1743 digest
[52] = (l
>> 8) & 0xff;
1744 digest
[51] = (l
>> 16) & 0xff;
1746 l
= itoa64_to_int (buf
[72]) << 0;
1747 l
|= itoa64_to_int (buf
[73]) << 6;
1748 l
|= itoa64_to_int (buf
[74]) << 12;
1749 l
|= itoa64_to_int (buf
[75]) << 18;
1751 digest
[56] = (l
>> 0) & 0xff;
1752 digest
[55] = (l
>> 8) & 0xff;
1753 digest
[54] = (l
>> 16) & 0xff;
1755 l
= itoa64_to_int (buf
[76]) << 0;
1756 l
|= itoa64_to_int (buf
[77]) << 6;
1757 l
|= itoa64_to_int (buf
[78]) << 12;
1758 l
|= itoa64_to_int (buf
[79]) << 18;
1760 digest
[59] = (l
>> 0) & 0xff;
1761 digest
[58] = (l
>> 8) & 0xff;
1762 digest
[57] = (l
>> 16) & 0xff;
1764 l
= itoa64_to_int (buf
[80]) << 0;
1765 l
|= itoa64_to_int (buf
[81]) << 6;
1766 l
|= itoa64_to_int (buf
[82]) << 12;
1767 l
|= itoa64_to_int (buf
[83]) << 18;
1769 digest
[62] = (l
>> 0) & 0xff;
1770 digest
[61] = (l
>> 8) & 0xff;
1771 digest
[60] = (l
>> 16) & 0xff;
1773 l
= itoa64_to_int (buf
[84]) << 0;
1774 l
|= itoa64_to_int (buf
[85]) << 6;
1776 digest
[63] = (l
>> 16) & 0xff;
1779 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1783 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1785 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1786 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1787 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1790 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1792 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1793 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1794 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1797 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1799 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1800 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1801 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[11] = int_to_itoa64 (l
& 0x3f);
1804 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1806 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1807 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1808 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[15] = int_to_itoa64 (l
& 0x3f);
1811 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1813 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1814 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1815 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[19] = int_to_itoa64 (l
& 0x3f);
1818 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1820 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1821 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1822 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[23] = int_to_itoa64 (l
& 0x3f);
1825 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1827 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1828 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1829 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[27] = int_to_itoa64 (l
& 0x3f);
1832 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1834 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1835 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1836 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[31] = int_to_itoa64 (l
& 0x3f);
1839 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1841 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1842 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1843 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[35] = int_to_itoa64 (l
& 0x3f);
1846 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1848 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1849 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1850 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[39] = int_to_itoa64 (l
& 0x3f);
1853 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1855 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1856 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1857 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[43] = int_to_itoa64 (l
& 0x3f);
1860 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1862 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1863 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1864 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[47] = int_to_itoa64 (l
& 0x3f);
1867 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1869 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1870 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1871 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[51] = int_to_itoa64 (l
& 0x3f);
1874 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1876 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1877 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1878 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[55] = int_to_itoa64 (l
& 0x3f);
1881 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1883 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1884 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1885 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[59] = int_to_itoa64 (l
& 0x3f);
1888 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1890 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1891 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1892 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[63] = int_to_itoa64 (l
& 0x3f);
1895 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1897 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1898 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1899 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[67] = int_to_itoa64 (l
& 0x3f);
1902 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1904 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1905 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1906 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[71] = int_to_itoa64 (l
& 0x3f);
1909 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1911 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1912 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1913 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[75] = int_to_itoa64 (l
& 0x3f);
1916 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1918 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1919 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1920 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1921 buf
[79] = int_to_itoa64 (l
& 0x3f);
1923 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1925 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1926 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1927 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1928 buf
[83] = int_to_itoa64 (l
& 0x3f);
1930 l
= 0 | 0 | (digest
[63] << 16);
1932 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1933 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1936 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1940 l
= itoa64_to_int (buf
[ 0]) << 0;
1941 l
|= itoa64_to_int (buf
[ 1]) << 6;
1942 l
|= itoa64_to_int (buf
[ 2]) << 12;
1943 l
|= itoa64_to_int (buf
[ 3]) << 18;
1945 digest
[ 0] = (l
>> 16) & 0xff;
1946 digest
[10] = (l
>> 8) & 0xff;
1947 digest
[20] = (l
>> 0) & 0xff;
1949 l
= itoa64_to_int (buf
[ 4]) << 0;
1950 l
|= itoa64_to_int (buf
[ 5]) << 6;
1951 l
|= itoa64_to_int (buf
[ 6]) << 12;
1952 l
|= itoa64_to_int (buf
[ 7]) << 18;
1954 digest
[21] = (l
>> 16) & 0xff;
1955 digest
[ 1] = (l
>> 8) & 0xff;
1956 digest
[11] = (l
>> 0) & 0xff;
1958 l
= itoa64_to_int (buf
[ 8]) << 0;
1959 l
|= itoa64_to_int (buf
[ 9]) << 6;
1960 l
|= itoa64_to_int (buf
[10]) << 12;
1961 l
|= itoa64_to_int (buf
[11]) << 18;
1963 digest
[12] = (l
>> 16) & 0xff;
1964 digest
[22] = (l
>> 8) & 0xff;
1965 digest
[ 2] = (l
>> 0) & 0xff;
1967 l
= itoa64_to_int (buf
[12]) << 0;
1968 l
|= itoa64_to_int (buf
[13]) << 6;
1969 l
|= itoa64_to_int (buf
[14]) << 12;
1970 l
|= itoa64_to_int (buf
[15]) << 18;
1972 digest
[ 3] = (l
>> 16) & 0xff;
1973 digest
[13] = (l
>> 8) & 0xff;
1974 digest
[23] = (l
>> 0) & 0xff;
1976 l
= itoa64_to_int (buf
[16]) << 0;
1977 l
|= itoa64_to_int (buf
[17]) << 6;
1978 l
|= itoa64_to_int (buf
[18]) << 12;
1979 l
|= itoa64_to_int (buf
[19]) << 18;
1981 digest
[24] = (l
>> 16) & 0xff;
1982 digest
[ 4] = (l
>> 8) & 0xff;
1983 digest
[14] = (l
>> 0) & 0xff;
1985 l
= itoa64_to_int (buf
[20]) << 0;
1986 l
|= itoa64_to_int (buf
[21]) << 6;
1987 l
|= itoa64_to_int (buf
[22]) << 12;
1988 l
|= itoa64_to_int (buf
[23]) << 18;
1990 digest
[15] = (l
>> 16) & 0xff;
1991 digest
[25] = (l
>> 8) & 0xff;
1992 digest
[ 5] = (l
>> 0) & 0xff;
1994 l
= itoa64_to_int (buf
[24]) << 0;
1995 l
|= itoa64_to_int (buf
[25]) << 6;
1996 l
|= itoa64_to_int (buf
[26]) << 12;
1997 l
|= itoa64_to_int (buf
[27]) << 18;
1999 digest
[ 6] = (l
>> 16) & 0xff;
2000 digest
[16] = (l
>> 8) & 0xff;
2001 digest
[26] = (l
>> 0) & 0xff;
2003 l
= itoa64_to_int (buf
[28]) << 0;
2004 l
|= itoa64_to_int (buf
[29]) << 6;
2005 l
|= itoa64_to_int (buf
[30]) << 12;
2006 l
|= itoa64_to_int (buf
[31]) << 18;
2008 digest
[27] = (l
>> 16) & 0xff;
2009 digest
[ 7] = (l
>> 8) & 0xff;
2010 digest
[17] = (l
>> 0) & 0xff;
2012 l
= itoa64_to_int (buf
[32]) << 0;
2013 l
|= itoa64_to_int (buf
[33]) << 6;
2014 l
|= itoa64_to_int (buf
[34]) << 12;
2015 l
|= itoa64_to_int (buf
[35]) << 18;
2017 digest
[18] = (l
>> 16) & 0xff;
2018 digest
[28] = (l
>> 8) & 0xff;
2019 digest
[ 8] = (l
>> 0) & 0xff;
2021 l
= itoa64_to_int (buf
[36]) << 0;
2022 l
|= itoa64_to_int (buf
[37]) << 6;
2023 l
|= itoa64_to_int (buf
[38]) << 12;
2024 l
|= itoa64_to_int (buf
[39]) << 18;
2026 digest
[ 9] = (l
>> 16) & 0xff;
2027 digest
[19] = (l
>> 8) & 0xff;
2028 digest
[29] = (l
>> 0) & 0xff;
2030 l
= itoa64_to_int (buf
[40]) << 0;
2031 l
|= itoa64_to_int (buf
[41]) << 6;
2032 l
|= itoa64_to_int (buf
[42]) << 12;
2034 digest
[31] = (l
>> 8) & 0xff;
2035 digest
[30] = (l
>> 0) & 0xff;
2038 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2042 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2044 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2045 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2046 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2051 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2052 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2053 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2058 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2059 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2060 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2065 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2066 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2067 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2072 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2073 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2074 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2079 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2080 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2081 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2086 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2087 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2088 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2093 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2094 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2095 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2098 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2100 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2101 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2102 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2103 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2105 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2107 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2108 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2109 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2110 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2112 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2114 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2115 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2116 buf
[42] = int_to_itoa64 (l
& 0x3f);
2119 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2123 l
= itoa64_to_int (buf
[ 0]) << 0;
2124 l
|= itoa64_to_int (buf
[ 1]) << 6;
2125 l
|= itoa64_to_int (buf
[ 2]) << 12;
2126 l
|= itoa64_to_int (buf
[ 3]) << 18;
2128 digest
[ 0] = (l
>> 0) & 0xff;
2129 digest
[ 1] = (l
>> 8) & 0xff;
2130 digest
[ 2] = (l
>> 16) & 0xff;
2132 l
= itoa64_to_int (buf
[ 4]) << 0;
2133 l
|= itoa64_to_int (buf
[ 5]) << 6;
2134 l
|= itoa64_to_int (buf
[ 6]) << 12;
2135 l
|= itoa64_to_int (buf
[ 7]) << 18;
2137 digest
[ 3] = (l
>> 0) & 0xff;
2138 digest
[ 4] = (l
>> 8) & 0xff;
2139 digest
[ 5] = (l
>> 16) & 0xff;
2141 l
= itoa64_to_int (buf
[ 8]) << 0;
2142 l
|= itoa64_to_int (buf
[ 9]) << 6;
2143 l
|= itoa64_to_int (buf
[10]) << 12;
2144 l
|= itoa64_to_int (buf
[11]) << 18;
2146 digest
[ 6] = (l
>> 0) & 0xff;
2147 digest
[ 7] = (l
>> 8) & 0xff;
2148 digest
[ 8] = (l
>> 16) & 0xff;
2150 l
= itoa64_to_int (buf
[12]) << 0;
2151 l
|= itoa64_to_int (buf
[13]) << 6;
2152 l
|= itoa64_to_int (buf
[14]) << 12;
2153 l
|= itoa64_to_int (buf
[15]) << 18;
2155 digest
[ 9] = (l
>> 0) & 0xff;
2156 digest
[10] = (l
>> 8) & 0xff;
2157 digest
[11] = (l
>> 16) & 0xff;
2159 l
= itoa64_to_int (buf
[16]) << 0;
2160 l
|= itoa64_to_int (buf
[17]) << 6;
2161 l
|= itoa64_to_int (buf
[18]) << 12;
2162 l
|= itoa64_to_int (buf
[19]) << 18;
2164 digest
[12] = (l
>> 0) & 0xff;
2165 digest
[13] = (l
>> 8) & 0xff;
2166 digest
[14] = (l
>> 16) & 0xff;
2168 l
= itoa64_to_int (buf
[20]) << 0;
2169 l
|= itoa64_to_int (buf
[21]) << 6;
2170 l
|= itoa64_to_int (buf
[22]) << 12;
2171 l
|= itoa64_to_int (buf
[23]) << 18;
2173 digest
[15] = (l
>> 0) & 0xff;
2174 digest
[16] = (l
>> 8) & 0xff;
2175 digest
[17] = (l
>> 16) & 0xff;
2177 l
= itoa64_to_int (buf
[24]) << 0;
2178 l
|= itoa64_to_int (buf
[25]) << 6;
2179 l
|= itoa64_to_int (buf
[26]) << 12;
2180 l
|= itoa64_to_int (buf
[27]) << 18;
2182 digest
[18] = (l
>> 0) & 0xff;
2183 digest
[19] = (l
>> 8) & 0xff;
2184 digest
[20] = (l
>> 16) & 0xff;
2186 l
= itoa64_to_int (buf
[28]) << 0;
2187 l
|= itoa64_to_int (buf
[29]) << 6;
2188 l
|= itoa64_to_int (buf
[30]) << 12;
2189 l
|= itoa64_to_int (buf
[31]) << 18;
2191 digest
[21] = (l
>> 0) & 0xff;
2192 digest
[22] = (l
>> 8) & 0xff;
2193 digest
[23] = (l
>> 16) & 0xff;
2195 l
= itoa64_to_int (buf
[32]) << 0;
2196 l
|= itoa64_to_int (buf
[33]) << 6;
2197 l
|= itoa64_to_int (buf
[34]) << 12;
2198 l
|= itoa64_to_int (buf
[35]) << 18;
2200 digest
[24] = (l
>> 0) & 0xff;
2201 digest
[25] = (l
>> 8) & 0xff;
2202 digest
[26] = (l
>> 16) & 0xff;
2204 l
= itoa64_to_int (buf
[36]) << 0;
2205 l
|= itoa64_to_int (buf
[37]) << 6;
2206 l
|= itoa64_to_int (buf
[38]) << 12;
2207 l
|= itoa64_to_int (buf
[39]) << 18;
2209 digest
[27] = (l
>> 0) & 0xff;
2210 digest
[28] = (l
>> 8) & 0xff;
2211 digest
[29] = (l
>> 16) & 0xff;
2213 l
= itoa64_to_int (buf
[40]) << 0;
2214 l
|= itoa64_to_int (buf
[41]) << 6;
2215 l
|= itoa64_to_int (buf
[42]) << 12;
2216 l
|= itoa64_to_int (buf
[43]) << 18;
2218 digest
[30] = (l
>> 0) & 0xff;
2219 digest
[31] = (l
>> 8) & 0xff;
2220 digest
[32] = (l
>> 16) & 0xff;
2255 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2259 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2261 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2262 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2263 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2266 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2268 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2269 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2270 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2273 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2275 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2276 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2277 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[11] = int_to_itoa64 (l
& 0x3f);
2280 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2282 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2283 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2284 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[15] = int_to_itoa64 (l
& 0x3f);
2287 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2289 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2290 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2291 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[19] = int_to_itoa64 (l
& 0x3f);
2294 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2296 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2297 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2298 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[23] = int_to_itoa64 (l
& 0x3f);
2301 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2303 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2304 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2305 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[27] = int_to_itoa64 (l
& 0x3f);
2308 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2310 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2311 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2312 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[31] = int_to_itoa64 (l
& 0x3f);
2315 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2317 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2318 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2319 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2320 buf
[35] = int_to_itoa64 (l
& 0x3f);
2322 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2324 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2325 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2326 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2327 buf
[39] = int_to_itoa64 (l
& 0x3f);
2329 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2331 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2332 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2333 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2334 //buf[43] = int_to_itoa64 (l & 0x3f);
2342 static struct termios savemodes
;
2343 static int havemodes
= 0;
2347 struct termios modmodes
;
2349 if (tcgetattr (fileno (stdin
), &savemodes
) < 0) return -1;
2353 modmodes
= savemodes
;
2354 modmodes
.c_lflag
&= ~ICANON
;
2355 modmodes
.c_cc
[VMIN
] = 1;
2356 modmodes
.c_cc
[VTIME
] = 0;
2358 return tcsetattr (fileno (stdin
), TCSANOW
, &modmodes
);
2367 FD_SET (fileno (stdin
), &rfds
);
2374 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2376 if (retval
== 0) return 0;
2377 if (retval
== -1) return -1;
2384 if (!havemodes
) return 0;
2386 return tcsetattr (fileno (stdin
), TCSADRAIN
, &savemodes
);
2390 #if defined(DARWIN) || defined(__FreeBSD__)
2391 static struct termios savemodes
;
2392 static int havemodes
= 0;
2396 struct termios modmodes
;
2398 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2402 modmodes
= savemodes
;
2403 modmodes
.c_lflag
&= ~ICANON
;
2404 modmodes
.c_cc
[VMIN
] = 1;
2405 modmodes
.c_cc
[VTIME
] = 0;
2407 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2416 FD_SET (fileno (stdin
), &rfds
);
2423 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2425 if (retval
== 0) return 0;
2426 if (retval
== -1) return -1;
2433 if (!havemodes
) return 0;
2435 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2440 static DWORD saveMode
= 0;
2444 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2446 GetConsoleMode (stdinHandle
, &saveMode
);
2447 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2454 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2456 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2458 if (rc
== WAIT_TIMEOUT
) return 0;
2459 if (rc
== WAIT_ABANDONED
) return -1;
2460 if (rc
== WAIT_FAILED
) return -1;
2462 // The whole ReadConsoleInput () part is a workaround.
2463 // For some unknown reason, maybe a mingw bug, a random signal
2464 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2465 // Then it wants to read with getche () a keyboard input
2466 // which has never been made.
2468 INPUT_RECORD buf
[100];
2472 memset (buf
, 0, sizeof (buf
));
2474 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2476 FlushConsoleInputBuffer (stdinHandle
);
2478 for (uint i
= 0; i
< num
; i
++)
2480 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2482 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2484 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2486 return KeyEvent
.uChar
.AsciiChar
;
2494 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2496 SetConsoleMode (stdinHandle
, saveMode
);
2506 #define MSG_ENOMEM "Insufficient memory available"
2508 void *mycalloc (size_t nmemb
, size_t size
)
2510 void *p
= calloc (nmemb
, size
);
2514 log_error ("ERROR: %s", MSG_ENOMEM
);
2522 void *mymalloc (size_t size
)
2524 void *p
= malloc (size
);
2528 log_error ("ERROR: %s", MSG_ENOMEM
);
2533 memset (p
, 0, size
);
2538 void myfree (void *ptr
)
2540 if (ptr
== NULL
) return;
2545 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2547 void *p
= realloc (ptr
, oldsz
+ add
);
2551 log_error ("ERROR: %s", MSG_ENOMEM
);
2556 memset ((char *) p
+ oldsz
, 0, add
);
2561 char *mystrdup (const char *s
)
2563 const size_t len
= strlen (s
);
2565 char *b
= (char *) mymalloc (len
+ 1);
2572 FILE *logfile_open (char *logfile
)
2574 FILE *fp
= fopen (logfile
, "ab");
2584 void logfile_close (FILE *fp
)
2586 if (fp
== stdout
) return;
2591 void logfile_append (const char *fmt
, ...)
2593 if (data
.logfile_disable
== 1) return;
2595 FILE *fp
= logfile_open (data
.logfile
);
2601 vfprintf (fp
, fmt
, ap
);
2612 int logfile_generate_id ()
2614 const int n
= rand ();
2623 char *logfile_generate_topid ()
2625 const int id
= logfile_generate_id ();
2627 char *topid
= (char *) mymalloc (1 + 16 + 1);
2629 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2634 char *logfile_generate_subid ()
2636 const int id
= logfile_generate_id ();
2638 char *subid
= (char *) mymalloc (1 + 16 + 1);
2640 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2650 void lock_file (FILE *fp
)
2654 memset (&lock
, 0, sizeof (struct flock
));
2656 lock
.l_type
= F_WRLCK
;
2657 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2661 log_error ("ERROR: Failed acquiring write lock: %s", strerror (errno
));
2668 void unlock_file (FILE *fp
)
2672 memset (&lock
, 0, sizeof (struct flock
));
2674 lock
.l_type
= F_UNLCK
;
2675 fcntl(fileno(fp
), F_SETLK
, &lock
);
2682 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2684 FlushFileBuffers (h
);
2694 int get_adapters_num_adl (void *adl
, int *iNumberAdapters
)
2696 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2698 if (iNumberAdapters
== 0)
2700 log_info ("WARN: No ADL adapters found.");
2709 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2711 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2712 ADLODParameters lpOdParameters;
2714 lpOdParameters.iSize = sizeof (ADLODParameters);
2715 size_t plevels_size = 0;
2717 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2719 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2720 __func__, iAdapterIndex,
2721 lpOdParameters.iNumberOfPerformanceLevels,
2722 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2723 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2725 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2727 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2729 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2731 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2733 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2734 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2735 __func__, iAdapterIndex, j,
2736 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2738 myfree (lpOdPerformanceLevels);
2744 LPAdapterInfo
hm_get_adapter_info_adl (void *adl
, int iNumberAdapters
)
2746 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2748 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2750 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2752 return lpAdapterInfo
;
2755 int hm_get_adapter_index_nvapi (HM_ADAPTER_NVAPI nvapiGPUHandle
[DEVICES_MAX
])
2759 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nvapi
, nvapiGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2763 log_info ("WARN: No NvAPI adapters found");
2771 int hm_get_adapter_index_nvml (HM_ADAPTER_NVML nvmlGPUHandle
[DEVICES_MAX
])
2775 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2777 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nvml
, 1, i
, &nvmlGPUHandle
[i
]) != NVML_SUCCESS
) break;
2779 // can be used to determine if the device by index matches the cuda device by index
2780 // char name[100]; memset (name, 0, sizeof (name));
2781 // hm_NVML_nvmlDeviceGetName (data.hm_nvml, nvGPUHandle[i], name, sizeof (name) - 1);
2788 log_info ("WARN: No NVML adapters found");
2798 // does not help at all, since ADL does not assign different bus id, device id when we have multi GPU setups
2801 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2805 for (uint i = 0; i < num_adl_adapters; i++)
2807 int opencl_bus_num = hm_device[i].busid;
2808 int opencl_dev_num = hm_device[i].devid;
2810 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2818 if (idx >= DEVICES_MAX) return -1;
2823 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2825 for (uint i = 0; i < opencl_num_devices; i++)
2827 cl_device_topology_amd device_topology;
2829 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2831 hm_device[i].busid = device_topology.pcie.bus;
2832 hm_device[i].devid = device_topology.pcie.device;
2837 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2839 // basically bubble sort
2841 for (int i
= 0; i
< num_adl_adapters
; i
++)
2843 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2845 // get info of adapter [x]
2847 u32 adapter_index_x
= valid_adl_device_list
[j
];
2848 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2850 u32 bus_num_x
= info_x
.iBusNumber
;
2851 u32 dev_num_x
= info_x
.iDeviceNumber
;
2853 // get info of adapter [y]
2855 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2856 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2858 u32 bus_num_y
= info_y
.iBusNumber
;
2859 u32 dev_num_y
= info_y
.iDeviceNumber
;
2863 if (bus_num_y
< bus_num_x
)
2867 else if (bus_num_y
== bus_num_x
)
2869 if (dev_num_y
< dev_num_x
)
2877 u32 temp
= valid_adl_device_list
[j
+ 1];
2879 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2880 valid_adl_device_list
[j
+ 0] = temp
;
2886 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2888 *num_adl_adapters
= 0;
2890 u32
*adl_adapters
= NULL
;
2892 int *bus_numbers
= NULL
;
2893 int *device_numbers
= NULL
;
2895 for (int i
= 0; i
< iNumberAdapters
; i
++)
2897 AdapterInfo info
= lpAdapterInfo
[i
];
2899 if (strlen (info
.strUDID
) < 1) continue;
2902 if (info
.iVendorID
!= 1002) continue;
2904 if (info
.iVendorID
!= 0x1002) continue;
2907 if (info
.iBusNumber
< 0) continue;
2908 if (info
.iDeviceNumber
< 0) continue;
2912 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2914 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2921 if (found
) continue;
2923 // add it to the list
2925 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2927 adl_adapters
[*num_adl_adapters
] = i
;
2929 // rest is just bookkeeping
2931 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2932 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2934 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2935 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2937 (*num_adl_adapters
)++;
2940 myfree (bus_numbers
);
2941 myfree (device_numbers
);
2943 // sort the list by increasing bus id, device id number
2945 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2947 return adl_adapters
;
2950 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2952 // loop through all valid devices
2954 for (int i
= 0; i
< num_adl_adapters
; i
++)
2956 u32 adapter_index
= valid_adl_device_list
[i
];
2960 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2962 // unfortunately this doesn't work since bus id and dev id are not unique
2963 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2964 // if (opencl_device_index == -1) continue;
2966 int opencl_device_index
= i
;
2968 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2970 // get fanspeed info
2972 if (hm_device
[opencl_device_index
].od_version
== 5)
2974 ADLFanSpeedInfo FanSpeedInfo
;
2976 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2978 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2980 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2982 // check read and write capability in fanspeedinfo
2984 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2985 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2987 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2991 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2994 else // od_version == 6
2996 ADLOD6FanSpeedInfo faninfo
;
2998 memset (&faninfo
, 0, sizeof (faninfo
));
3000 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
3002 // check read capability in fanspeedinfo
3004 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
3006 hm_device
[opencl_device_index
].fan_get_supported
= 1;
3010 hm_device
[opencl_device_index
].fan_get_supported
= 0;
3018 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3020 for (int i
= 0; i
< num_adl_adapters
; i
++)
3022 u32 adapter_index
= valid_adl_device_list
[i
];
3026 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3028 // get overdrive version
3030 int od_supported
= 0;
3034 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3036 // store the overdrive version in hm_device
3038 // unfortunately this doesn't work since bus id and dev id are not unique
3039 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3040 // if (opencl_device_index == -1) continue;
3042 int opencl_device_index
= i
;
3044 hm_device
[opencl_device_index
].od_version
= od_version
;
3050 int hm_get_adapter_index_adl (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3052 for (int i
= 0; i
< num_adl_adapters
; i
++)
3054 u32 adapter_index
= valid_adl_device_list
[i
];
3058 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3060 // store the iAdapterIndex in hm_device
3062 // unfortunately this doesn't work since bus id and dev id are not unique
3063 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3064 // if (opencl_device_index == -1) continue;
3066 int opencl_device_index
= i
;
3068 hm_device
[opencl_device_index
].adl
= info
.iAdapterIndex
;
3071 return num_adl_adapters
;
3074 int hm_get_threshold_slowdown_with_device_id (const uint device_id
)
3076 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3078 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3082 if (data
.hm_device
[device_id
].od_version
== 5)
3086 else if (data
.hm_device
[device_id
].od_version
== 6)
3088 int CurrentValue
= 0;
3089 int DefaultValue
= 0;
3091 if (hm_ADL_Overdrive6_TargetTemperatureData_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &CurrentValue
, &DefaultValue
) != ADL_OK
) return -1;
3093 // the return value has never been tested since hm_ADL_Overdrive6_TargetTemperatureData_Get() never worked on any system. expect problems.
3095 return DefaultValue
;
3100 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3104 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SLOWDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3112 int hm_get_threshold_shutdown_with_device_id (const uint device_id
)
3114 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3116 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3120 if (data
.hm_device
[device_id
].od_version
== 5)
3124 else if (data
.hm_device
[device_id
].od_version
== 6)
3131 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3135 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SHUTDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3143 int hm_get_temperature_with_device_id (const uint device_id
)
3145 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3147 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3151 if (data
.hm_device
[device_id
].od_version
== 5)
3153 ADLTemperature Temperature
;
3155 Temperature
.iSize
= sizeof (ADLTemperature
);
3157 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &Temperature
) != ADL_OK
) return -1;
3159 return Temperature
.iTemperature
/ 1000;
3161 else if (data
.hm_device
[device_id
].od_version
== 6)
3163 int Temperature
= 0;
3165 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &Temperature
) != ADL_OK
) return -1;
3167 return Temperature
/ 1000;
3172 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3174 int temperature
= 0;
3176 if (hm_NVML_nvmlDeviceGetTemperature (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
) != NVML_SUCCESS
) return -1;
3184 int hm_get_fanpolicy_with_device_id (const uint device_id
)
3186 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3188 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3190 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3194 if (data
.hm_device
[device_id
].od_version
== 5)
3196 ADLFanSpeedValue lpFanSpeedValue
;
3198 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3200 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3201 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3203 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3205 return (lpFanSpeedValue
.iFanSpeed
& ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
) ? 0 : 1;
3207 else // od_version == 6
3214 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3223 int hm_get_fanspeed_with_device_id (const uint device_id
)
3225 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3227 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3229 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3233 if (data
.hm_device
[device_id
].od_version
== 5)
3235 ADLFanSpeedValue lpFanSpeedValue
;
3237 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3239 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3240 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3241 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3243 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3245 return lpFanSpeedValue
.iFanSpeed
;
3247 else // od_version == 6
3249 ADLOD6FanSpeedInfo faninfo
;
3251 memset (&faninfo
, 0, sizeof (faninfo
));
3253 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &faninfo
) != ADL_OK
) return -1;
3255 return faninfo
.iFanSpeedPercent
;
3260 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3264 if (hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nvml
, 0, data
.hm_device
[device_id
].nvml
, (uint
*) &speed
) != NVML_SUCCESS
) return -1;
3273 int hm_get_buslanes_with_device_id (const uint device_id
)
3275 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3277 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3281 ADLPMActivity PMActivity
;
3283 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3285 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3287 return PMActivity
.iCurrentBusLanes
;
3291 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3293 unsigned int currLinkWidth
;
3295 if (hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &currLinkWidth
) != NVML_SUCCESS
) return -1;
3297 return currLinkWidth
;
3303 int hm_get_utilization_with_device_id (const uint device_id
)
3305 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3307 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3311 ADLPMActivity PMActivity
;
3313 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3315 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3317 return PMActivity
.iActivityPercent
;
3321 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3323 nvmlUtilization_t utilization
;
3325 if (hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &utilization
) != NVML_SUCCESS
) return -1;
3327 return utilization
.gpu
;
3333 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3335 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3337 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3341 ADLPMActivity PMActivity
;
3343 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3345 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3347 return PMActivity
.iMemoryClock
/ 100;
3351 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3355 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_MEM
, &clock
) != NVML_SUCCESS
) return -1;
3363 int hm_get_corespeed_with_device_id (const uint device_id
)
3365 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3367 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3371 ADLPMActivity PMActivity
;
3373 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3375 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3377 return PMActivity
.iEngineClock
/ 100;
3381 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3385 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_SM
, &clock
) != NVML_SUCCESS
) return -1;
3393 int hm_get_throttle_with_device_id (const uint device_id
)
3395 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3397 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3402 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3404 unsigned long long clocksThrottleReasons
= 0;
3405 unsigned long long supportedThrottleReasons
= 0;
3407 if (hm_NVML_nvmlDeviceGetCurrentClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &clocksThrottleReasons
) != NVML_SUCCESS
) return -1;
3408 if (hm_NVML_nvmlDeviceGetSupportedClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &supportedThrottleReasons
) != NVML_SUCCESS
) return -1;
3410 clocksThrottleReasons
&= supportedThrottleReasons
;
3411 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonGpuIdle
;
3412 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonApplicationsClocksSetting
;
3413 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonUnknown
;
3415 if (data
.kernel_power_final
)
3417 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonHwSlowdown
;
3420 return (clocksThrottleReasons
!= nvmlClocksThrottleReasonNone
);
3426 int hm_set_fanspeed_with_device_id_adl (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3428 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3434 if (data
.hm_device
[device_id
].od_version
== 5)
3436 ADLFanSpeedValue lpFanSpeedValue
;
3438 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3440 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3441 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3442 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3443 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3445 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3449 else // od_version == 6
3451 ADLOD6FanSpeedValue fan_speed_value
;
3453 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3455 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3456 fan_speed_value
.iFanSpeed
= fanspeed
;
3458 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &fan_speed_value
) != ADL_OK
) return -1;
3465 if (data
.hm_device
[device_id
].od_version
== 5)
3467 if (hm_ADL_Overdrive5_FanSpeedToDefault_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0) != ADL_OK
) return -1;
3471 else // od_version == 6
3473 if (hm_ADL_Overdrive6_FanSpeed_Reset (data
.hm_adl
, data
.hm_device
[device_id
].adl
) != ADL_OK
) return -1;
3484 int hm_set_fanspeed_with_device_id_nvapi (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3486 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3492 NV_GPU_COOLER_LEVELS CoolerLevels
= { 0 };
3494 CoolerLevels
.Version
= GPU_COOLER_LEVELS_VER
| sizeof (NV_GPU_COOLER_LEVELS
);
3496 CoolerLevels
.Levels
[0].Level
= fanspeed
;
3497 CoolerLevels
.Levels
[0].Policy
= 1;
3499 if (hm_NvAPI_GPU_SetCoolerLevels (data
.hm_nvapi
, data
.hm_device
[device_id
].nvapi
, 0, &CoolerLevels
) != NVAPI_OK
) return -1;
3505 if (hm_NvAPI_GPU_RestoreCoolerSettings (data
.hm_nvapi
, data
.hm_device
[device_id
].nvapi
, 0) != NVAPI_OK
) return -1;
3515 int hm_set_fanspeed_with_device_id_xnvctrl (const uint device_id
, const int fanspeed
)
3517 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3519 if (data
.hm_xnvctrl
)
3521 if (set_fan_speed_target (data
.hm_xnvctrl
, data
.hm_device
[device_id
].xnvctrl
, fanspeed
) != 0) return -1;
3530 #endif // HAVE_HWMON
3536 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3538 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3540 if (css_cnt
> SP_PW_MAX
)
3542 log_error ("ERROR: Mask length is too long");
3547 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3549 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3551 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3552 uint cs_len
= css
[css_pos
].cs_len
;
3554 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3556 uint c
= cs_buf
[cs_pos
] & 0xff;
3563 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3565 cs_t
*cs
= &css
[css_cnt
];
3567 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3569 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3573 for (i
= 0; i
< cs
->cs_len
; i
++)
3575 const uint u
= cs
->cs_buf
[i
];
3580 for (i
= 0; i
< in_len
; i
++)
3582 uint u
= in_buf
[i
] & 0xff;
3584 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3586 if (css_uniq
[u
] == 1) continue;
3590 cs
->cs_buf
[cs
->cs_len
] = u
;
3598 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3602 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3604 uint p0
= in_buf
[in_pos
] & 0xff;
3606 if (interpret
== 1 && p0
== '?')
3610 if (in_pos
== in_len
) break;
3612 uint p1
= in_buf
[in_pos
] & 0xff;
3616 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3618 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3620 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3622 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3624 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3626 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3628 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3629 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3631 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3632 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3634 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3635 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3637 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3638 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3640 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3642 default: log_error ("Syntax error: %s", in_buf
);
3648 if (data
.hex_charset
)
3652 if (in_pos
== in_len
)
3654 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3659 uint p1
= in_buf
[in_pos
] & 0xff;
3661 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3663 log_error ("ERROR: Invalid hex character detected in mask %s", in_buf
);
3670 chr
= hex_convert (p1
) << 0;
3671 chr
|= hex_convert (p0
) << 4;
3673 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3679 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3685 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3689 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3691 sum
*= css
[css_pos
].cs_len
;
3697 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3699 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3704 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3706 char p0
= mask_buf
[mask_pos
];
3712 if (mask_pos
== mask_len
) break;
3714 char p1
= mask_buf
[mask_pos
];
3720 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3722 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3724 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3726 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3728 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3730 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3732 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3733 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3735 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3736 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3738 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3739 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3741 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3742 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3744 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3746 default: log_error ("ERROR: Syntax error: %s", mask_buf
);
3752 if (data
.hex_charset
)
3756 // if there is no 2nd hex character, show an error:
3758 if (mask_pos
== mask_len
)
3760 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3765 char p1
= mask_buf
[mask_pos
];
3767 // if they are not valid hex character, show an error:
3769 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3771 log_error ("ERROR: Invalid hex character detected in mask %s", mask_buf
);
3778 chr
|= hex_convert (p1
) << 0;
3779 chr
|= hex_convert (p0
) << 4;
3781 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3787 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3794 log_error ("ERROR: Invalid mask length (0)");
3804 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3806 for (int i
= 0; i
< css_cnt
; i
++)
3808 uint len
= css
[i
].cs_len
;
3809 u64 next
= val
/ len
;
3810 uint pos
= val
% len
;
3811 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3816 void mp_cut_at (char *mask
, uint max
)
3820 uint mask_len
= strlen (mask
);
3822 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3824 if (mask
[i
] == '?') i
++;
3830 void mp_setup_sys (cs_t
*mp_sys
)
3834 uint donec
[CHARSIZ
] = { 0 };
3836 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3837 mp_sys
[0].cs_buf
[pos
++] = chr
;
3838 mp_sys
[0].cs_len
= pos
; }
3840 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3841 mp_sys
[1].cs_buf
[pos
++] = chr
;
3842 mp_sys
[1].cs_len
= pos
; }
3844 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3845 mp_sys
[2].cs_buf
[pos
++] = chr
;
3846 mp_sys
[2].cs_len
= pos
; }
3848 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3849 mp_sys
[3].cs_buf
[pos
++] = chr
;
3850 mp_sys
[3].cs_len
= pos
; }
3852 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3853 mp_sys
[4].cs_len
= pos
; }
3855 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3856 mp_sys
[5].cs_len
= pos
; }
3859 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3861 FILE *fp
= fopen (buf
, "rb");
3863 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3865 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3869 char mp_file
[1024] = { 0 };
3871 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3875 len
= in_superchop (mp_file
);
3879 log_info ("WARNING: Charset file corrupted");
3881 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3885 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3890 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3892 mp_usr
[index
].cs_len
= 0;
3894 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3897 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3899 char *new_mask_buf
= (char *) mymalloc (256);
3905 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3907 if (css_pos
== len
) break;
3909 char p0
= mask_buf
[mask_pos
];
3911 new_mask_buf
[mask_pos
] = p0
;
3917 if (mask_pos
== mask_len
) break;
3919 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3923 if (data
.hex_charset
)
3927 if (mask_pos
== mask_len
)
3929 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3934 char p1
= mask_buf
[mask_pos
];
3936 // if they are not valid hex character, show an error:
3938 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3940 log_error ("ERROR: Invalid hex character detected in mask: %s", mask_buf
);
3945 new_mask_buf
[mask_pos
] = p1
;
3950 if (css_pos
== len
) return (new_mask_buf
);
3952 myfree (new_mask_buf
);
3961 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3967 for (i
= start
; i
< stop
; i
++)
3969 sum
*= root_css_buf
[i
].cs_len
;
3975 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3979 cs_t
*cs
= &root_css_buf
[start
];
3983 for (i
= start
; i
< stop
; i
++)
3985 const u64 m
= v
% cs
->cs_len
;
3986 const u64 d
= v
/ cs
->cs_len
;
3990 const uint k
= cs
->cs_buf
[m
];
3992 pw_buf
[i
- start
] = (char) k
;
3994 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3998 int sp_comp_val (const void *p1
, const void *p2
)
4000 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
4001 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
4003 return b2
->val
- b1
->val
;
4006 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
4013 * Initialize hcstats
4016 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
4018 u64
*root_stats_ptr
= root_stats_buf
;
4020 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
4022 for (i
= 0; i
< SP_PW_MAX
; i
++)
4024 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
4026 root_stats_ptr
+= CHARSIZ
;
4029 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
4031 u64
*markov_stats_ptr
= markov_stats_buf
;
4033 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4035 for (i
= 0; i
< SP_PW_MAX
; i
++)
4037 for (j
= 0; j
< CHARSIZ
; j
++)
4039 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
4041 markov_stats_ptr
+= CHARSIZ
;
4051 char hcstat_tmp
[256] = { 0 };
4053 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
4055 hcstat
= hcstat_tmp
;
4058 FILE *fd
= fopen (hcstat
, "rb");
4062 log_error ("%s: %s", hcstat
, strerror (errno
));
4067 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
4069 log_error ("%s: Could not load data", hcstat
);
4076 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
4078 log_error ("%s: Could not load data", hcstat
);
4088 * Markov modifier of hcstat_table on user request
4093 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4094 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4099 /* Add all stats to first position */
4101 for (i
= 1; i
< SP_PW_MAX
; i
++)
4103 u64
*out
= root_stats_buf_by_pos
[0];
4104 u64
*in
= root_stats_buf_by_pos
[i
];
4106 for (j
= 0; j
< CHARSIZ
; j
++)
4112 for (i
= 1; i
< SP_PW_MAX
; i
++)
4114 u64
*out
= markov_stats_buf_by_key
[0][0];
4115 u64
*in
= markov_stats_buf_by_key
[i
][0];
4117 for (j
= 0; j
< CHARSIZ
; j
++)
4119 for (k
= 0; k
< CHARSIZ
; k
++)
4126 /* copy them to all pw_positions */
4128 for (i
= 1; i
< SP_PW_MAX
; i
++)
4130 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4133 for (i
= 1; i
< SP_PW_MAX
; i
++)
4135 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4143 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4145 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4147 for (i
= 0; i
< SP_PW_MAX
; i
++)
4149 root_table_buf_by_pos
[i
] = root_table_ptr
;
4151 root_table_ptr
+= CHARSIZ
;
4154 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4156 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4158 for (i
= 0; i
< SP_PW_MAX
; i
++)
4160 for (j
= 0; j
< CHARSIZ
; j
++)
4162 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4164 markov_table_ptr
+= CHARSIZ
;
4169 * Convert hcstat to tables
4172 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4174 uint key
= i
% CHARSIZ
;
4176 root_table_buf
[i
].key
= key
;
4177 root_table_buf
[i
].val
= root_stats_buf
[i
];
4180 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4182 uint key
= i
% CHARSIZ
;
4184 markov_table_buf
[i
].key
= key
;
4185 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4188 myfree (root_stats_buf
);
4189 myfree (markov_stats_buf
);
4195 for (i
= 0; i
< SP_PW_MAX
; i
++)
4197 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4200 for (i
= 0; i
< SP_PW_MAX
; i
++)
4202 for (j
= 0; j
< CHARSIZ
; j
++)
4204 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4209 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
4212 * Convert tables to css
4215 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4217 uint pw_pos
= i
/ CHARSIZ
;
4219 cs_t
*cs
= &root_css_buf
[pw_pos
];
4221 if (cs
->cs_len
== threshold
) continue;
4223 uint key
= root_table_buf
[i
].key
;
4225 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4227 cs
->cs_buf
[cs
->cs_len
] = key
;
4233 * Convert table to css
4236 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4238 uint c
= i
/ CHARSIZ
;
4240 cs_t
*cs
= &markov_css_buf
[c
];
4242 if (cs
->cs_len
== threshold
) continue;
4244 uint pw_pos
= c
/ CHARSIZ
;
4246 uint key
= markov_table_buf
[i
].key
;
4248 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4250 cs
->cs_buf
[cs
->cs_len
] = key
;
4256 for (uint i = 0; i < 8; i++)
4258 for (uint j = 0x20; j < 0x80; j++)
4260 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4262 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4264 for (uint k = 0; k < 10; k++)
4266 printf (" %u\n", ptr->cs_buf[k]);
4273 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4275 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4277 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4287 for (uint j
= 1; j
< CHARSIZ
; j
++)
4297 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4299 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4301 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4303 out
+= CHARSIZ
* CHARSIZ
;
4304 in
+= CHARSIZ
* CHARSIZ
;
4306 for (uint j
= 0; j
< CHARSIZ
; j
++)
4313 for (uint k
= 1; k
< CHARSIZ
; k
++)
4325 * mixed shared functions
4328 void dump_hex (const u8
*s
, const int sz
)
4330 for (int i
= 0; i
< sz
; i
++)
4332 log_info_nn ("%02x ", s
[i
]);
4338 void usage_mini_print (const char *progname
)
4340 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4343 void usage_big_print (const char *progname
)
4345 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4348 char *get_exec_path ()
4350 int exec_path_len
= 1024;
4352 char *exec_path
= (char *) mymalloc (exec_path_len
);
4356 char tmp
[32] = { 0 };
4358 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4360 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4364 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4368 uint size
= exec_path_len
;
4370 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4372 log_error("! executable path buffer too small\n");
4377 const int len
= strlen (exec_path
);
4381 #include <sys/sysctl.h>
4386 mib
[2] = KERN_PROC_PATHNAME
;
4389 char tmp
[32] = { 0 };
4391 size_t size
= exec_path_len
;
4392 sysctl(mib
, 4, exec_path
, &size
, NULL
, 0);
4394 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4397 #error Your Operating System is not supported or detected
4405 char *get_install_dir (const char *progname
)
4407 char *install_dir
= mystrdup (progname
);
4408 char *last_slash
= NULL
;
4410 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4414 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4420 install_dir
[0] = '.';
4424 return (install_dir
);
4427 char *get_profile_dir (const char *homedir
)
4429 #define DOT_HASHCAT ".hashcat"
4431 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4433 char *profile_dir
= (char *) mymalloc (len
+ 1);
4435 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4440 char *get_session_dir (const char *profile_dir
)
4442 #define SESSIONS_FOLDER "sessions"
4444 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4446 char *session_dir
= (char *) mymalloc (len
+ 1);
4448 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4453 uint
count_lines (FILE *fd
)
4457 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4463 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4465 if (nread
< 1) continue;
4469 for (i
= 0; i
< nread
; i
++)
4471 if (prev
== '\n') cnt
++;
4482 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4486 FILE *fd
= fopen (filename
, "rb");
4490 log_error ("%s: %s", filename
, strerror (errno
));
4495 #define MAX_KEY_SIZE (1024 * 1024)
4497 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4499 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4505 for (int fpos
= 0; fpos
< nread
; fpos
++)
4507 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4509 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4510 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4511 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4512 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4514 if (kpos
>= 64) kpos
= 0;
4521 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4525 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4526 if (CPU_ISSET(core
, cpu_set
)) break;
4528 thread_affinity_policy_data_t policy
= { core
};
4530 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4532 if (data
.quiet
== 0)
4534 if (rc
!= KERN_SUCCESS
)
4536 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4544 void set_cpu_affinity (char *cpu_affinity
)
4547 DWORD_PTR aff_mask
= 0;
4558 char *devices
= strdup (cpu_affinity
);
4560 char *next
= strtok (devices
, ",");
4564 uint cpu_id
= atoi (next
);
4579 log_error ("ERROR: Invalid cpu_id %u specified", cpu_id
);
4585 aff_mask
|= 1 << (cpu_id
- 1);
4587 CPU_SET ((cpu_id
- 1), &cpuset
);
4590 } while ((next
= strtok (NULL
, ",")) != NULL
);
4596 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4597 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4599 pthread_t thread
= pthread_self ();
4600 pthread_setaffinity_np (thread
, sizeof (cpuset_t
), &cpuset
);
4602 pthread_t thread
= pthread_self ();
4603 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4607 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4609 char *element
, *end
;
4611 end
= (char *) base
+ nmemb
* size
;
4613 for (element
= (char *) base
; element
< end
; element
+= size
)
4614 if (!compar (element
, key
))
4620 int sort_by_u32 (const void *v1
, const void *v2
)
4622 const u32
*s1
= (const u32
*) v1
;
4623 const u32
*s2
= (const u32
*) v2
;
4628 int sort_by_salt (const void *v1
, const void *v2
)
4630 const salt_t
*s1
= (const salt_t
*) v1
;
4631 const salt_t
*s2
= (const salt_t
*) v2
;
4633 const int res1
= s1
->salt_len
- s2
->salt_len
;
4635 if (res1
!= 0) return (res1
);
4637 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4639 if (res2
!= 0) return (res2
);
4647 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4648 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4655 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4656 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4662 int sort_by_salt_buf (const void *v1
, const void *v2
)
4664 const pot_t
*p1
= (const pot_t
*) v1
;
4665 const pot_t
*p2
= (const pot_t
*) v2
;
4667 const hash_t
*h1
= &p1
->hash
;
4668 const hash_t
*h2
= &p2
->hash
;
4670 const salt_t
*s1
= h1
->salt
;
4671 const salt_t
*s2
= h2
->salt
;
4677 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4678 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4684 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4686 const hash_t
*h1
= (const hash_t
*) v1
;
4687 const hash_t
*h2
= (const hash_t
*) v2
;
4689 const salt_t
*s1
= h1
->salt
;
4690 const salt_t
*s2
= h2
->salt
;
4692 // testphase: this should work
4697 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4698 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4701 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4702 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4703 if (s1->salt_len > s2->salt_len) return ( 1);
4704 if (s1->salt_len < s2->salt_len) return (-1);
4706 uint n = s1->salt_len;
4710 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4711 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4718 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4720 const hash_t
*h1
= (const hash_t
*) v1
;
4721 const hash_t
*h2
= (const hash_t
*) v2
;
4723 const salt_t
*s1
= h1
->salt
;
4724 const salt_t
*s2
= h2
->salt
;
4726 // 16 - 2 (since last 2 uints contain the digest)
4731 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4732 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4738 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4740 const hash_t
*h1
= (const hash_t
*) v1
;
4741 const hash_t
*h2
= (const hash_t
*) v2
;
4743 const void *d1
= h1
->digest
;
4744 const void *d2
= h2
->digest
;
4746 return data
.sort_by_digest (d1
, d2
);
4749 int sort_by_hash (const void *v1
, const void *v2
)
4751 const hash_t
*h1
= (const hash_t
*) v1
;
4752 const hash_t
*h2
= (const hash_t
*) v2
;
4756 const salt_t
*s1
= h1
->salt
;
4757 const salt_t
*s2
= h2
->salt
;
4759 int res
= sort_by_salt (s1
, s2
);
4761 if (res
!= 0) return (res
);
4764 const void *d1
= h1
->digest
;
4765 const void *d2
= h2
->digest
;
4767 return data
.sort_by_digest (d1
, d2
);
4770 int sort_by_pot (const void *v1
, const void *v2
)
4772 const pot_t
*p1
= (const pot_t
*) v1
;
4773 const pot_t
*p2
= (const pot_t
*) v2
;
4775 const hash_t
*h1
= &p1
->hash
;
4776 const hash_t
*h2
= &p2
->hash
;
4778 return sort_by_hash (h1
, h2
);
4781 int sort_by_mtime (const void *p1
, const void *p2
)
4783 const char **f1
= (const char **) p1
;
4784 const char **f2
= (const char **) p2
;
4786 struct stat s1
; stat (*f1
, &s1
);
4787 struct stat s2
; stat (*f2
, &s2
);
4789 return s2
.st_mtime
- s1
.st_mtime
;
4792 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4794 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4795 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4797 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4800 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4802 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4803 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4805 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4808 int sort_by_stringptr (const void *p1
, const void *p2
)
4810 const char **s1
= (const char **) p1
;
4811 const char **s2
= (const char **) p2
;
4813 return strcmp (*s1
, *s2
);
4816 int sort_by_dictstat (const void *s1
, const void *s2
)
4818 dictstat_t
*d1
= (dictstat_t
*) s1
;
4819 dictstat_t
*d2
= (dictstat_t
*) s2
;
4822 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4824 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4827 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4830 int sort_by_bitmap (const void *p1
, const void *p2
)
4832 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4833 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4835 return b1
->collisions
- b2
->collisions
;
4838 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4840 const u32
*d1
= (const u32
*) v1
;
4841 const u32
*d2
= (const u32
*) v2
;
4847 if (d1
[n
] > d2
[n
]) return ( 1);
4848 if (d1
[n
] < d2
[n
]) return (-1);
4854 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4856 const u32
*d1
= (const u32
*) v1
;
4857 const u32
*d2
= (const u32
*) v2
;
4863 if (d1
[n
] > d2
[n
]) return ( 1);
4864 if (d1
[n
] < d2
[n
]) return (-1);
4870 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4872 const u32
*d1
= (const u32
*) v1
;
4873 const u32
*d2
= (const u32
*) v2
;
4879 if (d1
[n
] > d2
[n
]) return ( 1);
4880 if (d1
[n
] < d2
[n
]) return (-1);
4886 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4888 const u32
*d1
= (const u32
*) v1
;
4889 const u32
*d2
= (const u32
*) v2
;
4895 if (d1
[n
] > d2
[n
]) return ( 1);
4896 if (d1
[n
] < d2
[n
]) return (-1);
4902 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4904 const u32
*d1
= (const u32
*) v1
;
4905 const u32
*d2
= (const u32
*) v2
;
4911 if (d1
[n
] > d2
[n
]) return ( 1);
4912 if (d1
[n
] < d2
[n
]) return (-1);
4918 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4920 const u32
*d1
= (const u32
*) v1
;
4921 const u32
*d2
= (const u32
*) v2
;
4927 if (d1
[n
] > d2
[n
]) return ( 1);
4928 if (d1
[n
] < d2
[n
]) return (-1);
4934 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4936 const u32
*d1
= (const u32
*) v1
;
4937 const u32
*d2
= (const u32
*) v2
;
4943 if (d1
[n
] > d2
[n
]) return ( 1);
4944 if (d1
[n
] < d2
[n
]) return (-1);
4950 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4952 const u32
*d1
= (const u32
*) v1
;
4953 const u32
*d2
= (const u32
*) v2
;
4959 if (d1
[n
] > d2
[n
]) return ( 1);
4960 if (d1
[n
] < d2
[n
]) return (-1);
4966 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4968 const u64
*d1
= (const u64
*) v1
;
4969 const u64
*d2
= (const u64
*) v2
;
4975 if (d1
[n
] > d2
[n
]) return ( 1);
4976 if (d1
[n
] < d2
[n
]) return (-1);
4982 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4984 const u64
*d1
= (const u64
*) v1
;
4985 const u64
*d2
= (const u64
*) v2
;
4991 if (d1
[n
] > d2
[n
]) return ( 1);
4992 if (d1
[n
] < d2
[n
]) return (-1);
4998 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
5000 const u64
*d1
= (const u64
*) v1
;
5001 const u64
*d2
= (const u64
*) v2
;
5007 if (d1
[n
] > d2
[n
]) return ( 1);
5008 if (d1
[n
] < d2
[n
]) return (-1);
5014 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
5016 const u32
*d1
= (const u32
*) v1
;
5017 const u32
*d2
= (const u32
*) v2
;
5019 const uint dgst_pos0
= data
.dgst_pos0
;
5020 const uint dgst_pos1
= data
.dgst_pos1
;
5021 const uint dgst_pos2
= data
.dgst_pos2
;
5022 const uint dgst_pos3
= data
.dgst_pos3
;
5024 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
5025 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
5026 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
5027 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
5028 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
5029 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
5030 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
5031 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
5036 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
5038 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
5039 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
5041 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
5043 if (res1
!= 0) return (res1
);
5048 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
5050 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
5051 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
5053 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
5055 if (res1
!= 0) return (res1
);
5057 const int res2
= t1
->attack_mode
5060 if (res2
!= 0) return (res2
);
5062 const int res3
= t1
->hash_type
5065 if (res3
!= 0) return (res3
);
5070 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
)
5072 uint outfile_autohex
= data
.outfile_autohex
;
5074 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
5076 FILE *debug_fp
= NULL
;
5078 if (debug_file
!= NULL
)
5080 debug_fp
= fopen (debug_file
, "ab");
5082 lock_file (debug_fp
);
5089 if (debug_fp
== NULL
)
5091 log_info ("WARNING: Could not open debug-file for writing");
5095 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
5097 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
5099 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
5102 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
5104 if (debug_mode
== 4)
5106 fputc (':', debug_fp
);
5108 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5111 fputc ('\n', debug_fp
);
5113 if (debug_file
!= NULL
) fclose (debug_fp
);
5117 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5119 int needs_hexify
= 0;
5121 if (outfile_autohex
== 1)
5123 for (uint i
= 0; i
< plain_len
; i
++)
5125 if (plain_ptr
[i
] < 0x20)
5132 if (plain_ptr
[i
] > 0x7f)
5141 if (needs_hexify
== 1)
5143 fprintf (fp
, "$HEX[");
5145 for (uint i
= 0; i
< plain_len
; i
++)
5147 fprintf (fp
, "%02x", plain_ptr
[i
]);
5154 fwrite (plain_ptr
, plain_len
, 1, fp
);
5158 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
)
5160 uint outfile_format
= data
.outfile_format
;
5162 char separator
= data
.separator
;
5164 if (outfile_format
& OUTFILE_FMT_HASH
)
5166 fprintf (out_fp
, "%s", out_buf
);
5168 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5170 fputc (separator
, out_fp
);
5173 else if (data
.username
)
5175 if (username
!= NULL
)
5177 for (uint i
= 0; i
< user_len
; i
++)
5179 fprintf (out_fp
, "%c", username
[i
]);
5182 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5184 fputc (separator
, out_fp
);
5189 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5191 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5193 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5195 fputc (separator
, out_fp
);
5199 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5201 for (uint i
= 0; i
< plain_len
; i
++)
5203 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5206 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5208 fputc (separator
, out_fp
);
5212 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5215 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5220 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5222 fprintf (out_fp
, "%llu", crackpos
);
5227 fputc ('\n', out_fp
);
5230 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
)
5234 pot_key
.hash
.salt
= hashes_buf
->salt
;
5235 pot_key
.hash
.digest
= hashes_buf
->digest
;
5237 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5243 input_buf
[input_len
] = 0;
5246 unsigned char *username
= NULL
;
5251 user_t
*user
= hashes_buf
->hash_info
->user
;
5255 username
= (unsigned char *) (user
->user_name
);
5257 user_len
= user
->user_len
;
5261 // do output the line
5262 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5266 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5267 #define LM_MASKED_PLAIN "[notfound]"
5269 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
)
5275 pot_left_key
.hash
.salt
= hash_left
->salt
;
5276 pot_left_key
.hash
.digest
= hash_left
->digest
;
5278 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5282 uint weak_hash_found
= 0;
5284 pot_t pot_right_key
;
5286 pot_right_key
.hash
.salt
= hash_right
->salt
;
5287 pot_right_key
.hash
.digest
= hash_right
->digest
;
5289 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5291 if (pot_right_ptr
== NULL
)
5293 // special case, if "weak hash"
5295 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5297 weak_hash_found
= 1;
5299 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5301 // in theory this is not needed, but we are paranoia:
5303 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5304 pot_right_ptr
->plain_len
= 0;
5308 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5310 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
5315 // at least one half was found:
5319 input_buf
[input_len
] = 0;
5323 unsigned char *username
= NULL
;
5328 user_t
*user
= hash_left
->hash_info
->user
;
5332 username
= (unsigned char *) (user
->user_name
);
5334 user_len
= user
->user_len
;
5338 // mask the part which was not found
5340 uint left_part_masked
= 0;
5341 uint right_part_masked
= 0;
5343 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5345 if (pot_left_ptr
== NULL
)
5347 left_part_masked
= 1;
5349 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5351 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5353 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5354 pot_left_ptr
->plain_len
= mask_plain_len
;
5357 if (pot_right_ptr
== NULL
)
5359 right_part_masked
= 1;
5361 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5363 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5365 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5366 pot_right_ptr
->plain_len
= mask_plain_len
;
5369 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5373 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5375 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5377 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5379 // do output the line
5381 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5383 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5385 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5386 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5389 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
)
5393 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5395 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5397 if (pot_ptr
== NULL
)
5401 input_buf
[input_len
] = 0;
5403 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5407 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
)
5413 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5415 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5419 pot_t pot_right_key
;
5421 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5423 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5425 uint weak_hash_found
= 0;
5427 if (pot_right_ptr
== NULL
)
5429 // special case, if "weak hash"
5431 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5433 weak_hash_found
= 1;
5435 // we just need that pot_right_ptr is not a NULL pointer
5437 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5441 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5443 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5448 // ... at least one part was not cracked
5452 input_buf
[input_len
] = 0;
5454 // only show the hash part which is still not cracked
5456 uint user_len
= input_len
- 32;
5458 char *hash_output
= (char *) mymalloc (33);
5460 memcpy (hash_output
, input_buf
, input_len
);
5462 if (pot_left_ptr
!= NULL
)
5464 // only show right part (because left part was already found)
5466 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5468 hash_output
[user_len
+ 16] = 0;
5471 if (pot_right_ptr
!= NULL
)
5473 // only show left part (because right part was already found)
5475 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5477 hash_output
[user_len
+ 16] = 0;
5480 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5482 myfree (hash_output
);
5484 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5487 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5489 uint opencl_platforms_filter
= 0;
5491 if (opencl_platforms
)
5493 char *platforms
= strdup (opencl_platforms
);
5495 char *next
= strtok (platforms
, ",");
5499 int platform
= atoi (next
);
5501 if (platform
< 1 || platform
> 32)
5503 log_error ("ERROR: Invalid OpenCL platform %u specified", platform
);
5508 opencl_platforms_filter
|= 1 << (platform
- 1);
5510 } while ((next
= strtok (NULL
, ",")) != NULL
);
5516 opencl_platforms_filter
= -1;
5519 return opencl_platforms_filter
;
5522 u32
setup_devices_filter (char *opencl_devices
)
5524 u32 devices_filter
= 0;
5528 char *devices
= strdup (opencl_devices
);
5530 char *next
= strtok (devices
, ",");
5534 int device_id
= atoi (next
);
5536 if (device_id
< 1 || device_id
> 32)
5538 log_error ("ERROR: Invalid device_id %u specified", device_id
);
5543 devices_filter
|= 1 << (device_id
- 1);
5545 } while ((next
= strtok (NULL
, ",")) != NULL
);
5551 devices_filter
= -1;
5554 return devices_filter
;
5557 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5559 cl_device_type device_types_filter
= 0;
5561 if (opencl_device_types
)
5563 char *device_types
= strdup (opencl_device_types
);
5565 char *next
= strtok (device_types
, ",");
5569 int device_type
= atoi (next
);
5571 if (device_type
< 1 || device_type
> 3)
5573 log_error ("ERROR: Invalid device_type %u specified", device_type
);
5578 device_types_filter
|= 1 << device_type
;
5580 } while ((next
= strtok (NULL
, ",")) != NULL
);
5582 free (device_types
);
5586 // Do not use CPU by default, this often reduces GPU performance because
5587 // the CPU is too busy to handle GPU synchronization
5589 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5592 return device_types_filter
;
5595 u32
get_random_num (const u32 min
, const u32 max
)
5597 if (min
== max
) return (min
);
5599 return ((rand () % (max
- min
)) + min
);
5602 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5604 u32 quotient
= dividend
/ divisor
;
5606 if (dividend
% divisor
) quotient
++;
5611 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5613 u64 quotient
= dividend
/ divisor
;
5615 if (dividend
% divisor
) quotient
++;
5620 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5622 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5623 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5625 if (tm
->tm_year
- 70)
5627 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5628 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5630 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5632 else if (tm
->tm_yday
)
5634 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5635 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5637 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5639 else if (tm
->tm_hour
)
5641 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5642 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5644 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5646 else if (tm
->tm_min
)
5648 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5649 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5651 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5655 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5657 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5661 void format_speed_display (float val
, char *buf
, size_t len
)
5672 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5683 /* generate output */
5687 snprintf (buf
, len
- 1, "%.0f ", val
);
5691 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5695 void lowercase (u8
*buf
, int len
)
5697 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5700 void uppercase (u8
*buf
, int len
)
5702 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5705 int fgetl (FILE *fp
, char *line_buf
)
5711 const int c
= fgetc (fp
);
5713 if (c
== EOF
) break;
5715 line_buf
[line_len
] = (char) c
;
5719 if (line_len
== HCBUFSIZ
) line_len
--;
5721 if (c
== '\n') break;
5724 if (line_len
== 0) return 0;
5726 if (line_buf
[line_len
- 1] == '\n')
5730 line_buf
[line_len
] = 0;
5733 if (line_len
== 0) return 0;
5735 if (line_buf
[line_len
- 1] == '\r')
5739 line_buf
[line_len
] = 0;
5745 int in_superchop (char *buf
)
5747 int len
= strlen (buf
);
5751 if (buf
[len
- 1] == '\n')
5758 if (buf
[len
- 1] == '\r')
5773 char **scan_directory (const char *path
)
5775 char *tmp_path
= mystrdup (path
);
5777 size_t tmp_path_len
= strlen (tmp_path
);
5779 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5781 tmp_path
[tmp_path_len
- 1] = 0;
5783 tmp_path_len
= strlen (tmp_path
);
5786 char **files
= NULL
;
5792 if ((d
= opendir (tmp_path
)) != NULL
)
5798 memset (&e
, 0, sizeof (e
));
5799 struct dirent
*de
= NULL
;
5801 if (readdir_r (d
, &e
, &de
) != 0)
5803 log_error ("ERROR: readdir_r() failed");
5808 if (de
== NULL
) break;
5812 while ((de
= readdir (d
)) != NULL
)
5815 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5817 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5819 char *path_file
= (char *) mymalloc (path_size
+ 1);
5821 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5823 path_file
[path_size
] = 0;
5827 if ((d_test
= opendir (path_file
)) != NULL
)
5835 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5839 files
[num_files
- 1] = path_file
;
5845 else if (errno
== ENOTDIR
)
5847 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5851 files
[num_files
- 1] = mystrdup (path
);
5854 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5858 files
[num_files
- 1] = NULL
;
5865 int count_dictionaries (char **dictionary_files
)
5867 if (dictionary_files
== NULL
) return 0;
5871 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5879 char *stroptitype (const uint opti_type
)
5883 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5884 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5885 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5886 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5887 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5888 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5889 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5890 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5891 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5892 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5893 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5894 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5895 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5896 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5897 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5898 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5899 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5900 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5901 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5907 char *strparser (const uint parser_status
)
5909 switch (parser_status
)
5911 case PARSER_OK
: return ((char *) PA_000
); break;
5912 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5913 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5914 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5915 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5916 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5917 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5918 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5919 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5920 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5921 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5922 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5923 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5924 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5925 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5926 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5927 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5930 return ((char *) PA_255
);
5933 char *strhashtype (const uint hash_mode
)
5937 case 0: return ((char *) HT_00000
); break;
5938 case 10: return ((char *) HT_00010
); break;
5939 case 11: return ((char *) HT_00011
); break;
5940 case 12: return ((char *) HT_00012
); break;
5941 case 20: return ((char *) HT_00020
); break;
5942 case 21: return ((char *) HT_00021
); break;
5943 case 22: return ((char *) HT_00022
); break;
5944 case 23: return ((char *) HT_00023
); break;
5945 case 30: return ((char *) HT_00030
); break;
5946 case 40: return ((char *) HT_00040
); break;
5947 case 50: return ((char *) HT_00050
); break;
5948 case 60: return ((char *) HT_00060
); break;
5949 case 100: return ((char *) HT_00100
); break;
5950 case 101: return ((char *) HT_00101
); break;
5951 case 110: return ((char *) HT_00110
); break;
5952 case 111: return ((char *) HT_00111
); break;
5953 case 112: return ((char *) HT_00112
); break;
5954 case 120: return ((char *) HT_00120
); break;
5955 case 121: return ((char *) HT_00121
); break;
5956 case 122: return ((char *) HT_00122
); break;
5957 case 124: return ((char *) HT_00124
); break;
5958 case 125: return ((char *) HT_00125
); break;
5959 case 130: return ((char *) HT_00130
); break;
5960 case 131: return ((char *) HT_00131
); break;
5961 case 132: return ((char *) HT_00132
); break;
5962 case 133: return ((char *) HT_00133
); break;
5963 case 140: return ((char *) HT_00140
); break;
5964 case 141: return ((char *) HT_00141
); break;
5965 case 150: return ((char *) HT_00150
); break;
5966 case 160: return ((char *) HT_00160
); break;
5967 case 200: return ((char *) HT_00200
); break;
5968 case 300: return ((char *) HT_00300
); break;
5969 case 400: return ((char *) HT_00400
); break;
5970 case 500: return ((char *) HT_00500
); break;
5971 case 501: return ((char *) HT_00501
); break;
5972 case 900: return ((char *) HT_00900
); break;
5973 case 910: return ((char *) HT_00910
); break;
5974 case 1000: return ((char *) HT_01000
); break;
5975 case 1100: return ((char *) HT_01100
); break;
5976 case 1400: return ((char *) HT_01400
); break;
5977 case 1410: return ((char *) HT_01410
); break;
5978 case 1420: return ((char *) HT_01420
); break;
5979 case 1421: return ((char *) HT_01421
); break;
5980 case 1430: return ((char *) HT_01430
); break;
5981 case 1440: return ((char *) HT_01440
); break;
5982 case 1441: return ((char *) HT_01441
); break;
5983 case 1450: return ((char *) HT_01450
); break;
5984 case 1460: return ((char *) HT_01460
); break;
5985 case 1500: return ((char *) HT_01500
); break;
5986 case 1600: return ((char *) HT_01600
); break;
5987 case 1700: return ((char *) HT_01700
); break;
5988 case 1710: return ((char *) HT_01710
); break;
5989 case 1711: return ((char *) HT_01711
); break;
5990 case 1720: return ((char *) HT_01720
); break;
5991 case 1722: return ((char *) HT_01722
); break;
5992 case 1730: return ((char *) HT_01730
); break;
5993 case 1731: return ((char *) HT_01731
); break;
5994 case 1740: return ((char *) HT_01740
); break;
5995 case 1750: return ((char *) HT_01750
); break;
5996 case 1760: return ((char *) HT_01760
); break;
5997 case 1800: return ((char *) HT_01800
); break;
5998 case 2100: return ((char *) HT_02100
); break;
5999 case 2400: return ((char *) HT_02400
); break;
6000 case 2410: return ((char *) HT_02410
); break;
6001 case 2500: return ((char *) HT_02500
); break;
6002 case 2600: return ((char *) HT_02600
); break;
6003 case 2611: return ((char *) HT_02611
); break;
6004 case 2612: return ((char *) HT_02612
); break;
6005 case 2711: return ((char *) HT_02711
); break;
6006 case 2811: return ((char *) HT_02811
); break;
6007 case 3000: return ((char *) HT_03000
); break;
6008 case 3100: return ((char *) HT_03100
); break;
6009 case 3200: return ((char *) HT_03200
); break;
6010 case 3710: return ((char *) HT_03710
); break;
6011 case 3711: return ((char *) HT_03711
); break;
6012 case 3800: return ((char *) HT_03800
); break;
6013 case 4300: return ((char *) HT_04300
); break;
6014 case 4400: return ((char *) HT_04400
); break;
6015 case 4500: return ((char *) HT_04500
); break;
6016 case 4700: return ((char *) HT_04700
); break;
6017 case 4800: return ((char *) HT_04800
); break;
6018 case 4900: return ((char *) HT_04900
); break;
6019 case 5000: return ((char *) HT_05000
); break;
6020 case 5100: return ((char *) HT_05100
); break;
6021 case 5200: return ((char *) HT_05200
); break;
6022 case 5300: return ((char *) HT_05300
); break;
6023 case 5400: return ((char *) HT_05400
); break;
6024 case 5500: return ((char *) HT_05500
); break;
6025 case 5600: return ((char *) HT_05600
); break;
6026 case 5700: return ((char *) HT_05700
); break;
6027 case 5800: return ((char *) HT_05800
); break;
6028 case 6000: return ((char *) HT_06000
); break;
6029 case 6100: return ((char *) HT_06100
); break;
6030 case 6211: return ((char *) HT_06211
); break;
6031 case 6212: return ((char *) HT_06212
); break;
6032 case 6213: return ((char *) HT_06213
); break;
6033 case 6221: return ((char *) HT_06221
); break;
6034 case 6222: return ((char *) HT_06222
); break;
6035 case 6223: return ((char *) HT_06223
); break;
6036 case 6231: return ((char *) HT_06231
); break;
6037 case 6232: return ((char *) HT_06232
); break;
6038 case 6233: return ((char *) HT_06233
); break;
6039 case 6241: return ((char *) HT_06241
); break;
6040 case 6242: return ((char *) HT_06242
); break;
6041 case 6243: return ((char *) HT_06243
); break;
6042 case 6300: return ((char *) HT_06300
); break;
6043 case 6400: return ((char *) HT_06400
); break;
6044 case 6500: return ((char *) HT_06500
); break;
6045 case 6600: return ((char *) HT_06600
); break;
6046 case 6700: return ((char *) HT_06700
); break;
6047 case 6800: return ((char *) HT_06800
); break;
6048 case 6900: return ((char *) HT_06900
); break;
6049 case 7100: return ((char *) HT_07100
); break;
6050 case 7200: return ((char *) HT_07200
); break;
6051 case 7300: return ((char *) HT_07300
); break;
6052 case 7400: return ((char *) HT_07400
); break;
6053 case 7500: return ((char *) HT_07500
); break;
6054 case 7600: return ((char *) HT_07600
); break;
6055 case 7700: return ((char *) HT_07700
); break;
6056 case 7800: return ((char *) HT_07800
); break;
6057 case 7900: return ((char *) HT_07900
); break;
6058 case 8000: return ((char *) HT_08000
); break;
6059 case 8100: return ((char *) HT_08100
); break;
6060 case 8200: return ((char *) HT_08200
); break;
6061 case 8300: return ((char *) HT_08300
); break;
6062 case 8400: return ((char *) HT_08400
); break;
6063 case 8500: return ((char *) HT_08500
); break;
6064 case 8600: return ((char *) HT_08600
); break;
6065 case 8700: return ((char *) HT_08700
); break;
6066 case 8800: return ((char *) HT_08800
); break;
6067 case 8900: return ((char *) HT_08900
); break;
6068 case 9000: return ((char *) HT_09000
); break;
6069 case 9100: return ((char *) HT_09100
); break;
6070 case 9200: return ((char *) HT_09200
); break;
6071 case 9300: return ((char *) HT_09300
); break;
6072 case 9400: return ((char *) HT_09400
); break;
6073 case 9500: return ((char *) HT_09500
); break;
6074 case 9600: return ((char *) HT_09600
); break;
6075 case 9700: return ((char *) HT_09700
); break;
6076 case 9710: return ((char *) HT_09710
); break;
6077 case 9720: return ((char *) HT_09720
); break;
6078 case 9800: return ((char *) HT_09800
); break;
6079 case 9810: return ((char *) HT_09810
); break;
6080 case 9820: return ((char *) HT_09820
); break;
6081 case 9900: return ((char *) HT_09900
); break;
6082 case 10000: return ((char *) HT_10000
); break;
6083 case 10100: return ((char *) HT_10100
); break;
6084 case 10200: return ((char *) HT_10200
); break;
6085 case 10300: return ((char *) HT_10300
); break;
6086 case 10400: return ((char *) HT_10400
); break;
6087 case 10410: return ((char *) HT_10410
); break;
6088 case 10420: return ((char *) HT_10420
); break;
6089 case 10500: return ((char *) HT_10500
); break;
6090 case 10600: return ((char *) HT_10600
); break;
6091 case 10700: return ((char *) HT_10700
); break;
6092 case 10800: return ((char *) HT_10800
); break;
6093 case 10900: return ((char *) HT_10900
); break;
6094 case 11000: return ((char *) HT_11000
); break;
6095 case 11100: return ((char *) HT_11100
); break;
6096 case 11200: return ((char *) HT_11200
); break;
6097 case 11300: return ((char *) HT_11300
); break;
6098 case 11400: return ((char *) HT_11400
); break;
6099 case 11500: return ((char *) HT_11500
); break;
6100 case 11600: return ((char *) HT_11600
); break;
6101 case 11700: return ((char *) HT_11700
); break;
6102 case 11800: return ((char *) HT_11800
); break;
6103 case 11900: return ((char *) HT_11900
); break;
6104 case 12000: return ((char *) HT_12000
); break;
6105 case 12100: return ((char *) HT_12100
); break;
6106 case 12200: return ((char *) HT_12200
); break;
6107 case 12300: return ((char *) HT_12300
); break;
6108 case 12400: return ((char *) HT_12400
); break;
6109 case 12500: return ((char *) HT_12500
); break;
6110 case 12600: return ((char *) HT_12600
); break;
6111 case 12700: return ((char *) HT_12700
); break;
6112 case 12800: return ((char *) HT_12800
); break;
6113 case 12900: return ((char *) HT_12900
); break;
6114 case 13000: return ((char *) HT_13000
); break;
6115 case 13100: return ((char *) HT_13100
); break;
6116 case 13200: return ((char *) HT_13200
); break;
6117 case 13300: return ((char *) HT_13300
); break;
6118 case 13400: return ((char *) HT_13400
); break;
6119 case 13500: return ((char *) HT_13500
); break;
6120 case 13600: return ((char *) HT_13600
); break;
6121 case 13711: return ((char *) HT_13711
); break;
6122 case 13712: return ((char *) HT_13712
); break;
6123 case 13713: return ((char *) HT_13713
); break;
6124 case 13721: return ((char *) HT_13721
); break;
6125 case 13722: return ((char *) HT_13722
); break;
6126 case 13723: return ((char *) HT_13723
); break;
6127 case 13731: return ((char *) HT_13731
); break;
6128 case 13732: return ((char *) HT_13732
); break;
6129 case 13733: return ((char *) HT_13733
); break;
6130 case 13741: return ((char *) HT_13741
); break;
6131 case 13742: return ((char *) HT_13742
); break;
6132 case 13743: return ((char *) HT_13743
); break;
6133 case 13751: return ((char *) HT_13751
); break;
6134 case 13752: return ((char *) HT_13752
); break;
6135 case 13753: return ((char *) HT_13753
); break;
6136 case 13761: return ((char *) HT_13761
); break;
6137 case 13762: return ((char *) HT_13762
); break;
6138 case 13763: return ((char *) HT_13763
); break;
6139 case 13800: return ((char *) HT_13800
); break;
6142 return ((char *) "Unknown");
6145 char *strstatus (const uint devices_status
)
6147 switch (devices_status
)
6149 case STATUS_INIT
: return ((char *) ST_0000
); break;
6150 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6151 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6152 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6153 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6154 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6155 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6156 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6157 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6158 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6159 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6162 return ((char *) "Unknown");
6165 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6167 uint hash_type
= data
.hash_type
;
6168 uint hash_mode
= data
.hash_mode
;
6169 uint salt_type
= data
.salt_type
;
6170 uint opts_type
= data
.opts_type
;
6171 uint opti_type
= data
.opti_type
;
6172 uint dgst_size
= data
.dgst_size
;
6174 char *hashfile
= data
.hashfile
;
6178 uint digest_buf
[64] = { 0 };
6180 u64
*digest_buf64
= (u64
*) digest_buf
;
6182 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6184 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6186 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6192 case HASH_TYPE_DESCRYPT
:
6193 FP (digest_buf
[1], digest_buf
[0], tt
);
6196 case HASH_TYPE_DESRACF
:
6197 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6198 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6200 FP (digest_buf
[1], digest_buf
[0], tt
);
6204 FP (digest_buf
[1], digest_buf
[0], tt
);
6207 case HASH_TYPE_NETNTLM
:
6208 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6209 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6210 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6211 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6213 FP (digest_buf
[1], digest_buf
[0], tt
);
6214 FP (digest_buf
[3], digest_buf
[2], tt
);
6217 case HASH_TYPE_BSDICRYPT
:
6218 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6219 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6221 FP (digest_buf
[1], digest_buf
[0], tt
);
6226 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6231 digest_buf
[0] += MD4M_A
;
6232 digest_buf
[1] += MD4M_B
;
6233 digest_buf
[2] += MD4M_C
;
6234 digest_buf
[3] += MD4M_D
;
6238 digest_buf
[0] += MD5M_A
;
6239 digest_buf
[1] += MD5M_B
;
6240 digest_buf
[2] += MD5M_C
;
6241 digest_buf
[3] += MD5M_D
;
6244 case HASH_TYPE_SHA1
:
6245 digest_buf
[0] += SHA1M_A
;
6246 digest_buf
[1] += SHA1M_B
;
6247 digest_buf
[2] += SHA1M_C
;
6248 digest_buf
[3] += SHA1M_D
;
6249 digest_buf
[4] += SHA1M_E
;
6252 case HASH_TYPE_SHA256
:
6253 digest_buf
[0] += SHA256M_A
;
6254 digest_buf
[1] += SHA256M_B
;
6255 digest_buf
[2] += SHA256M_C
;
6256 digest_buf
[3] += SHA256M_D
;
6257 digest_buf
[4] += SHA256M_E
;
6258 digest_buf
[5] += SHA256M_F
;
6259 digest_buf
[6] += SHA256M_G
;
6260 digest_buf
[7] += SHA256M_H
;
6263 case HASH_TYPE_SHA384
:
6264 digest_buf64
[0] += SHA384M_A
;
6265 digest_buf64
[1] += SHA384M_B
;
6266 digest_buf64
[2] += SHA384M_C
;
6267 digest_buf64
[3] += SHA384M_D
;
6268 digest_buf64
[4] += SHA384M_E
;
6269 digest_buf64
[5] += SHA384M_F
;
6270 digest_buf64
[6] += 0;
6271 digest_buf64
[7] += 0;
6274 case HASH_TYPE_SHA512
:
6275 digest_buf64
[0] += SHA512M_A
;
6276 digest_buf64
[1] += SHA512M_B
;
6277 digest_buf64
[2] += SHA512M_C
;
6278 digest_buf64
[3] += SHA512M_D
;
6279 digest_buf64
[4] += SHA512M_E
;
6280 digest_buf64
[5] += SHA512M_F
;
6281 digest_buf64
[6] += SHA512M_G
;
6282 digest_buf64
[7] += SHA512M_H
;
6287 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6289 if (dgst_size
== DGST_SIZE_4_2
)
6291 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6293 else if (dgst_size
== DGST_SIZE_4_4
)
6295 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6297 else if (dgst_size
== DGST_SIZE_4_5
)
6299 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6301 else if (dgst_size
== DGST_SIZE_4_6
)
6303 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6305 else if (dgst_size
== DGST_SIZE_4_8
)
6307 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6309 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6311 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6313 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6315 else if (hash_type
== HASH_TYPE_SHA384
)
6317 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6319 else if (hash_type
== HASH_TYPE_SHA512
)
6321 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6323 else if (hash_type
== HASH_TYPE_GOST
)
6325 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6328 else if (dgst_size
== DGST_SIZE_4_64
)
6330 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6332 else if (dgst_size
== DGST_SIZE_8_25
)
6334 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6338 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6339 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6340 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6346 memset (&salt
, 0, sizeof (salt_t
));
6348 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6350 char *ptr
= (char *) salt
.salt_buf
;
6352 uint len
= salt
.salt_len
;
6354 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6360 case HASH_TYPE_NETNTLM
:
6362 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6363 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6365 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6371 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6373 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6381 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6383 uint max
= salt
.salt_len
/ 4;
6387 for (uint i
= 0; i
< max
; i
++)
6389 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6393 if (opts_type
& OPTS_TYPE_ST_HEX
)
6395 char tmp
[64] = { 0 };
6397 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6399 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6404 memcpy (ptr
, tmp
, len
);
6407 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6409 memset (ptr
+ len
, 0, memset_size
);
6411 salt
.salt_len
= len
;
6415 // some modes require special encoding
6418 uint out_buf_plain
[256] = { 0 };
6419 uint out_buf_salt
[256] = { 0 };
6421 char tmp_buf
[1024] = { 0 };
6423 char *ptr_plain
= (char *) out_buf_plain
;
6424 char *ptr_salt
= (char *) out_buf_salt
;
6426 if (hash_mode
== 22)
6428 char username
[30] = { 0 };
6430 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6432 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6434 u16
*ptr
= (u16
*) digest_buf
;
6436 tmp_buf
[ 0] = sig
[0];
6437 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6438 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6439 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6440 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6441 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6442 tmp_buf
[ 6] = sig
[1];
6443 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6444 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6445 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6446 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6447 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6448 tmp_buf
[12] = sig
[2];
6449 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6450 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6451 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6452 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6453 tmp_buf
[17] = sig
[3];
6454 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6455 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6456 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6457 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6458 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6459 tmp_buf
[23] = sig
[4];
6460 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6461 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6462 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6463 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6464 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6465 tmp_buf
[29] = sig
[5];
6467 snprintf (out_buf
, len
-1, "%s:%s",
6471 else if (hash_mode
== 23)
6473 // do not show the skyper part in output
6475 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6477 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6479 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6486 else if (hash_mode
== 101)
6488 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6490 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6491 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6492 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6493 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6494 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6496 memcpy (tmp_buf
, digest_buf
, 20);
6498 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6500 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6502 else if (hash_mode
== 111)
6504 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6506 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6507 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6508 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6509 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6510 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6512 memcpy (tmp_buf
, digest_buf
, 20);
6513 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6515 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6517 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6519 else if ((hash_mode
== 122) || (hash_mode
== 125))
6521 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6522 (char *) salt
.salt_buf
,
6529 else if (hash_mode
== 124)
6531 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6532 (char *) salt
.salt_buf
,
6539 else if (hash_mode
== 131)
6541 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6542 (char *) salt
.salt_buf
,
6550 else if (hash_mode
== 132)
6552 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6553 (char *) salt
.salt_buf
,
6560 else if (hash_mode
== 133)
6562 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6564 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6565 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6566 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6567 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6568 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6570 memcpy (tmp_buf
, digest_buf
, 20);
6572 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6574 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6576 else if (hash_mode
== 141)
6578 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6580 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6582 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6584 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6586 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6587 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6588 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6589 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6590 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6592 memcpy (tmp_buf
, digest_buf
, 20);
6594 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6598 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6600 else if (hash_mode
== 400)
6602 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6604 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6605 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6606 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6607 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6609 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6611 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6613 else if (hash_mode
== 500)
6615 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6617 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6618 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6619 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6620 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6622 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6624 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6626 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6630 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6633 else if (hash_mode
== 501)
6635 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6637 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6638 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6640 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6642 else if (hash_mode
== 1421)
6644 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6646 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6662 else if (hash_mode
== 1441)
6664 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6666 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6668 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6670 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6672 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6673 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6674 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6675 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6676 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6677 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6678 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6679 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6681 memcpy (tmp_buf
, digest_buf
, 32);
6683 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6687 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6689 else if (hash_mode
== 1500)
6691 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6692 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6693 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6694 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6695 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6697 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6699 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6701 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6702 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6704 memcpy (tmp_buf
, digest_buf
, 8);
6706 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6708 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6712 else if (hash_mode
== 1600)
6714 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6716 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6717 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6718 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6719 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6721 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6723 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6725 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6729 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6732 else if (hash_mode
== 1711)
6734 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6736 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6737 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6738 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6739 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6740 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6741 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6742 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6743 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6745 memcpy (tmp_buf
, digest_buf
, 64);
6746 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6748 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6750 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6752 else if (hash_mode
== 1722)
6754 uint
*ptr
= digest_buf
;
6756 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6757 (unsigned char *) salt
.salt_buf
,
6767 else if (hash_mode
== 1731)
6769 uint
*ptr
= digest_buf
;
6771 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6772 (unsigned char *) salt
.salt_buf
,
6782 else if (hash_mode
== 1800)
6786 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6787 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6788 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6789 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6790 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6791 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6792 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6793 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6795 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6797 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6799 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6803 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6806 else if (hash_mode
== 2100)
6810 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6812 salt
.salt_iter
+ 1);
6814 uint signature_len
= strlen (out_buf
);
6816 pos
+= signature_len
;
6817 len
-= signature_len
;
6819 char *salt_ptr
= (char *) salt
.salt_buf
;
6821 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6823 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6824 byte_swap_32 (digest_buf
[0]),
6825 byte_swap_32 (digest_buf
[1]),
6826 byte_swap_32 (digest_buf
[2]),
6827 byte_swap_32 (digest_buf
[3]));
6829 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6831 memcpy (tmp_buf
, digest_buf
, 16);
6833 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6835 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6836 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6837 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6838 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6840 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6841 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6842 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6843 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6845 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6846 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6847 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6848 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6850 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6851 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6852 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6853 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6855 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6856 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6857 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6858 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6862 else if (hash_mode
== 2500)
6864 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6866 wpa_t
*wpa
= &wpas
[salt_pos
];
6868 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6869 (char *) salt
.salt_buf
,
6883 else if (hash_mode
== 4400)
6885 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6886 byte_swap_32 (digest_buf
[0]),
6887 byte_swap_32 (digest_buf
[1]),
6888 byte_swap_32 (digest_buf
[2]),
6889 byte_swap_32 (digest_buf
[3]));
6891 else if (hash_mode
== 4700)
6893 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6894 byte_swap_32 (digest_buf
[0]),
6895 byte_swap_32 (digest_buf
[1]),
6896 byte_swap_32 (digest_buf
[2]),
6897 byte_swap_32 (digest_buf
[3]),
6898 byte_swap_32 (digest_buf
[4]));
6900 else if (hash_mode
== 4800)
6902 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6904 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6909 byte_swap_32 (salt
.salt_buf
[0]),
6910 byte_swap_32 (salt
.salt_buf
[1]),
6911 byte_swap_32 (salt
.salt_buf
[2]),
6912 byte_swap_32 (salt
.salt_buf
[3]),
6915 else if (hash_mode
== 4900)
6917 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6918 byte_swap_32 (digest_buf
[0]),
6919 byte_swap_32 (digest_buf
[1]),
6920 byte_swap_32 (digest_buf
[2]),
6921 byte_swap_32 (digest_buf
[3]),
6922 byte_swap_32 (digest_buf
[4]));
6924 else if (hash_mode
== 5100)
6926 snprintf (out_buf
, len
-1, "%08x%08x",
6930 else if (hash_mode
== 5200)
6932 snprintf (out_buf
, len
-1, "%s", hashfile
);
6934 else if (hash_mode
== 5300)
6936 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6938 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6940 int buf_len
= len
-1;
6944 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6946 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6948 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6950 snprintf (out_buf
, buf_len
, ":");
6956 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6964 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6966 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6968 if ((i
== 0) || (i
== 5))
6970 snprintf (out_buf
, buf_len
, ":");
6976 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6984 for (uint i
= 0; i
< 4; i
++)
6988 snprintf (out_buf
, buf_len
, ":");
6994 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
7000 else if (hash_mode
== 5400)
7002 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
7004 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
7006 int buf_len
= len
-1;
7010 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
7012 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
7014 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
7016 snprintf (out_buf
, buf_len
, ":");
7022 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
7030 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
7032 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
7034 if ((i
== 0) || (i
== 5))
7036 snprintf (out_buf
, buf_len
, ":");
7042 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
7050 for (uint i
= 0; i
< 5; i
++)
7054 snprintf (out_buf
, buf_len
, ":");
7060 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
7066 else if (hash_mode
== 5500)
7068 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7070 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7072 char user_buf
[64] = { 0 };
7073 char domain_buf
[64] = { 0 };
7074 char srvchall_buf
[1024] = { 0 };
7075 char clichall_buf
[1024] = { 0 };
7077 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7079 char *ptr
= (char *) netntlm
->userdomain_buf
;
7081 user_buf
[i
] = ptr
[j
];
7084 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7086 char *ptr
= (char *) netntlm
->userdomain_buf
;
7088 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7091 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7093 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7095 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7098 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7100 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7102 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7105 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7113 byte_swap_32 (salt
.salt_buf_pc
[0]),
7114 byte_swap_32 (salt
.salt_buf_pc
[1]),
7117 else if (hash_mode
== 5600)
7119 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7121 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7123 char user_buf
[64] = { 0 };
7124 char domain_buf
[64] = { 0 };
7125 char srvchall_buf
[1024] = { 0 };
7126 char clichall_buf
[1024] = { 0 };
7128 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7130 char *ptr
= (char *) netntlm
->userdomain_buf
;
7132 user_buf
[i
] = ptr
[j
];
7135 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7137 char *ptr
= (char *) netntlm
->userdomain_buf
;
7139 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7142 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7144 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7146 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7149 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7151 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7153 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7156 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7166 else if (hash_mode
== 5700)
7168 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7170 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7171 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7172 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7173 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7174 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7175 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7176 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7177 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7179 memcpy (tmp_buf
, digest_buf
, 32);
7181 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7185 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7187 else if (hash_mode
== 5800)
7189 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7190 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7191 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7192 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7193 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7195 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7202 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7204 snprintf (out_buf
, len
-1, "%s", hashfile
);
7206 else if (hash_mode
== 6300)
7208 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7210 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7211 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7212 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7213 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7215 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7217 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7219 else if (hash_mode
== 6400)
7221 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7223 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7225 else if (hash_mode
== 6500)
7227 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7229 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7231 else if (hash_mode
== 6600)
7233 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7235 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7237 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7238 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7240 uint buf_len
= len
- 1;
7242 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7245 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7247 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7252 else if (hash_mode
== 6700)
7254 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7256 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7258 else if (hash_mode
== 6800)
7260 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7262 else if (hash_mode
== 7100)
7264 uint
*ptr
= digest_buf
;
7266 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7268 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7270 uint esalt
[8] = { 0 };
7272 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7273 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7274 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7275 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7276 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7277 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7278 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7279 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7281 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",
7282 SIGNATURE_SHA512OSX
,
7284 esalt
[ 0], esalt
[ 1],
7285 esalt
[ 2], esalt
[ 3],
7286 esalt
[ 4], esalt
[ 5],
7287 esalt
[ 6], esalt
[ 7],
7295 ptr
[15], ptr
[14]);
7297 else if (hash_mode
== 7200)
7299 uint
*ptr
= digest_buf
;
7301 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7303 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7307 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7309 len_used
= strlen (out_buf
);
7311 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7313 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7315 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7318 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",
7326 ptr
[15], ptr
[14]);
7328 else if (hash_mode
== 7300)
7330 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7332 rakp_t
*rakp
= &rakps
[salt_pos
];
7334 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7336 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7339 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7346 else if (hash_mode
== 7400)
7348 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7350 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7351 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7352 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7353 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7354 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7355 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7356 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7357 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7359 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7361 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7363 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7367 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7370 else if (hash_mode
== 7500)
7372 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7374 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7376 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7377 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7379 char data
[128] = { 0 };
7381 char *ptr_data
= data
;
7383 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7385 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7388 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7390 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7395 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7397 (char *) krb5pa
->user
,
7398 (char *) krb5pa
->realm
,
7399 (char *) krb5pa
->salt
,
7402 else if (hash_mode
== 7700)
7404 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7405 (char *) salt
.salt_buf
,
7409 else if (hash_mode
== 7800)
7411 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7412 (char *) salt
.salt_buf
,
7419 else if (hash_mode
== 7900)
7421 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7425 char *tmp
= (char *) salt
.salt_buf_pc
;
7427 ptr_plain
[42] = tmp
[0];
7433 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7435 else if (hash_mode
== 8000)
7437 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7438 (unsigned char *) salt
.salt_buf
,
7448 else if (hash_mode
== 8100)
7450 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7451 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7453 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7454 (unsigned char *) salt
.salt_buf
,
7461 else if (hash_mode
== 8200)
7463 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7465 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7467 char data_buf
[4096] = { 0 };
7469 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7471 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7474 data_buf
[cloudkey
->data_len
* 2] = 0;
7476 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7477 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7478 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7479 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7480 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7481 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7482 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7483 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7485 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7486 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7487 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7488 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7490 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7506 else if (hash_mode
== 8300)
7508 char digest_buf_c
[34] = { 0 };
7510 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7511 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7512 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7513 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7514 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7516 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7518 digest_buf_c
[32] = 0;
7522 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7524 char domain_buf_c
[33] = { 0 };
7526 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7528 for (uint i
= 0; i
< salt_pc_len
; i
++)
7530 const char next
= domain_buf_c
[i
];
7532 domain_buf_c
[i
] = '.';
7537 domain_buf_c
[salt_pc_len
] = 0;
7541 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7543 else if (hash_mode
== 8500)
7545 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7547 else if (hash_mode
== 2612)
7549 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7551 (char *) salt
.salt_buf
,
7557 else if (hash_mode
== 3711)
7559 char *salt_ptr
= (char *) salt
.salt_buf
;
7561 salt_ptr
[salt
.salt_len
- 1] = 0;
7563 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7564 SIGNATURE_MEDIAWIKI_B
,
7571 else if (hash_mode
== 8800)
7573 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7575 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7577 char tmp
[3073] = { 0 };
7579 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7581 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7586 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7587 SIGNATURE_ANDROIDFDE
,
7588 byte_swap_32 (salt
.salt_buf
[0]),
7589 byte_swap_32 (salt
.salt_buf
[1]),
7590 byte_swap_32 (salt
.salt_buf
[2]),
7591 byte_swap_32 (salt
.salt_buf
[3]),
7592 byte_swap_32 (digest_buf
[0]),
7593 byte_swap_32 (digest_buf
[1]),
7594 byte_swap_32 (digest_buf
[2]),
7595 byte_swap_32 (digest_buf
[3]),
7598 else if (hash_mode
== 8900)
7600 uint N
= salt
.scrypt_N
;
7601 uint r
= salt
.scrypt_r
;
7602 uint p
= salt
.scrypt_p
;
7604 char base64_salt
[32] = { 0 };
7606 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7608 memset (tmp_buf
, 0, 46);
7610 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7611 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7612 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7613 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7614 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7615 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7616 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7617 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7618 digest_buf
[8] = 0; // needed for base64_encode ()
7620 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7622 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7630 else if (hash_mode
== 9000)
7632 snprintf (out_buf
, len
-1, "%s", hashfile
);
7634 else if (hash_mode
== 9200)
7638 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7640 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7642 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7646 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7647 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7648 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7649 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7650 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7651 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7652 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7653 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7654 digest_buf
[8] = 0; // needed for base64_encode ()
7656 char tmp_buf
[64] = { 0 };
7658 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7659 tmp_buf
[43] = 0; // cut it here
7663 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7665 else if (hash_mode
== 9300)
7667 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7668 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7669 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7670 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7671 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7672 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7673 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7674 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7675 digest_buf
[8] = 0; // needed for base64_encode ()
7677 char tmp_buf
[64] = { 0 };
7679 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7680 tmp_buf
[43] = 0; // cut it here
7682 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7684 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7686 else if (hash_mode
== 9400)
7688 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7690 office2007_t
*office2007
= &office2007s
[salt_pos
];
7692 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7693 SIGNATURE_OFFICE2007
,
7696 office2007
->keySize
,
7702 office2007
->encryptedVerifier
[0],
7703 office2007
->encryptedVerifier
[1],
7704 office2007
->encryptedVerifier
[2],
7705 office2007
->encryptedVerifier
[3],
7706 office2007
->encryptedVerifierHash
[0],
7707 office2007
->encryptedVerifierHash
[1],
7708 office2007
->encryptedVerifierHash
[2],
7709 office2007
->encryptedVerifierHash
[3],
7710 office2007
->encryptedVerifierHash
[4]);
7712 else if (hash_mode
== 9500)
7714 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7716 office2010_t
*office2010
= &office2010s
[salt_pos
];
7718 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,
7724 office2010
->encryptedVerifier
[0],
7725 office2010
->encryptedVerifier
[1],
7726 office2010
->encryptedVerifier
[2],
7727 office2010
->encryptedVerifier
[3],
7728 office2010
->encryptedVerifierHash
[0],
7729 office2010
->encryptedVerifierHash
[1],
7730 office2010
->encryptedVerifierHash
[2],
7731 office2010
->encryptedVerifierHash
[3],
7732 office2010
->encryptedVerifierHash
[4],
7733 office2010
->encryptedVerifierHash
[5],
7734 office2010
->encryptedVerifierHash
[6],
7735 office2010
->encryptedVerifierHash
[7]);
7737 else if (hash_mode
== 9600)
7739 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7741 office2013_t
*office2013
= &office2013s
[salt_pos
];
7743 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,
7749 office2013
->encryptedVerifier
[0],
7750 office2013
->encryptedVerifier
[1],
7751 office2013
->encryptedVerifier
[2],
7752 office2013
->encryptedVerifier
[3],
7753 office2013
->encryptedVerifierHash
[0],
7754 office2013
->encryptedVerifierHash
[1],
7755 office2013
->encryptedVerifierHash
[2],
7756 office2013
->encryptedVerifierHash
[3],
7757 office2013
->encryptedVerifierHash
[4],
7758 office2013
->encryptedVerifierHash
[5],
7759 office2013
->encryptedVerifierHash
[6],
7760 office2013
->encryptedVerifierHash
[7]);
7762 else if (hash_mode
== 9700)
7764 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7766 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7768 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7769 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7770 byte_swap_32 (salt
.salt_buf
[0]),
7771 byte_swap_32 (salt
.salt_buf
[1]),
7772 byte_swap_32 (salt
.salt_buf
[2]),
7773 byte_swap_32 (salt
.salt_buf
[3]),
7774 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7775 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7776 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7777 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7778 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7779 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7780 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7781 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7783 else if (hash_mode
== 9710)
7785 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7787 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7789 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7790 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7791 byte_swap_32 (salt
.salt_buf
[0]),
7792 byte_swap_32 (salt
.salt_buf
[1]),
7793 byte_swap_32 (salt
.salt_buf
[2]),
7794 byte_swap_32 (salt
.salt_buf
[3]),
7795 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7796 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7797 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7798 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7799 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7800 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7801 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7802 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7804 else if (hash_mode
== 9720)
7806 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7808 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7810 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7812 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7813 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7814 byte_swap_32 (salt
.salt_buf
[0]),
7815 byte_swap_32 (salt
.salt_buf
[1]),
7816 byte_swap_32 (salt
.salt_buf
[2]),
7817 byte_swap_32 (salt
.salt_buf
[3]),
7818 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7819 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7820 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7821 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7822 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7823 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7824 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7825 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7832 else if (hash_mode
== 9800)
7834 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7836 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7838 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7839 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7844 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7845 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7846 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7847 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7848 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7849 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7850 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7851 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7852 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7854 else if (hash_mode
== 9810)
7856 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7858 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7860 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7861 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7866 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7867 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7868 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7869 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7870 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7871 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7872 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7873 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7874 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7876 else if (hash_mode
== 9820)
7878 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7880 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7882 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7884 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7885 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7890 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7891 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7892 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7893 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7894 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7895 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7896 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7897 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7898 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7905 else if (hash_mode
== 10000)
7909 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7911 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7913 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7917 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7918 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7919 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7920 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7921 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7922 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7923 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7924 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7925 digest_buf
[8] = 0; // needed for base64_encode ()
7927 char tmp_buf
[64] = { 0 };
7929 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7933 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7935 else if (hash_mode
== 10100)
7937 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7942 byte_swap_32 (salt
.salt_buf
[0]),
7943 byte_swap_32 (salt
.salt_buf
[1]),
7944 byte_swap_32 (salt
.salt_buf
[2]),
7945 byte_swap_32 (salt
.salt_buf
[3]));
7947 else if (hash_mode
== 10200)
7949 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7951 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7955 char challenge
[100] = { 0 };
7957 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7961 char tmp_buf
[100] = { 0 };
7963 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7964 (char *) cram_md5
->user
,
7970 char response
[100] = { 0 };
7972 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7974 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7976 else if (hash_mode
== 10300)
7978 char tmp_buf
[100] = { 0 };
7980 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7981 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7983 uint tmp_len
= 20 + salt
.salt_len
;
7987 char base64_encoded
[100] = { 0 };
7989 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7991 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7993 else if (hash_mode
== 10400)
7995 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7997 pdf_t
*pdf
= &pdfs
[salt_pos
];
7999 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",
8007 byte_swap_32 (pdf
->id_buf
[0]),
8008 byte_swap_32 (pdf
->id_buf
[1]),
8009 byte_swap_32 (pdf
->id_buf
[2]),
8010 byte_swap_32 (pdf
->id_buf
[3]),
8012 byte_swap_32 (pdf
->u_buf
[0]),
8013 byte_swap_32 (pdf
->u_buf
[1]),
8014 byte_swap_32 (pdf
->u_buf
[2]),
8015 byte_swap_32 (pdf
->u_buf
[3]),
8016 byte_swap_32 (pdf
->u_buf
[4]),
8017 byte_swap_32 (pdf
->u_buf
[5]),
8018 byte_swap_32 (pdf
->u_buf
[6]),
8019 byte_swap_32 (pdf
->u_buf
[7]),
8021 byte_swap_32 (pdf
->o_buf
[0]),
8022 byte_swap_32 (pdf
->o_buf
[1]),
8023 byte_swap_32 (pdf
->o_buf
[2]),
8024 byte_swap_32 (pdf
->o_buf
[3]),
8025 byte_swap_32 (pdf
->o_buf
[4]),
8026 byte_swap_32 (pdf
->o_buf
[5]),
8027 byte_swap_32 (pdf
->o_buf
[6]),
8028 byte_swap_32 (pdf
->o_buf
[7])
8031 else if (hash_mode
== 10410)
8033 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8035 pdf_t
*pdf
= &pdfs
[salt_pos
];
8037 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",
8045 byte_swap_32 (pdf
->id_buf
[0]),
8046 byte_swap_32 (pdf
->id_buf
[1]),
8047 byte_swap_32 (pdf
->id_buf
[2]),
8048 byte_swap_32 (pdf
->id_buf
[3]),
8050 byte_swap_32 (pdf
->u_buf
[0]),
8051 byte_swap_32 (pdf
->u_buf
[1]),
8052 byte_swap_32 (pdf
->u_buf
[2]),
8053 byte_swap_32 (pdf
->u_buf
[3]),
8054 byte_swap_32 (pdf
->u_buf
[4]),
8055 byte_swap_32 (pdf
->u_buf
[5]),
8056 byte_swap_32 (pdf
->u_buf
[6]),
8057 byte_swap_32 (pdf
->u_buf
[7]),
8059 byte_swap_32 (pdf
->o_buf
[0]),
8060 byte_swap_32 (pdf
->o_buf
[1]),
8061 byte_swap_32 (pdf
->o_buf
[2]),
8062 byte_swap_32 (pdf
->o_buf
[3]),
8063 byte_swap_32 (pdf
->o_buf
[4]),
8064 byte_swap_32 (pdf
->o_buf
[5]),
8065 byte_swap_32 (pdf
->o_buf
[6]),
8066 byte_swap_32 (pdf
->o_buf
[7])
8069 else if (hash_mode
== 10420)
8071 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8073 pdf_t
*pdf
= &pdfs
[salt_pos
];
8075 u8
*rc4key
= (u8
*) pdf
->rc4key
;
8077 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",
8085 byte_swap_32 (pdf
->id_buf
[0]),
8086 byte_swap_32 (pdf
->id_buf
[1]),
8087 byte_swap_32 (pdf
->id_buf
[2]),
8088 byte_swap_32 (pdf
->id_buf
[3]),
8090 byte_swap_32 (pdf
->u_buf
[0]),
8091 byte_swap_32 (pdf
->u_buf
[1]),
8092 byte_swap_32 (pdf
->u_buf
[2]),
8093 byte_swap_32 (pdf
->u_buf
[3]),
8094 byte_swap_32 (pdf
->u_buf
[4]),
8095 byte_swap_32 (pdf
->u_buf
[5]),
8096 byte_swap_32 (pdf
->u_buf
[6]),
8097 byte_swap_32 (pdf
->u_buf
[7]),
8099 byte_swap_32 (pdf
->o_buf
[0]),
8100 byte_swap_32 (pdf
->o_buf
[1]),
8101 byte_swap_32 (pdf
->o_buf
[2]),
8102 byte_swap_32 (pdf
->o_buf
[3]),
8103 byte_swap_32 (pdf
->o_buf
[4]),
8104 byte_swap_32 (pdf
->o_buf
[5]),
8105 byte_swap_32 (pdf
->o_buf
[6]),
8106 byte_swap_32 (pdf
->o_buf
[7]),
8114 else if (hash_mode
== 10500)
8116 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8118 pdf_t
*pdf
= &pdfs
[salt_pos
];
8120 if (pdf
->id_len
== 32)
8122 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",
8130 byte_swap_32 (pdf
->id_buf
[0]),
8131 byte_swap_32 (pdf
->id_buf
[1]),
8132 byte_swap_32 (pdf
->id_buf
[2]),
8133 byte_swap_32 (pdf
->id_buf
[3]),
8134 byte_swap_32 (pdf
->id_buf
[4]),
8135 byte_swap_32 (pdf
->id_buf
[5]),
8136 byte_swap_32 (pdf
->id_buf
[6]),
8137 byte_swap_32 (pdf
->id_buf
[7]),
8139 byte_swap_32 (pdf
->u_buf
[0]),
8140 byte_swap_32 (pdf
->u_buf
[1]),
8141 byte_swap_32 (pdf
->u_buf
[2]),
8142 byte_swap_32 (pdf
->u_buf
[3]),
8143 byte_swap_32 (pdf
->u_buf
[4]),
8144 byte_swap_32 (pdf
->u_buf
[5]),
8145 byte_swap_32 (pdf
->u_buf
[6]),
8146 byte_swap_32 (pdf
->u_buf
[7]),
8148 byte_swap_32 (pdf
->o_buf
[0]),
8149 byte_swap_32 (pdf
->o_buf
[1]),
8150 byte_swap_32 (pdf
->o_buf
[2]),
8151 byte_swap_32 (pdf
->o_buf
[3]),
8152 byte_swap_32 (pdf
->o_buf
[4]),
8153 byte_swap_32 (pdf
->o_buf
[5]),
8154 byte_swap_32 (pdf
->o_buf
[6]),
8155 byte_swap_32 (pdf
->o_buf
[7])
8160 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",
8168 byte_swap_32 (pdf
->id_buf
[0]),
8169 byte_swap_32 (pdf
->id_buf
[1]),
8170 byte_swap_32 (pdf
->id_buf
[2]),
8171 byte_swap_32 (pdf
->id_buf
[3]),
8173 byte_swap_32 (pdf
->u_buf
[0]),
8174 byte_swap_32 (pdf
->u_buf
[1]),
8175 byte_swap_32 (pdf
->u_buf
[2]),
8176 byte_swap_32 (pdf
->u_buf
[3]),
8177 byte_swap_32 (pdf
->u_buf
[4]),
8178 byte_swap_32 (pdf
->u_buf
[5]),
8179 byte_swap_32 (pdf
->u_buf
[6]),
8180 byte_swap_32 (pdf
->u_buf
[7]),
8182 byte_swap_32 (pdf
->o_buf
[0]),
8183 byte_swap_32 (pdf
->o_buf
[1]),
8184 byte_swap_32 (pdf
->o_buf
[2]),
8185 byte_swap_32 (pdf
->o_buf
[3]),
8186 byte_swap_32 (pdf
->o_buf
[4]),
8187 byte_swap_32 (pdf
->o_buf
[5]),
8188 byte_swap_32 (pdf
->o_buf
[6]),
8189 byte_swap_32 (pdf
->o_buf
[7])
8193 else if (hash_mode
== 10600)
8195 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8197 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8198 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8200 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8202 else if (hash_mode
== 10700)
8204 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8206 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8207 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8209 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8211 else if (hash_mode
== 10900)
8213 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8215 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8216 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8218 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8220 else if (hash_mode
== 11100)
8222 u32 salt_challenge
= salt
.salt_buf
[0];
8224 salt_challenge
= byte_swap_32 (salt_challenge
);
8226 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8228 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8229 SIGNATURE_POSTGRESQL_AUTH
,
8237 else if (hash_mode
== 11200)
8239 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8240 SIGNATURE_MYSQL_AUTH
,
8241 (unsigned char *) salt
.salt_buf
,
8248 else if (hash_mode
== 11300)
8250 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8252 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8254 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8255 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8256 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8258 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8259 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8260 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8262 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8264 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8266 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8269 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8271 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8273 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8276 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8278 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8280 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8283 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8284 SIGNATURE_BITCOIN_WALLET
,
8288 (unsigned char *) salt
.salt_buf
,
8296 free (cry_master_buf
);
8298 free (public_key_buf
);
8300 else if (hash_mode
== 11400)
8302 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8304 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8305 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8307 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8309 else if (hash_mode
== 11600)
8311 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8313 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8315 const uint data_len
= seven_zip
->data_len
;
8317 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8319 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8321 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8323 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8326 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8327 SIGNATURE_SEVEN_ZIP
,
8331 (char *) seven_zip
->salt_buf
,
8333 seven_zip
->iv_buf
[0],
8334 seven_zip
->iv_buf
[1],
8335 seven_zip
->iv_buf
[2],
8336 seven_zip
->iv_buf
[3],
8338 seven_zip
->data_len
,
8339 seven_zip
->unpack_size
,
8344 else if (hash_mode
== 11700)
8346 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8356 else if (hash_mode
== 11800)
8358 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8376 else if (hash_mode
== 11900)
8378 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8380 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8381 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8383 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8385 else if (hash_mode
== 12000)
8387 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8389 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8390 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8392 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8394 else if (hash_mode
== 12100)
8396 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8398 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8399 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8401 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8403 else if (hash_mode
== 12200)
8405 uint
*ptr_digest
= digest_buf
;
8406 uint
*ptr_salt
= salt
.salt_buf
;
8408 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8415 else if (hash_mode
== 12300)
8417 uint
*ptr_digest
= digest_buf
;
8418 uint
*ptr_salt
= salt
.salt_buf
;
8420 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",
8421 ptr_digest
[ 0], ptr_digest
[ 1],
8422 ptr_digest
[ 2], ptr_digest
[ 3],
8423 ptr_digest
[ 4], ptr_digest
[ 5],
8424 ptr_digest
[ 6], ptr_digest
[ 7],
8425 ptr_digest
[ 8], ptr_digest
[ 9],
8426 ptr_digest
[10], ptr_digest
[11],
8427 ptr_digest
[12], ptr_digest
[13],
8428 ptr_digest
[14], ptr_digest
[15],
8434 else if (hash_mode
== 12400)
8436 // encode iteration count
8438 char salt_iter
[5] = { 0 };
8440 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8441 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8442 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8443 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8448 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8449 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8450 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8451 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8456 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8458 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8459 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8461 memcpy (tmp_buf
, digest_buf
, 8);
8463 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8467 // fill the resulting buffer
8469 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8471 else if (hash_mode
== 12500)
8473 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8475 byte_swap_32 (salt
.salt_buf
[0]),
8476 byte_swap_32 (salt
.salt_buf
[1]),
8482 else if (hash_mode
== 12600)
8484 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8485 digest_buf
[0] + salt
.salt_buf_pc
[0],
8486 digest_buf
[1] + salt
.salt_buf_pc
[1],
8487 digest_buf
[2] + salt
.salt_buf_pc
[2],
8488 digest_buf
[3] + salt
.salt_buf_pc
[3],
8489 digest_buf
[4] + salt
.salt_buf_pc
[4],
8490 digest_buf
[5] + salt
.salt_buf_pc
[5],
8491 digest_buf
[6] + salt
.salt_buf_pc
[6],
8492 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8494 else if (hash_mode
== 12700)
8496 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8498 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8499 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8501 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8503 else if (hash_mode
== 12800)
8505 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8507 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",
8520 byte_swap_32 (digest_buf
[0]),
8521 byte_swap_32 (digest_buf
[1]),
8522 byte_swap_32 (digest_buf
[2]),
8523 byte_swap_32 (digest_buf
[3]),
8524 byte_swap_32 (digest_buf
[4]),
8525 byte_swap_32 (digest_buf
[5]),
8526 byte_swap_32 (digest_buf
[6]),
8527 byte_swap_32 (digest_buf
[7])
8530 else if (hash_mode
== 12900)
8532 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",
8541 byte_swap_32 (digest_buf
[0]),
8542 byte_swap_32 (digest_buf
[1]),
8543 byte_swap_32 (digest_buf
[2]),
8544 byte_swap_32 (digest_buf
[3]),
8545 byte_swap_32 (digest_buf
[4]),
8546 byte_swap_32 (digest_buf
[5]),
8547 byte_swap_32 (digest_buf
[6]),
8548 byte_swap_32 (digest_buf
[7]),
8555 else if (hash_mode
== 13000)
8557 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8559 rar5_t
*rar5
= &rar5s
[salt_pos
];
8561 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8571 byte_swap_32 (digest_buf
[0]),
8572 byte_swap_32 (digest_buf
[1])
8575 else if (hash_mode
== 13100)
8577 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8579 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8581 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8582 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8584 char data
[2560 * 4 * 2] = { 0 };
8586 char *ptr_data
= data
;
8588 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8589 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8594 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8595 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8597 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8599 (char *) krb5tgs
->account_info
,
8603 else if (hash_mode
== 13200)
8605 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8619 else if (hash_mode
== 13300)
8621 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8622 SIGNATURE_AXCRYPT_SHA1
,
8628 else if (hash_mode
== 13400)
8630 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8632 keepass_t
*keepass
= &keepasss
[salt_pos
];
8634 u32 version
= (u32
) keepass
->version
;
8635 u32 rounds
= salt
.salt_iter
;
8636 u32 algorithm
= (u32
) keepass
->algorithm
;
8637 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8639 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8640 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8641 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8642 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8643 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8645 /* specific to version 1 */
8649 /* specific to version 2 */
8650 u32 expected_bytes_len
;
8651 u32
*ptr_expected_bytes
;
8653 u32 final_random_seed_len
;
8654 u32 transf_random_seed_len
;
8656 u32 contents_hash_len
;
8658 transf_random_seed_len
= 8;
8660 contents_hash_len
= 8;
8661 final_random_seed_len
= 8;
8664 final_random_seed_len
= 4;
8666 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8672 char *ptr_data
= out_buf
;
8674 ptr_data
+= strlen(out_buf
);
8679 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8680 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8685 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8686 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8691 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8692 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8699 contents_len
= (u32
) keepass
->contents_len
;
8700 ptr_contents
= (u32
*) keepass
->contents
;
8702 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8703 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8715 char ptr_contents_len
[10] = { 0 };
8717 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8719 sprintf (ptr_data
, "%d", contents_len
);
8721 ptr_data
+= strlen(ptr_contents_len
);
8726 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8727 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8729 else if (version
== 2)
8731 expected_bytes_len
= 8;
8732 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8734 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8735 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8740 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8741 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8755 sprintf (ptr_data
, "%d", keyfile_len
);
8762 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8763 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8766 else if (hash_mode
== 13500)
8768 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8770 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8772 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8774 char pstoken_tmp
[1024 + 1] = { 0 };
8776 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8778 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8780 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8783 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8791 else if (hash_mode
== 13600)
8793 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8795 zip2_t
*zip2
= &zip2s
[salt_pos
];
8797 const u32 salt_len
= zip2
->salt_len
;
8799 char salt_tmp
[32 + 1] = { 0 };
8801 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8803 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8805 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8808 const u32 data_len
= zip2
->data_len
;
8810 char data_tmp
[8192 + 1] = { 0 };
8812 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8814 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8816 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8819 const u32 auth_len
= zip2
->auth_len
;
8821 char auth_tmp
[20 + 1] = { 0 };
8823 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8825 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8827 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8830 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8831 SIGNATURE_ZIP2_START
,
8837 zip2
->compress_length
,
8840 SIGNATURE_ZIP2_STOP
);
8842 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8844 snprintf (out_buf
, len
-1, "%s", hashfile
);
8846 else if (hash_mode
== 13800)
8848 win8phone_t
*esalts
= (win8phone_t
*) data
.esalts_buf
;
8850 win8phone_t
*esalt
= &esalts
[salt_pos
];
8852 char buf
[256 + 1] = { 0 };
8854 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
8856 sprintf (buf
+ j
, "%08x", esalt
->salt_buf
[i
]);
8859 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%s",
8872 if (hash_type
== HASH_TYPE_MD4
)
8874 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8880 else if (hash_type
== HASH_TYPE_MD5
)
8882 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8888 else if (hash_type
== HASH_TYPE_SHA1
)
8890 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8897 else if (hash_type
== HASH_TYPE_SHA256
)
8899 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8909 else if (hash_type
== HASH_TYPE_SHA384
)
8911 uint
*ptr
= digest_buf
;
8913 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8921 else if (hash_type
== HASH_TYPE_SHA512
)
8923 uint
*ptr
= digest_buf
;
8925 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8935 else if (hash_type
== HASH_TYPE_LM
)
8937 snprintf (out_buf
, len
-1, "%08x%08x",
8941 else if (hash_type
== HASH_TYPE_ORACLEH
)
8943 snprintf (out_buf
, len
-1, "%08X%08X",
8947 else if (hash_type
== HASH_TYPE_BCRYPT
)
8949 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8950 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8952 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8954 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8956 else if (hash_type
== HASH_TYPE_KECCAK
)
8958 uint
*ptr
= digest_buf
;
8960 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",
8988 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8990 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8992 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8999 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
9001 digest_buf
[ 0] = digest_buf
[ 0];
9002 digest_buf
[ 1] = digest_buf
[ 1];
9003 digest_buf
[ 2] = digest_buf
[ 2];
9004 digest_buf
[ 3] = digest_buf
[ 3];
9005 digest_buf
[ 4] = digest_buf
[ 4];
9006 digest_buf
[ 5] = digest_buf
[ 5];
9007 digest_buf
[ 6] = digest_buf
[ 6];
9008 digest_buf
[ 7] = digest_buf
[ 7];
9009 digest_buf
[ 8] = digest_buf
[ 8];
9010 digest_buf
[ 9] = digest_buf
[ 9];
9011 digest_buf
[10] = digest_buf
[10];
9012 digest_buf
[11] = digest_buf
[11];
9013 digest_buf
[12] = digest_buf
[12];
9014 digest_buf
[13] = digest_buf
[13];
9015 digest_buf
[14] = digest_buf
[14];
9016 digest_buf
[15] = digest_buf
[15];
9018 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
9036 else if (hash_type
== HASH_TYPE_GOST
)
9038 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
9048 else if (hash_type
== HASH_TYPE_MYSQL
)
9050 snprintf (out_buf
, len
-1, "%08x%08x",
9054 else if (hash_type
== HASH_TYPE_LOTUS5
)
9056 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
9062 else if (hash_type
== HASH_TYPE_LOTUS6
)
9064 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
9065 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
9066 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
9067 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
9069 char buf
[16] = { 0 };
9071 memcpy (buf
+ 0, salt
.salt_buf
, 5);
9072 memcpy (buf
+ 5, digest_buf
, 9);
9076 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
9078 tmp_buf
[18] = salt
.salt_buf_pc
[7];
9081 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
9083 else if (hash_type
== HASH_TYPE_LOTUS8
)
9085 char buf
[52] = { 0 };
9089 memcpy (buf
+ 0, salt
.salt_buf
, 16);
9095 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
9099 buf
[26] = salt
.salt_buf_pc
[0];
9100 buf
[27] = salt
.salt_buf_pc
[1];
9104 memcpy (buf
+ 28, digest_buf
, 8);
9106 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9110 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9112 else if (hash_type
== HASH_TYPE_CRC32
)
9114 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9118 if (salt_type
== SALT_TYPE_INTERN
)
9120 size_t pos
= strlen (out_buf
);
9122 out_buf
[pos
] = data
.separator
;
9124 char *ptr
= (char *) salt
.salt_buf
;
9126 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9128 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9132 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9134 memset (hccap
, 0, sizeof (hccap_t
));
9136 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9138 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9140 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9141 wpa_t
*wpa
= &wpas
[salt_pos
];
9143 hccap
->keyver
= wpa
->keyver
;
9145 hccap
->eapol_size
= wpa
->eapol_size
;
9147 if (wpa
->keyver
!= 1)
9149 uint eapol_tmp
[64] = { 0 };
9151 for (uint i
= 0; i
< 64; i
++)
9153 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9156 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9160 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9163 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9164 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9165 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9166 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9168 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9170 uint dgst_size
= data
.dgst_size
;
9172 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9174 if (wpa
->keyver
!= 1)
9176 uint digest_tmp
[4] = { 0 };
9178 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9179 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9180 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9181 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9183 memcpy (hccap
->keymic
, digest_tmp
, 16);
9187 memcpy (hccap
->keymic
, digest_ptr
, 16);
9191 void SuspendThreads ()
9193 if (data
.devices_status
!= STATUS_RUNNING
) return;
9195 hc_timer_set (&data
.timer_paused
);
9197 data
.devices_status
= STATUS_PAUSED
;
9199 log_info ("Paused");
9202 void ResumeThreads ()
9204 if (data
.devices_status
!= STATUS_PAUSED
) return;
9208 hc_timer_get (data
.timer_paused
, ms_paused
);
9210 data
.ms_paused
+= ms_paused
;
9212 data
.devices_status
= STATUS_RUNNING
;
9214 log_info ("Resumed");
9219 data
.devices_status
= STATUS_BYPASS
;
9221 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9224 void stop_at_checkpoint ()
9226 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9228 if (data
.devices_status
!= STATUS_RUNNING
) return;
9231 // this feature only makes sense if --restore-disable was not specified
9233 if (data
.restore_disable
== 1)
9235 log_info ("WARNING: This feature is disabled when --restore-disable is specified");
9240 // check if monitoring of Restore Point updates should be enabled or disabled
9242 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9244 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9246 // save the current restore point value
9248 data
.checkpoint_cur_words
= get_lowest_words_done ();
9250 log_info ("Checkpoint enabled: Will quit at next Restore Point update");
9254 data
.devices_status
= STATUS_RUNNING
;
9256 // reset the global value for checkpoint checks
9258 data
.checkpoint_cur_words
= 0;
9260 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9266 data
.devices_status
= STATUS_ABORTED
;
9271 data
.devices_status
= STATUS_QUIT
;
9274 void naive_replace (char *s
, const u8 key_char
, const u8 replace_char
)
9276 const size_t len
= strlen (s
);
9278 for (size_t in
= 0; in
< len
; in
++)
9284 s
[in
] = replace_char
;
9289 void naive_escape (char *s
, size_t s_max
, const u8 key_char
, const u8 escape_char
)
9291 char s_escaped
[1024] = { 0 };
9293 size_t s_escaped_max
= sizeof (s_escaped
);
9295 const size_t len
= strlen (s
);
9297 for (size_t in
= 0, out
= 0; in
< len
; in
++, out
++)
9303 s_escaped
[out
] = escape_char
;
9308 if (out
== s_escaped_max
- 2) break;
9313 strncpy (s
, s_escaped
, s_max
- 1);
9316 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9318 FILE *fp
= fopen (kernel_file
, "rb");
9324 memset (&st
, 0, sizeof (st
));
9326 stat (kernel_file
, &st
);
9328 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9330 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9332 if (num_read
!= (size_t) st
.st_size
)
9334 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9341 buf
[st
.st_size
] = 0;
9343 for (int i
= 0; i
< num_devices
; i
++)
9345 kernel_lengths
[i
] = (size_t) st
.st_size
;
9347 kernel_sources
[i
] = buf
;
9352 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9360 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9362 if (binary_size
> 0)
9364 FILE *fp
= fopen (dst
, "wb");
9367 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9378 restore_data_t
*init_restore (int argc
, char **argv
)
9380 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9382 if (data
.restore_disable
== 0)
9384 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9388 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9392 log_error ("ERROR: Cannot read %s", data
.eff_restore_file
);
9401 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9403 int pidbin_len
= -1;
9406 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9408 FILE *fd
= fopen (pidbin
, "rb");
9412 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9414 pidbin
[pidbin_len
] = 0;
9418 char *argv0_r
= strrchr (argv
[0], '/');
9420 char *pidbin_r
= strrchr (pidbin
, '/');
9422 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9424 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9426 if (strcmp (argv0_r
, pidbin_r
) == 0)
9428 log_error ("ERROR: Already an instance %s running on pid %d", pidbin
, rd
->pid
);
9435 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9437 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9439 int pidbin2_len
= -1;
9441 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9442 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9444 pidbin
[pidbin_len
] = 0;
9445 pidbin2
[pidbin2_len
] = 0;
9449 if (strcmp (pidbin
, pidbin2
) == 0)
9451 log_error ("ERROR: Already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9464 if (rd
->version_bin
< RESTORE_MIN
)
9466 log_error ("ERROR: Cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9473 memset (rd
, 0, sizeof (restore_data_t
));
9475 rd
->version_bin
= VERSION_BIN
;
9478 rd
->pid
= getpid ();
9480 rd
->pid
= GetCurrentProcessId ();
9483 if (getcwd (rd
->cwd
, 255) == NULL
)
9496 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9498 FILE *fp
= fopen (eff_restore_file
, "rb");
9502 log_error ("ERROR: Restore file '%s': %s", eff_restore_file
, strerror (errno
));
9507 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9509 log_error ("ERROR: Can't read %s", eff_restore_file
);
9514 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9516 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9518 for (uint i
= 0; i
< rd
->argc
; i
++)
9520 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9522 log_error ("ERROR: Can't read %s", eff_restore_file
);
9527 size_t len
= strlen (buf
);
9529 if (len
) buf
[len
- 1] = 0;
9531 rd
->argv
[i
] = mystrdup (buf
);
9538 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9540 if (chdir (rd
->cwd
))
9542 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9543 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9544 " https://github.com/philsmd/analyze_hc_restore\n"
9545 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9551 u64
get_lowest_words_done ()
9555 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9557 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9559 if (device_param
->skipped
) continue;
9561 const u64 words_done
= device_param
->words_done
;
9563 if (words_done
< words_cur
) words_cur
= words_done
;
9566 // It's possible that a device's workload isn't finished right after a restore-case.
9567 // In that case, this function would return 0 and overwrite the real restore point
9568 // There's also data.words_cur which is set to rd->words_cur but it changes while
9569 // the attack is running therefore we should stick to rd->words_cur.
9570 // Note that -s influences rd->words_cur we should keep a close look on that.
9572 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9577 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9579 u64 words_cur
= get_lowest_words_done ();
9581 rd
->words_cur
= words_cur
;
9583 FILE *fp
= fopen (new_restore_file
, "wb");
9587 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9592 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9594 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9599 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9601 for (uint i
= 0; i
< rd
->argc
; i
++)
9603 fprintf (fp
, "%s", rd
->argv
[i
]);
9609 fsync (fileno (fp
));
9614 void cycle_restore ()
9616 const char *eff_restore_file
= data
.eff_restore_file
;
9617 const char *new_restore_file
= data
.new_restore_file
;
9619 restore_data_t
*rd
= data
.rd
;
9621 write_restore (new_restore_file
, rd
);
9625 memset (&st
, 0, sizeof(st
));
9627 if (stat (eff_restore_file
, &st
) == 0)
9629 if (unlink (eff_restore_file
))
9631 log_info ("WARN: Unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9635 if (rename (new_restore_file
, eff_restore_file
))
9637 log_info ("WARN: Rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9641 void check_checkpoint ()
9643 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9645 u64 words_cur
= get_lowest_words_done ();
9647 if (words_cur
!= data
.checkpoint_cur_words
)
9657 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9661 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9663 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9665 myfree (alias
->device_name
);
9666 myfree (alias
->alias_name
);
9669 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9671 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9673 myfree (entry
->device_name
);
9676 myfree (tuning_db
->alias_buf
);
9677 myfree (tuning_db
->entry_buf
);
9682 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9684 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9686 int num_lines
= count_lines (fp
);
9688 // a bit over-allocated
9690 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9691 tuning_db
->alias_cnt
= 0;
9693 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9694 tuning_db
->entry_cnt
= 0;
9699 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9701 FILE *fp
= fopen (tuning_db_file
, "rb");
9705 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9710 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9716 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9720 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9722 if (line_buf
== NULL
) break;
9726 const int line_len
= in_superchop (line_buf
);
9728 if (line_len
== 0) continue;
9730 if (line_buf
[0] == '#') continue;
9734 char *token_ptr
[7] = { NULL
};
9738 char *next
= strtok (line_buf
, "\t ");
9740 token_ptr
[token_cnt
] = next
;
9744 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9746 token_ptr
[token_cnt
] = next
;
9753 char *device_name
= token_ptr
[0];
9754 char *alias_name
= token_ptr
[1];
9756 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9758 alias
->device_name
= mystrdup (device_name
);
9759 alias
->alias_name
= mystrdup (alias_name
);
9761 tuning_db
->alias_cnt
++;
9763 else if (token_cnt
== 6)
9765 if ((token_ptr
[1][0] != '0') &&
9766 (token_ptr
[1][0] != '1') &&
9767 (token_ptr
[1][0] != '3') &&
9768 (token_ptr
[1][0] != '*'))
9770 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9775 if ((token_ptr
[3][0] != '1') &&
9776 (token_ptr
[3][0] != '2') &&
9777 (token_ptr
[3][0] != '4') &&
9778 (token_ptr
[3][0] != '8') &&
9779 (token_ptr
[3][0] != 'N'))
9781 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9786 char *device_name
= token_ptr
[0];
9788 int attack_mode
= -1;
9790 int vector_width
= -1;
9791 int kernel_accel
= -1;
9792 int kernel_loops
= -1;
9794 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9795 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9796 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9798 if (token_ptr
[4][0] != 'A')
9800 kernel_accel
= atoi (token_ptr
[4]);
9802 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9804 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9814 if (token_ptr
[5][0] != 'A')
9816 kernel_loops
= atoi (token_ptr
[5]);
9818 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9820 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9830 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9832 entry
->device_name
= mystrdup (device_name
);
9833 entry
->attack_mode
= attack_mode
;
9834 entry
->hash_type
= hash_type
;
9835 entry
->vector_width
= vector_width
;
9836 entry
->kernel_accel
= kernel_accel
;
9837 entry
->kernel_loops
= kernel_loops
;
9839 tuning_db
->entry_cnt
++;
9843 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9853 // todo: print loaded 'cnt' message
9855 // sort the database
9857 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9858 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9863 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9865 static tuning_db_entry_t s
;
9867 // first we need to convert all spaces in the device_name to underscore
9869 char *device_name_nospace
= strdup (device_param
->device_name
);
9871 int device_name_length
= strlen (device_name_nospace
);
9875 for (i
= 0; i
< device_name_length
; i
++)
9877 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9880 // find out if there's an alias configured
9882 tuning_db_alias_t a
;
9884 a
.device_name
= device_name_nospace
;
9886 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
);
9888 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9890 // attack-mode 6 and 7 are attack-mode 1 basically
9892 if (attack_mode
== 6) attack_mode
= 1;
9893 if (attack_mode
== 7) attack_mode
= 1;
9895 // bsearch is not ideal but fast enough
9897 s
.device_name
= device_name_nospace
;
9898 s
.attack_mode
= attack_mode
;
9899 s
.hash_type
= hash_type
;
9901 tuning_db_entry_t
*entry
= NULL
;
9903 // this will produce all 2^3 combinations required
9905 for (i
= 0; i
< 8; i
++)
9907 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9908 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9909 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9911 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9913 if (entry
!= NULL
) break;
9915 // in non-wildcard mode do some additional checks:
9919 // in case we have an alias-name
9921 if (alias_name
!= NULL
)
9923 s
.device_name
= alias_name
;
9925 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9927 if (entry
!= NULL
) break;
9930 // or by device type
9932 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9934 s
.device_name
= "DEVICE_TYPE_CPU";
9936 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9938 s
.device_name
= "DEVICE_TYPE_GPU";
9940 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9942 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9945 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9947 if (entry
!= NULL
) break;
9951 // free converted device_name
9953 myfree (device_name_nospace
);
9962 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9964 u8 tmp
[256] = { 0 };
9966 if (salt_len
> sizeof (tmp
))
9971 memcpy (tmp
, in
, salt_len
);
9973 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9975 if ((salt_len
% 2) == 0)
9977 u32 new_salt_len
= salt_len
/ 2;
9979 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9984 tmp
[i
] = hex_convert (p1
) << 0;
9985 tmp
[i
] |= hex_convert (p0
) << 4;
9988 salt_len
= new_salt_len
;
9995 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9997 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
10000 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
10002 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
10006 u32
*tmp_uint
= (u32
*) tmp
;
10008 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
10009 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
10010 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
10011 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
10012 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
10013 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
10014 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
10015 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
10016 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
10017 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
10019 salt_len
= salt_len
* 2;
10027 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
10029 lowercase (tmp
, salt_len
);
10032 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
10034 uppercase (tmp
, salt_len
);
10037 u32 len
= salt_len
;
10039 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
10044 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
10049 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
10051 u32
*tmp_uint
= (uint
*) tmp
;
10055 if (len
% 4) max
++;
10057 for (u32 i
= 0; i
< max
; i
++)
10059 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
10062 // Important: we may need to increase the length of memcpy since
10063 // we don't want to "loose" some swapped bytes (could happen if
10064 // they do not perfectly fit in the 4-byte blocks)
10065 // Memcpy does always copy the bytes in the BE order, but since
10066 // we swapped them, some important bytes could be in positions
10067 // we normally skip with the original len
10069 if (len
% 4) len
+= 4 - (len
% 4);
10072 memcpy (out
, tmp
, len
);
10077 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10079 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
10081 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
10083 u32
*digest
= (u32
*) hash_buf
->digest
;
10085 salt_t
*salt
= hash_buf
->salt
;
10087 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
10089 char *iter_pos
= input_buf
+ 4;
10091 salt
->salt_iter
= 1 << atoi (iter_pos
);
10093 char *salt_pos
= strchr (iter_pos
, '$');
10095 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10099 uint salt_len
= 16;
10101 salt
->salt_len
= salt_len
;
10103 u8 tmp_buf
[100] = { 0 };
10105 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
10107 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10109 memcpy (salt_buf_ptr
, tmp_buf
, 16);
10111 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
10112 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
10113 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
10114 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
10116 char *hash_pos
= salt_pos
+ 22;
10118 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10120 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
10122 memcpy (digest
, tmp_buf
, 24);
10124 digest
[0] = byte_swap_32 (digest
[0]);
10125 digest
[1] = byte_swap_32 (digest
[1]);
10126 digest
[2] = byte_swap_32 (digest
[2]);
10127 digest
[3] = byte_swap_32 (digest
[3]);
10128 digest
[4] = byte_swap_32 (digest
[4]);
10129 digest
[5] = byte_swap_32 (digest
[5]);
10131 digest
[5] &= ~0xff; // its just 23 not 24 !
10133 return (PARSER_OK
);
10136 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10138 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10140 u32
*digest
= (u32
*) hash_buf
->digest
;
10142 u8 tmp_buf
[100] = { 0 };
10144 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10146 memcpy (digest
, tmp_buf
, 32);
10148 digest
[0] = byte_swap_32 (digest
[0]);
10149 digest
[1] = byte_swap_32 (digest
[1]);
10150 digest
[2] = byte_swap_32 (digest
[2]);
10151 digest
[3] = byte_swap_32 (digest
[3]);
10152 digest
[4] = byte_swap_32 (digest
[4]);
10153 digest
[5] = byte_swap_32 (digest
[5]);
10154 digest
[6] = byte_swap_32 (digest
[6]);
10155 digest
[7] = byte_swap_32 (digest
[7]);
10157 digest
[0] -= SHA256M_A
;
10158 digest
[1] -= SHA256M_B
;
10159 digest
[2] -= SHA256M_C
;
10160 digest
[3] -= SHA256M_D
;
10161 digest
[4] -= SHA256M_E
;
10162 digest
[5] -= SHA256M_F
;
10163 digest
[6] -= SHA256M_G
;
10164 digest
[7] -= SHA256M_H
;
10166 return (PARSER_OK
);
10169 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10171 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10173 u32
*digest
= (u32
*) hash_buf
->digest
;
10175 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10176 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10178 digest
[0] = byte_swap_32 (digest
[0]);
10179 digest
[1] = byte_swap_32 (digest
[1]);
10183 IP (digest
[0], digest
[1], tt
);
10185 digest
[0] = digest
[0];
10186 digest
[1] = digest
[1];
10190 return (PARSER_OK
);
10193 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10195 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10197 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10199 u32
*digest
= (u32
*) hash_buf
->digest
;
10201 salt_t
*salt
= hash_buf
->salt
;
10203 char *hash_pos
= input_buf
+ 10;
10205 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10206 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10207 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10208 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10209 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10211 digest
[0] -= SHA1M_A
;
10212 digest
[1] -= SHA1M_B
;
10213 digest
[2] -= SHA1M_C
;
10214 digest
[3] -= SHA1M_D
;
10215 digest
[4] -= SHA1M_E
;
10217 uint salt_len
= 10;
10219 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10221 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10223 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10225 salt
->salt_len
= salt_len
;
10227 return (PARSER_OK
);
10230 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10232 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10234 u32
*digest
= (u32
*) hash_buf
->digest
;
10236 salt_t
*salt
= hash_buf
->salt
;
10238 char *hash_pos
= input_buf
+ 8;
10240 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10241 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10242 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10243 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10244 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10246 digest
[0] -= SHA1M_A
;
10247 digest
[1] -= SHA1M_B
;
10248 digest
[2] -= SHA1M_C
;
10249 digest
[3] -= SHA1M_D
;
10250 digest
[4] -= SHA1M_E
;
10254 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10256 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10258 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10260 salt
->salt_len
= salt_len
;
10262 return (PARSER_OK
);
10265 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10267 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10269 u64
*digest
= (u64
*) hash_buf
->digest
;
10271 salt_t
*salt
= hash_buf
->salt
;
10273 char *hash_pos
= input_buf
+ 8;
10275 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10276 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10277 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10278 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10279 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10280 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10281 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10282 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10284 digest
[0] -= SHA512M_A
;
10285 digest
[1] -= SHA512M_B
;
10286 digest
[2] -= SHA512M_C
;
10287 digest
[3] -= SHA512M_D
;
10288 digest
[4] -= SHA512M_E
;
10289 digest
[5] -= SHA512M_F
;
10290 digest
[6] -= SHA512M_G
;
10291 digest
[7] -= SHA512M_H
;
10295 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10297 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10299 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10301 salt
->salt_len
= salt_len
;
10303 return (PARSER_OK
);
10306 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10308 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10310 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10314 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10317 u32
*digest
= (u32
*) hash_buf
->digest
;
10319 salt_t
*salt
= hash_buf
->salt
;
10321 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10322 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10323 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10324 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10326 digest
[0] = byte_swap_32 (digest
[0]);
10327 digest
[1] = byte_swap_32 (digest
[1]);
10328 digest
[2] = byte_swap_32 (digest
[2]);
10329 digest
[3] = byte_swap_32 (digest
[3]);
10331 digest
[0] -= MD5M_A
;
10332 digest
[1] -= MD5M_B
;
10333 digest
[2] -= MD5M_C
;
10334 digest
[3] -= MD5M_D
;
10336 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10338 uint salt_len
= input_len
- 32 - 1;
10340 char *salt_buf
= input_buf
+ 32 + 1;
10342 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10344 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10346 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10348 salt
->salt_len
= salt_len
;
10350 return (PARSER_OK
);
10353 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10355 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10357 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10361 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10366 char clean_input_buf
[32] = { 0 };
10368 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10369 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10371 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10375 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10381 clean_input_buf
[k
] = input_buf
[i
];
10389 u32
*digest
= (u32
*) hash_buf
->digest
;
10391 salt_t
*salt
= hash_buf
->salt
;
10393 u32 a
, b
, c
, d
, e
, f
;
10395 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10396 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10397 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10398 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10399 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10400 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10402 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10403 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10405 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10406 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10407 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10408 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10409 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10410 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10412 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10413 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10415 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10416 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10417 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10418 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10419 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10420 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10422 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10423 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10425 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10426 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10427 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10428 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10429 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10430 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10432 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10433 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10435 digest
[0] = byte_swap_32 (digest
[0]);
10436 digest
[1] = byte_swap_32 (digest
[1]);
10437 digest
[2] = byte_swap_32 (digest
[2]);
10438 digest
[3] = byte_swap_32 (digest
[3]);
10440 digest
[0] -= MD5M_A
;
10441 digest
[1] -= MD5M_B
;
10442 digest
[2] -= MD5M_C
;
10443 digest
[3] -= MD5M_D
;
10445 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10447 uint salt_len
= input_len
- 30 - 1;
10449 char *salt_buf
= input_buf
+ 30 + 1;
10451 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10453 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10455 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10456 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10458 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10460 salt
->salt_len
= salt_len
;
10462 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10464 salt
->salt_len
+= 22;
10466 return (PARSER_OK
);
10469 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10471 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10473 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10477 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10480 u32
*digest
= (u32
*) hash_buf
->digest
;
10482 salt_t
*salt
= hash_buf
->salt
;
10484 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10485 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10486 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10487 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10488 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10490 digest
[0] -= SHA1M_A
;
10491 digest
[1] -= SHA1M_B
;
10492 digest
[2] -= SHA1M_C
;
10493 digest
[3] -= SHA1M_D
;
10494 digest
[4] -= SHA1M_E
;
10496 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10498 uint salt_len
= input_len
- 40 - 1;
10500 char *salt_buf
= input_buf
+ 40 + 1;
10502 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10504 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10506 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10508 salt
->salt_len
= salt_len
;
10510 return (PARSER_OK
);
10513 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10515 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10517 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10521 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10524 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10526 char *iter_pos
= input_buf
+ 6;
10528 salt_t
*salt
= hash_buf
->salt
;
10530 uint iter
= atoi (iter_pos
);
10534 iter
= ROUNDS_DCC2
;
10537 salt
->salt_iter
= iter
- 1;
10539 char *salt_pos
= strchr (iter_pos
, '#');
10541 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10545 char *digest_pos
= strchr (salt_pos
, '#');
10547 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10551 uint salt_len
= digest_pos
- salt_pos
- 1;
10553 u32
*digest
= (u32
*) hash_buf
->digest
;
10555 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10556 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10557 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10558 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10560 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10562 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10564 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10566 salt
->salt_len
= salt_len
;
10568 return (PARSER_OK
);
10571 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10573 u32
*digest
= (u32
*) hash_buf
->digest
;
10575 salt_t
*salt
= hash_buf
->salt
;
10577 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10581 memcpy (&in
, input_buf
, input_len
);
10583 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10585 memcpy (digest
, in
.keymic
, 16);
10588 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10589 The phrase "Pairwise key expansion"
10590 Access Point Address (referred to as Authenticator Address AA)
10591 Supplicant Address (referred to as Supplicant Address SA)
10592 Access Point Nonce (referred to as Authenticator Anonce)
10593 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10596 uint salt_len
= strlen (in
.essid
);
10600 log_info ("WARNING: The ESSID length is too long, the hccap file may be invalid or corrupted");
10602 return (PARSER_SALT_LENGTH
);
10605 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10607 salt
->salt_len
= salt_len
;
10609 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10611 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10613 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10615 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10617 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10618 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10622 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10623 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10626 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10628 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10629 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10633 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10634 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10637 for (int i
= 0; i
< 25; i
++)
10639 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10642 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10643 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10644 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10645 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10647 wpa
->keyver
= in
.keyver
;
10649 if (wpa
->keyver
> 255)
10651 log_info ("ATTENTION!");
10652 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10653 log_info (" This could be due to a recent aircrack-ng bug.");
10654 log_info (" The key version was automatically reset to a reasonable value.");
10657 wpa
->keyver
&= 0xff;
10660 wpa
->eapol_size
= in
.eapol_size
;
10662 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10664 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10666 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10668 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10670 if (wpa
->keyver
== 1)
10676 digest
[0] = byte_swap_32 (digest
[0]);
10677 digest
[1] = byte_swap_32 (digest
[1]);
10678 digest
[2] = byte_swap_32 (digest
[2]);
10679 digest
[3] = byte_swap_32 (digest
[3]);
10681 for (int i
= 0; i
< 64; i
++)
10683 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10687 uint32_t *p0
= (uint32_t *) in
.essid
;
10691 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10692 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10694 salt
->salt_buf
[10] = c0
;
10695 salt
->salt_buf
[11] = c1
;
10697 return (PARSER_OK
);
10700 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10702 u32
*digest
= (u32
*) hash_buf
->digest
;
10704 salt_t
*salt
= hash_buf
->salt
;
10706 if (input_len
== 0)
10708 log_error ("Password Safe v2 container not specified");
10713 FILE *fp
= fopen (input_buf
, "rb");
10717 log_error ("%s: %s", input_buf
, strerror (errno
));
10724 memset (&buf
, 0, sizeof (psafe2_hdr
));
10726 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10730 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10732 salt
->salt_buf
[0] = buf
.random
[0];
10733 salt
->salt_buf
[1] = buf
.random
[1];
10735 salt
->salt_len
= 8;
10736 salt
->salt_iter
= 1000;
10738 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10739 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10740 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10741 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10742 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10744 return (PARSER_OK
);
10747 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10749 u32
*digest
= (u32
*) hash_buf
->digest
;
10751 salt_t
*salt
= hash_buf
->salt
;
10753 if (input_len
== 0)
10755 log_error (".psafe3 not specified");
10760 FILE *fp
= fopen (input_buf
, "rb");
10764 log_error ("%s: %s", input_buf
, strerror (errno
));
10771 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10775 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10777 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10779 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10781 salt
->salt_iter
= in
.iterations
+ 1;
10783 salt
->salt_buf
[0] = in
.salt_buf
[0];
10784 salt
->salt_buf
[1] = in
.salt_buf
[1];
10785 salt
->salt_buf
[2] = in
.salt_buf
[2];
10786 salt
->salt_buf
[3] = in
.salt_buf
[3];
10787 salt
->salt_buf
[4] = in
.salt_buf
[4];
10788 salt
->salt_buf
[5] = in
.salt_buf
[5];
10789 salt
->salt_buf
[6] = in
.salt_buf
[6];
10790 salt
->salt_buf
[7] = in
.salt_buf
[7];
10792 salt
->salt_len
= 32;
10794 digest
[0] = in
.hash_buf
[0];
10795 digest
[1] = in
.hash_buf
[1];
10796 digest
[2] = in
.hash_buf
[2];
10797 digest
[3] = in
.hash_buf
[3];
10798 digest
[4] = in
.hash_buf
[4];
10799 digest
[5] = in
.hash_buf
[5];
10800 digest
[6] = in
.hash_buf
[6];
10801 digest
[7] = in
.hash_buf
[7];
10803 digest
[0] = byte_swap_32 (digest
[0]);
10804 digest
[1] = byte_swap_32 (digest
[1]);
10805 digest
[2] = byte_swap_32 (digest
[2]);
10806 digest
[3] = byte_swap_32 (digest
[3]);
10807 digest
[4] = byte_swap_32 (digest
[4]);
10808 digest
[5] = byte_swap_32 (digest
[5]);
10809 digest
[6] = byte_swap_32 (digest
[6]);
10810 digest
[7] = byte_swap_32 (digest
[7]);
10812 return (PARSER_OK
);
10815 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10817 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10819 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10821 u32
*digest
= (u32
*) hash_buf
->digest
;
10823 salt_t
*salt
= hash_buf
->salt
;
10825 char *iter_pos
= input_buf
+ 3;
10827 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10829 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10831 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10833 salt
->salt_iter
= salt_iter
;
10835 char *salt_pos
= iter_pos
+ 1;
10839 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10841 salt
->salt_len
= salt_len
;
10843 char *hash_pos
= salt_pos
+ salt_len
;
10845 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10847 return (PARSER_OK
);
10850 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10852 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10854 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10856 u32
*digest
= (u32
*) hash_buf
->digest
;
10858 salt_t
*salt
= hash_buf
->salt
;
10860 char *salt_pos
= input_buf
+ 3;
10862 uint iterations_len
= 0;
10864 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10868 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10870 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10871 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10875 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10879 iterations_len
+= 8;
10883 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10886 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10888 char *hash_pos
= strchr (salt_pos
, '$');
10890 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10892 uint salt_len
= hash_pos
- salt_pos
;
10894 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10896 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10898 salt
->salt_len
= salt_len
;
10902 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10904 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10906 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10908 return (PARSER_OK
);
10911 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10913 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10915 u32
*digest
= (u32
*) hash_buf
->digest
;
10917 salt_t
*salt
= hash_buf
->salt
;
10919 char *salt_pos
= input_buf
+ 6;
10921 uint iterations_len
= 0;
10923 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10927 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10929 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10930 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10934 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10938 iterations_len
+= 8;
10942 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10945 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10947 char *hash_pos
= strchr (salt_pos
, '$');
10949 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10951 uint salt_len
= hash_pos
- salt_pos
;
10953 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10955 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10957 salt
->salt_len
= salt_len
;
10961 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10963 return (PARSER_OK
);
10966 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10968 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10970 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10972 u32
*digest
= (u32
*) hash_buf
->digest
;
10974 salt_t
*salt
= hash_buf
->salt
;
10976 char *salt_pos
= input_buf
+ 14;
10978 char *hash_pos
= strchr (salt_pos
, '*');
10980 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10984 uint salt_len
= hash_pos
- salt_pos
- 1;
10986 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10988 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10990 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10992 salt
->salt_len
= salt_len
;
10994 u8 tmp_buf
[100] = { 0 };
10996 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10998 memcpy (digest
, tmp_buf
, 20);
11000 digest
[0] = byte_swap_32 (digest
[0]);
11001 digest
[1] = byte_swap_32 (digest
[1]);
11002 digest
[2] = byte_swap_32 (digest
[2]);
11003 digest
[3] = byte_swap_32 (digest
[3]);
11004 digest
[4] = byte_swap_32 (digest
[4]);
11006 digest
[0] -= SHA1M_A
;
11007 digest
[1] -= SHA1M_B
;
11008 digest
[2] -= SHA1M_C
;
11009 digest
[3] -= SHA1M_D
;
11010 digest
[4] -= SHA1M_E
;
11012 return (PARSER_OK
);
11015 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11017 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
11019 unsigned char c12
= itoa64_to_int (input_buf
[12]);
11021 if (c12
& 3) return (PARSER_HASH_VALUE
);
11023 u32
*digest
= (u32
*) hash_buf
->digest
;
11025 salt_t
*salt
= hash_buf
->salt
;
11027 // for ascii_digest
11028 salt
->salt_sign
[0] = input_buf
[0];
11029 salt
->salt_sign
[1] = input_buf
[1];
11031 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
11032 | itoa64_to_int (input_buf
[1]) << 6;
11034 salt
->salt_len
= 2;
11036 u8 tmp_buf
[100] = { 0 };
11038 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
11040 memcpy (digest
, tmp_buf
, 8);
11044 IP (digest
[0], digest
[1], tt
);
11049 return (PARSER_OK
);
11052 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11054 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
11056 u32
*digest
= (u32
*) hash_buf
->digest
;
11058 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11059 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11060 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11061 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11063 digest
[0] = byte_swap_32 (digest
[0]);
11064 digest
[1] = byte_swap_32 (digest
[1]);
11065 digest
[2] = byte_swap_32 (digest
[2]);
11066 digest
[3] = byte_swap_32 (digest
[3]);
11068 digest
[0] -= MD4M_A
;
11069 digest
[1] -= MD4M_B
;
11070 digest
[2] -= MD4M_C
;
11071 digest
[3] -= MD4M_D
;
11073 return (PARSER_OK
);
11076 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11078 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11080 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
11084 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
11087 u32
*digest
= (u32
*) hash_buf
->digest
;
11089 salt_t
*salt
= hash_buf
->salt
;
11091 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11092 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11093 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11094 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11096 digest
[0] = byte_swap_32 (digest
[0]);
11097 digest
[1] = byte_swap_32 (digest
[1]);
11098 digest
[2] = byte_swap_32 (digest
[2]);
11099 digest
[3] = byte_swap_32 (digest
[3]);
11101 digest
[0] -= MD4M_A
;
11102 digest
[1] -= MD4M_B
;
11103 digest
[2] -= MD4M_C
;
11104 digest
[3] -= MD4M_D
;
11106 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11108 uint salt_len
= input_len
- 32 - 1;
11110 char *salt_buf
= input_buf
+ 32 + 1;
11112 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11114 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11116 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11118 salt
->salt_len
= salt_len
;
11120 return (PARSER_OK
);
11123 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11125 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
11127 u32
*digest
= (u32
*) hash_buf
->digest
;
11129 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11130 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11131 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11132 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11134 digest
[0] = byte_swap_32 (digest
[0]);
11135 digest
[1] = byte_swap_32 (digest
[1]);
11136 digest
[2] = byte_swap_32 (digest
[2]);
11137 digest
[3] = byte_swap_32 (digest
[3]);
11139 digest
[0] -= MD5M_A
;
11140 digest
[1] -= MD5M_B
;
11141 digest
[2] -= MD5M_C
;
11142 digest
[3] -= MD5M_D
;
11144 return (PARSER_OK
);
11147 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11149 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11151 u32
*digest
= (u32
*) hash_buf
->digest
;
11153 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11154 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11158 digest
[0] = byte_swap_32 (digest
[0]);
11159 digest
[1] = byte_swap_32 (digest
[1]);
11161 return (PARSER_OK
);
11164 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11166 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11168 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11172 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11175 u32
*digest
= (u32
*) hash_buf
->digest
;
11177 salt_t
*salt
= hash_buf
->salt
;
11179 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11180 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11181 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11182 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11184 digest
[0] = byte_swap_32 (digest
[0]);
11185 digest
[1] = byte_swap_32 (digest
[1]);
11186 digest
[2] = byte_swap_32 (digest
[2]);
11187 digest
[3] = byte_swap_32 (digest
[3]);
11189 digest
[0] -= MD5M_A
;
11190 digest
[1] -= MD5M_B
;
11191 digest
[2] -= MD5M_C
;
11192 digest
[3] -= MD5M_D
;
11194 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11196 uint salt_len
= input_len
- 32 - 1;
11198 char *salt_buf
= input_buf
+ 32 + 1;
11200 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11202 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11204 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11206 salt
->salt_len
= salt_len
;
11208 return (PARSER_OK
);
11211 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11213 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11215 u32
*digest
= (u32
*) hash_buf
->digest
;
11217 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11218 | itoa64_to_int (input_buf
[ 1]) << 6
11219 | itoa64_to_int (input_buf
[ 2]) << 12
11220 | itoa64_to_int (input_buf
[ 3]) << 18;
11221 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11222 | itoa64_to_int (input_buf
[ 5]) << 6
11223 | itoa64_to_int (input_buf
[ 6]) << 12
11224 | itoa64_to_int (input_buf
[ 7]) << 18;
11225 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11226 | itoa64_to_int (input_buf
[ 9]) << 6
11227 | itoa64_to_int (input_buf
[10]) << 12
11228 | itoa64_to_int (input_buf
[11]) << 18;
11229 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11230 | itoa64_to_int (input_buf
[13]) << 6
11231 | itoa64_to_int (input_buf
[14]) << 12
11232 | itoa64_to_int (input_buf
[15]) << 18;
11234 digest
[0] -= MD5M_A
;
11235 digest
[1] -= MD5M_B
;
11236 digest
[2] -= MD5M_C
;
11237 digest
[3] -= MD5M_D
;
11239 digest
[0] &= 0x00ffffff;
11240 digest
[1] &= 0x00ffffff;
11241 digest
[2] &= 0x00ffffff;
11242 digest
[3] &= 0x00ffffff;
11244 return (PARSER_OK
);
11247 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11249 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11251 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11255 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11258 u32
*digest
= (u32
*) hash_buf
->digest
;
11260 salt_t
*salt
= hash_buf
->salt
;
11262 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11263 | itoa64_to_int (input_buf
[ 1]) << 6
11264 | itoa64_to_int (input_buf
[ 2]) << 12
11265 | itoa64_to_int (input_buf
[ 3]) << 18;
11266 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11267 | itoa64_to_int (input_buf
[ 5]) << 6
11268 | itoa64_to_int (input_buf
[ 6]) << 12
11269 | itoa64_to_int (input_buf
[ 7]) << 18;
11270 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11271 | itoa64_to_int (input_buf
[ 9]) << 6
11272 | itoa64_to_int (input_buf
[10]) << 12
11273 | itoa64_to_int (input_buf
[11]) << 18;
11274 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11275 | itoa64_to_int (input_buf
[13]) << 6
11276 | itoa64_to_int (input_buf
[14]) << 12
11277 | itoa64_to_int (input_buf
[15]) << 18;
11279 digest
[0] -= MD5M_A
;
11280 digest
[1] -= MD5M_B
;
11281 digest
[2] -= MD5M_C
;
11282 digest
[3] -= MD5M_D
;
11284 digest
[0] &= 0x00ffffff;
11285 digest
[1] &= 0x00ffffff;
11286 digest
[2] &= 0x00ffffff;
11287 digest
[3] &= 0x00ffffff;
11289 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11291 uint salt_len
= input_len
- 16 - 1;
11293 char *salt_buf
= input_buf
+ 16 + 1;
11295 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11297 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11299 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11301 salt
->salt_len
= salt_len
;
11303 return (PARSER_OK
);
11306 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11308 key
[0] = (nthash
[0] >> 0);
11309 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11310 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11311 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11312 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11313 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11314 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11315 key
[7] = (nthash
[6] << 1);
11327 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11329 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11331 u32
*digest
= (u32
*) hash_buf
->digest
;
11333 salt_t
*salt
= hash_buf
->salt
;
11335 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11341 char *user_pos
= input_buf
;
11343 char *unused_pos
= strchr (user_pos
, ':');
11345 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11347 uint user_len
= unused_pos
- user_pos
;
11349 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11353 char *domain_pos
= strchr (unused_pos
, ':');
11355 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11357 uint unused_len
= domain_pos
- unused_pos
;
11359 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11363 char *srvchall_pos
= strchr (domain_pos
, ':');
11365 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11367 uint domain_len
= srvchall_pos
- domain_pos
;
11369 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11373 char *hash_pos
= strchr (srvchall_pos
, ':');
11375 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11377 uint srvchall_len
= hash_pos
- srvchall_pos
;
11379 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11383 char *clichall_pos
= strchr (hash_pos
, ':');
11385 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11387 uint hash_len
= clichall_pos
- hash_pos
;
11389 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11393 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11395 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11398 * store some data for later use
11401 netntlm
->user_len
= user_len
* 2;
11402 netntlm
->domain_len
= domain_len
* 2;
11403 netntlm
->srvchall_len
= srvchall_len
/ 2;
11404 netntlm
->clichall_len
= clichall_len
/ 2;
11406 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11407 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11410 * handle username and domainname
11413 for (uint i
= 0; i
< user_len
; i
++)
11415 *userdomain_ptr
++ = user_pos
[i
];
11416 *userdomain_ptr
++ = 0;
11419 for (uint i
= 0; i
< domain_len
; i
++)
11421 *userdomain_ptr
++ = domain_pos
[i
];
11422 *userdomain_ptr
++ = 0;
11426 * handle server challenge encoding
11429 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11431 const char p0
= srvchall_pos
[i
+ 0];
11432 const char p1
= srvchall_pos
[i
+ 1];
11434 *chall_ptr
++ = hex_convert (p1
) << 0
11435 | hex_convert (p0
) << 4;
11439 * handle client challenge encoding
11442 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11444 const char p0
= clichall_pos
[i
+ 0];
11445 const char p1
= clichall_pos
[i
+ 1];
11447 *chall_ptr
++ = hex_convert (p1
) << 0
11448 | hex_convert (p0
) << 4;
11455 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11457 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11459 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11461 salt
->salt_len
= salt_len
;
11463 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11464 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11465 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11466 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11468 digest
[0] = byte_swap_32 (digest
[0]);
11469 digest
[1] = byte_swap_32 (digest
[1]);
11470 digest
[2] = byte_swap_32 (digest
[2]);
11471 digest
[3] = byte_swap_32 (digest
[3]);
11473 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11475 uint digest_tmp
[2] = { 0 };
11477 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11478 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11480 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11481 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11483 /* special case 2: ESS */
11485 if (srvchall_len
== 48)
11487 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11489 uint w
[16] = { 0 };
11491 w
[ 0] = netntlm
->chall_buf
[6];
11492 w
[ 1] = netntlm
->chall_buf
[7];
11493 w
[ 2] = netntlm
->chall_buf
[0];
11494 w
[ 3] = netntlm
->chall_buf
[1];
11498 uint dgst
[4] = { 0 };
11507 salt
->salt_buf
[0] = dgst
[0];
11508 salt
->salt_buf
[1] = dgst
[1];
11512 /* precompute netntlmv1 exploit start */
11514 for (uint i
= 0; i
< 0x10000; i
++)
11516 uint key_md4
[2] = { i
, 0 };
11517 uint key_des
[2] = { 0, 0 };
11519 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11521 uint Kc
[16] = { 0 };
11522 uint Kd
[16] = { 0 };
11524 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11526 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11528 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11530 if (data3
[0] != digest_tmp
[0]) continue;
11531 if (data3
[1] != digest_tmp
[1]) continue;
11533 salt
->salt_buf
[2] = i
;
11535 salt
->salt_len
= 24;
11540 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11541 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11543 /* precompute netntlmv1 exploit stop */
11547 IP (digest
[0], digest
[1], tt
);
11548 IP (digest
[2], digest
[3], tt
);
11550 digest
[0] = rotr32 (digest
[0], 29);
11551 digest
[1] = rotr32 (digest
[1], 29);
11552 digest
[2] = rotr32 (digest
[2], 29);
11553 digest
[3] = rotr32 (digest
[3], 29);
11555 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11557 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11558 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11560 return (PARSER_OK
);
11563 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11565 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11567 u32
*digest
= (u32
*) hash_buf
->digest
;
11569 salt_t
*salt
= hash_buf
->salt
;
11571 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11577 char *user_pos
= input_buf
;
11579 char *unused_pos
= strchr (user_pos
, ':');
11581 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11583 uint user_len
= unused_pos
- user_pos
;
11585 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11589 char *domain_pos
= strchr (unused_pos
, ':');
11591 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11593 uint unused_len
= domain_pos
- unused_pos
;
11595 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11599 char *srvchall_pos
= strchr (domain_pos
, ':');
11601 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11603 uint domain_len
= srvchall_pos
- domain_pos
;
11605 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11609 char *hash_pos
= strchr (srvchall_pos
, ':');
11611 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11613 uint srvchall_len
= hash_pos
- srvchall_pos
;
11615 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11619 char *clichall_pos
= strchr (hash_pos
, ':');
11621 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11623 uint hash_len
= clichall_pos
- hash_pos
;
11625 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11629 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11631 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11633 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11636 * store some data for later use
11639 netntlm
->user_len
= user_len
* 2;
11640 netntlm
->domain_len
= domain_len
* 2;
11641 netntlm
->srvchall_len
= srvchall_len
/ 2;
11642 netntlm
->clichall_len
= clichall_len
/ 2;
11644 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11645 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11648 * handle username and domainname
11651 for (uint i
= 0; i
< user_len
; i
++)
11653 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11654 *userdomain_ptr
++ = 0;
11657 for (uint i
= 0; i
< domain_len
; i
++)
11659 *userdomain_ptr
++ = domain_pos
[i
];
11660 *userdomain_ptr
++ = 0;
11663 *userdomain_ptr
++ = 0x80;
11666 * handle server challenge encoding
11669 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11671 const char p0
= srvchall_pos
[i
+ 0];
11672 const char p1
= srvchall_pos
[i
+ 1];
11674 *chall_ptr
++ = hex_convert (p1
) << 0
11675 | hex_convert (p0
) << 4;
11679 * handle client challenge encoding
11682 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11684 const char p0
= clichall_pos
[i
+ 0];
11685 const char p1
= clichall_pos
[i
+ 1];
11687 *chall_ptr
++ = hex_convert (p1
) << 0
11688 | hex_convert (p0
) << 4;
11691 *chall_ptr
++ = 0x80;
11694 * handle hash itself
11697 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11698 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11699 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11700 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11702 digest
[0] = byte_swap_32 (digest
[0]);
11703 digest
[1] = byte_swap_32 (digest
[1]);
11704 digest
[2] = byte_swap_32 (digest
[2]);
11705 digest
[3] = byte_swap_32 (digest
[3]);
11708 * reuse challange data as salt_buf, its the buffer that is most likely unique
11711 salt
->salt_buf
[0] = 0;
11712 salt
->salt_buf
[1] = 0;
11713 salt
->salt_buf
[2] = 0;
11714 salt
->salt_buf
[3] = 0;
11715 salt
->salt_buf
[4] = 0;
11716 salt
->salt_buf
[5] = 0;
11717 salt
->salt_buf
[6] = 0;
11718 salt
->salt_buf
[7] = 0;
11722 uptr
= (uint
*) netntlm
->userdomain_buf
;
11724 for (uint i
= 0; i
< 16; i
+= 16)
11726 md5_64 (uptr
, salt
->salt_buf
);
11729 uptr
= (uint
*) netntlm
->chall_buf
;
11731 for (uint i
= 0; i
< 256; i
+= 16)
11733 md5_64 (uptr
, salt
->salt_buf
);
11736 salt
->salt_len
= 16;
11738 return (PARSER_OK
);
11741 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11743 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11745 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11749 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11752 u32
*digest
= (u32
*) hash_buf
->digest
;
11754 salt_t
*salt
= hash_buf
->salt
;
11756 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11757 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11758 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11759 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11761 digest
[0] = byte_swap_32 (digest
[0]);
11762 digest
[1] = byte_swap_32 (digest
[1]);
11763 digest
[2] = byte_swap_32 (digest
[2]);
11764 digest
[3] = byte_swap_32 (digest
[3]);
11766 digest
[0] -= MD5M_A
;
11767 digest
[1] -= MD5M_B
;
11768 digest
[2] -= MD5M_C
;
11769 digest
[3] -= MD5M_D
;
11771 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11773 uint salt_len
= input_len
- 32 - 1;
11775 char *salt_buf
= input_buf
+ 32 + 1;
11777 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11779 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11781 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11783 salt
->salt_len
= salt_len
;
11785 return (PARSER_OK
);
11788 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11790 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11792 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11796 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11799 u32
*digest
= (u32
*) hash_buf
->digest
;
11801 salt_t
*salt
= hash_buf
->salt
;
11803 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11804 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11805 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11806 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11808 digest
[0] = byte_swap_32 (digest
[0]);
11809 digest
[1] = byte_swap_32 (digest
[1]);
11810 digest
[2] = byte_swap_32 (digest
[2]);
11811 digest
[3] = byte_swap_32 (digest
[3]);
11813 digest
[0] -= MD5M_A
;
11814 digest
[1] -= MD5M_B
;
11815 digest
[2] -= MD5M_C
;
11816 digest
[3] -= MD5M_D
;
11818 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11820 uint salt_len
= input_len
- 32 - 1;
11822 char *salt_buf
= input_buf
+ 32 + 1;
11824 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11826 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11828 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11830 salt
->salt_len
= salt_len
;
11832 return (PARSER_OK
);
11835 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11837 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11839 u32
*digest
= (u32
*) hash_buf
->digest
;
11841 salt_t
*salt
= hash_buf
->salt
;
11843 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11844 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11845 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11846 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11848 digest
[0] = byte_swap_32 (digest
[0]);
11849 digest
[1] = byte_swap_32 (digest
[1]);
11850 digest
[2] = byte_swap_32 (digest
[2]);
11851 digest
[3] = byte_swap_32 (digest
[3]);
11853 digest
[0] -= MD5M_A
;
11854 digest
[1] -= MD5M_B
;
11855 digest
[2] -= MD5M_C
;
11856 digest
[3] -= MD5M_D
;
11859 * This is a virtual salt. While the algorithm is basically not salted
11860 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11861 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11864 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11866 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11868 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11870 salt
->salt_len
= salt_len
;
11872 return (PARSER_OK
);
11875 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11877 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11879 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11883 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11886 u32
*digest
= (u32
*) hash_buf
->digest
;
11888 salt_t
*salt
= hash_buf
->salt
;
11890 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11891 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11892 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11893 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11895 digest
[0] = byte_swap_32 (digest
[0]);
11896 digest
[1] = byte_swap_32 (digest
[1]);
11897 digest
[2] = byte_swap_32 (digest
[2]);
11898 digest
[3] = byte_swap_32 (digest
[3]);
11900 digest
[0] -= MD5M_A
;
11901 digest
[1] -= MD5M_B
;
11902 digest
[2] -= MD5M_C
;
11903 digest
[3] -= MD5M_D
;
11905 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11907 uint salt_len
= input_len
- 32 - 1;
11909 char *salt_buf
= input_buf
+ 32 + 1;
11911 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11913 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11915 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11917 salt
->salt_len
= salt_len
;
11919 return (PARSER_OK
);
11922 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11924 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11926 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11930 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11933 u32
*digest
= (u32
*) hash_buf
->digest
;
11935 salt_t
*salt
= hash_buf
->salt
;
11937 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11938 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11939 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11940 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11942 digest
[0] = byte_swap_32 (digest
[0]);
11943 digest
[1] = byte_swap_32 (digest
[1]);
11944 digest
[2] = byte_swap_32 (digest
[2]);
11945 digest
[3] = byte_swap_32 (digest
[3]);
11947 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11949 uint salt_len
= input_len
- 32 - 1;
11951 char *salt_buf
= input_buf
+ 32 + 1;
11953 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11955 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11957 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11959 salt
->salt_len
= salt_len
;
11961 return (PARSER_OK
);
11964 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11966 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11968 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11972 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11975 u32
*digest
= (u32
*) hash_buf
->digest
;
11977 salt_t
*salt
= hash_buf
->salt
;
11979 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11980 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11981 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11982 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11984 digest
[0] = byte_swap_32 (digest
[0]);
11985 digest
[1] = byte_swap_32 (digest
[1]);
11986 digest
[2] = byte_swap_32 (digest
[2]);
11987 digest
[3] = byte_swap_32 (digest
[3]);
11989 digest
[0] -= MD4M_A
;
11990 digest
[1] -= MD4M_B
;
11991 digest
[2] -= MD4M_C
;
11992 digest
[3] -= MD4M_D
;
11994 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11996 uint salt_len
= input_len
- 32 - 1;
11998 char *salt_buf
= input_buf
+ 32 + 1;
12000 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12002 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12004 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12006 salt
->salt_len
= salt_len
;
12008 return (PARSER_OK
);
12011 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12013 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12015 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
12019 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
12022 u32
*digest
= (u32
*) hash_buf
->digest
;
12024 salt_t
*salt
= hash_buf
->salt
;
12026 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12027 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12028 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12029 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12031 digest
[0] = byte_swap_32 (digest
[0]);
12032 digest
[1] = byte_swap_32 (digest
[1]);
12033 digest
[2] = byte_swap_32 (digest
[2]);
12034 digest
[3] = byte_swap_32 (digest
[3]);
12036 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12038 uint salt_len
= input_len
- 32 - 1;
12040 char *salt_buf
= input_buf
+ 32 + 1;
12042 uint salt_pc_block
[16] = { 0 };
12044 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
12046 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
12048 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12050 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
12052 salt_pc_block
[14] = salt_len
* 8;
12054 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
12056 md5_64 (salt_pc_block
, salt_pc_digest
);
12058 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
12059 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
12060 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
12061 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
12063 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
12065 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
12067 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
12069 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
12070 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
12071 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
12072 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
12074 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
12076 return (PARSER_OK
);
12079 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12081 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
12083 u32
*digest
= (u32
*) hash_buf
->digest
;
12085 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12086 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12087 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12088 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12089 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12091 digest
[0] -= SHA1M_A
;
12092 digest
[1] -= SHA1M_B
;
12093 digest
[2] -= SHA1M_C
;
12094 digest
[3] -= SHA1M_D
;
12095 digest
[4] -= SHA1M_E
;
12097 return (PARSER_OK
);
12100 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12102 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
12104 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
12106 u32
*digest
= (u32
*) hash_buf
->digest
;
12110 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12111 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12112 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12113 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12116 return (PARSER_OK
);
12119 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12121 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12123 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12127 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12130 u32
*digest
= (u32
*) hash_buf
->digest
;
12132 salt_t
*salt
= hash_buf
->salt
;
12134 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12135 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12136 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12137 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12138 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12140 digest
[0] -= SHA1M_A
;
12141 digest
[1] -= SHA1M_B
;
12142 digest
[2] -= SHA1M_C
;
12143 digest
[3] -= SHA1M_D
;
12144 digest
[4] -= SHA1M_E
;
12146 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12148 uint salt_len
= input_len
- 40 - 1;
12150 char *salt_buf
= input_buf
+ 40 + 1;
12152 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12154 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12156 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12158 salt
->salt_len
= salt_len
;
12160 return (PARSER_OK
);
12163 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12165 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12167 u32
*digest
= (u32
*) hash_buf
->digest
;
12169 salt_t
*salt
= hash_buf
->salt
;
12171 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12173 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12174 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12175 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12176 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12177 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12179 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12181 uint salt_len
= input_len
- 40 - 1;
12183 char *salt_buf
= input_buf
+ 40 + 1;
12185 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12187 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12189 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12191 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12194 pstoken
->salt_len
= salt_len
/ 2;
12196 /* some fake salt for the sorting mechanisms */
12198 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12199 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12200 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12201 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12202 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12203 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12204 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12205 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12207 salt
->salt_len
= 32;
12209 /* we need to check if we can precompute some of the data --
12210 this is possible since the scheme is badly designed */
12212 pstoken
->pc_digest
[0] = SHA1M_A
;
12213 pstoken
->pc_digest
[1] = SHA1M_B
;
12214 pstoken
->pc_digest
[2] = SHA1M_C
;
12215 pstoken
->pc_digest
[3] = SHA1M_D
;
12216 pstoken
->pc_digest
[4] = SHA1M_E
;
12218 pstoken
->pc_offset
= 0;
12220 for (int i
= 0; i
< (int) pstoken
->salt_len
- 63; i
+= 64)
12224 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12225 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12226 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12227 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12228 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12229 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12230 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12231 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12232 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12233 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12234 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12235 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12236 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12237 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12238 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12239 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12241 sha1_64 (w
, pstoken
->pc_digest
);
12243 pstoken
->pc_offset
+= 16;
12246 return (PARSER_OK
);
12249 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12251 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12253 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12255 u32
*digest
= (u32
*) hash_buf
->digest
;
12257 u8 tmp_buf
[100] = { 0 };
12259 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12261 memcpy (digest
, tmp_buf
, 20);
12263 digest
[0] = byte_swap_32 (digest
[0]);
12264 digest
[1] = byte_swap_32 (digest
[1]);
12265 digest
[2] = byte_swap_32 (digest
[2]);
12266 digest
[3] = byte_swap_32 (digest
[3]);
12267 digest
[4] = byte_swap_32 (digest
[4]);
12269 digest
[0] -= SHA1M_A
;
12270 digest
[1] -= SHA1M_B
;
12271 digest
[2] -= SHA1M_C
;
12272 digest
[3] -= SHA1M_D
;
12273 digest
[4] -= SHA1M_E
;
12275 return (PARSER_OK
);
12278 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12280 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12282 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12284 u32
*digest
= (u32
*) hash_buf
->digest
;
12286 salt_t
*salt
= hash_buf
->salt
;
12288 u8 tmp_buf
[100] = { 0 };
12290 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12292 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12294 memcpy (digest
, tmp_buf
, 20);
12296 int salt_len
= tmp_len
- 20;
12298 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12300 salt
->salt_len
= salt_len
;
12302 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12304 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12306 char *ptr
= (char *) salt
->salt_buf
;
12308 ptr
[salt
->salt_len
] = 0x80;
12311 digest
[0] = byte_swap_32 (digest
[0]);
12312 digest
[1] = byte_swap_32 (digest
[1]);
12313 digest
[2] = byte_swap_32 (digest
[2]);
12314 digest
[3] = byte_swap_32 (digest
[3]);
12315 digest
[4] = byte_swap_32 (digest
[4]);
12317 digest
[0] -= SHA1M_A
;
12318 digest
[1] -= SHA1M_B
;
12319 digest
[2] -= SHA1M_C
;
12320 digest
[3] -= SHA1M_D
;
12321 digest
[4] -= SHA1M_E
;
12323 return (PARSER_OK
);
12326 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12328 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12330 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12332 u32
*digest
= (u32
*) hash_buf
->digest
;
12334 salt_t
*salt
= hash_buf
->salt
;
12336 char *salt_buf
= input_buf
+ 6;
12340 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12342 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12344 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12346 salt
->salt_len
= salt_len
;
12348 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12350 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12351 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12352 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12353 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12354 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12356 digest
[0] -= SHA1M_A
;
12357 digest
[1] -= SHA1M_B
;
12358 digest
[2] -= SHA1M_C
;
12359 digest
[3] -= SHA1M_D
;
12360 digest
[4] -= SHA1M_E
;
12362 return (PARSER_OK
);
12365 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12367 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12369 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12371 u32
*digest
= (u32
*) hash_buf
->digest
;
12373 salt_t
*salt
= hash_buf
->salt
;
12375 char *salt_buf
= input_buf
+ 6;
12379 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12381 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12383 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12385 salt
->salt_len
= salt_len
;
12387 char *hash_pos
= input_buf
+ 6 + 8;
12389 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12390 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12391 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12392 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12393 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12395 digest
[0] -= SHA1M_A
;
12396 digest
[1] -= SHA1M_B
;
12397 digest
[2] -= SHA1M_C
;
12398 digest
[3] -= SHA1M_D
;
12399 digest
[4] -= SHA1M_E
;
12401 return (PARSER_OK
);
12404 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12406 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12408 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12410 u64
*digest
= (u64
*) hash_buf
->digest
;
12412 salt_t
*salt
= hash_buf
->salt
;
12414 char *salt_buf
= input_buf
+ 6;
12418 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12420 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12422 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12424 salt
->salt_len
= salt_len
;
12426 char *hash_pos
= input_buf
+ 6 + 8;
12428 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12429 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12430 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12431 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12432 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12433 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12434 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12435 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12437 digest
[0] -= SHA512M_A
;
12438 digest
[1] -= SHA512M_B
;
12439 digest
[2] -= SHA512M_C
;
12440 digest
[3] -= SHA512M_D
;
12441 digest
[4] -= SHA512M_E
;
12442 digest
[5] -= SHA512M_F
;
12443 digest
[6] -= SHA512M_G
;
12444 digest
[7] -= SHA512M_H
;
12446 return (PARSER_OK
);
12449 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12451 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12453 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12457 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12460 u32
*digest
= (u32
*) hash_buf
->digest
;
12462 salt_t
*salt
= hash_buf
->salt
;
12464 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12465 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12469 digest
[0] = byte_swap_32 (digest
[0]);
12470 digest
[1] = byte_swap_32 (digest
[1]);
12472 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12474 uint salt_len
= input_len
- 16 - 1;
12476 char *salt_buf
= input_buf
+ 16 + 1;
12478 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12480 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12482 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12484 salt
->salt_len
= salt_len
;
12486 return (PARSER_OK
);
12489 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12491 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12493 u32
*digest
= (u32
*) hash_buf
->digest
;
12495 salt_t
*salt
= hash_buf
->salt
;
12497 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12498 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12499 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12500 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12501 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12503 digest
[0] -= SHA1M_A
;
12504 digest
[1] -= SHA1M_B
;
12505 digest
[2] -= SHA1M_C
;
12506 digest
[3] -= SHA1M_D
;
12507 digest
[4] -= SHA1M_E
;
12509 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12511 uint salt_len
= input_len
- 40 - 1;
12513 char *salt_buf
= input_buf
+ 40 + 1;
12515 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12517 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12519 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12521 salt
->salt_len
= salt_len
;
12523 return (PARSER_OK
);
12526 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12528 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12530 u32
*digest
= (u32
*) hash_buf
->digest
;
12532 salt_t
*salt
= hash_buf
->salt
;
12534 char *hash_pos
= input_buf
;
12536 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12537 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12538 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12539 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12540 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12541 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12542 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12543 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12544 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12545 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12546 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12547 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12548 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12549 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12550 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12551 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12553 char *salt_pos
= input_buf
+ 128;
12555 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12556 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12557 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12558 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12560 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12561 salt
->salt_len
= 16;
12563 return (PARSER_OK
);
12566 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12568 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12570 u32
*digest
= (u32
*) hash_buf
->digest
;
12572 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12573 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12574 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12575 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12576 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12577 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12578 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12579 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12581 digest
[0] -= SHA256M_A
;
12582 digest
[1] -= SHA256M_B
;
12583 digest
[2] -= SHA256M_C
;
12584 digest
[3] -= SHA256M_D
;
12585 digest
[4] -= SHA256M_E
;
12586 digest
[5] -= SHA256M_F
;
12587 digest
[6] -= SHA256M_G
;
12588 digest
[7] -= SHA256M_H
;
12590 return (PARSER_OK
);
12593 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12595 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12597 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12601 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12604 u32
*digest
= (u32
*) hash_buf
->digest
;
12606 salt_t
*salt
= hash_buf
->salt
;
12608 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12609 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12610 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12611 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12612 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12613 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12614 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12615 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12617 digest
[0] -= SHA256M_A
;
12618 digest
[1] -= SHA256M_B
;
12619 digest
[2] -= SHA256M_C
;
12620 digest
[3] -= SHA256M_D
;
12621 digest
[4] -= SHA256M_E
;
12622 digest
[5] -= SHA256M_F
;
12623 digest
[6] -= SHA256M_G
;
12624 digest
[7] -= SHA256M_H
;
12626 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12628 uint salt_len
= input_len
- 64 - 1;
12630 char *salt_buf
= input_buf
+ 64 + 1;
12632 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12634 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12636 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12638 salt
->salt_len
= salt_len
;
12640 return (PARSER_OK
);
12643 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12645 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12647 u64
*digest
= (u64
*) hash_buf
->digest
;
12649 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12650 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12651 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12652 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12653 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12654 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12658 digest
[0] -= SHA384M_A
;
12659 digest
[1] -= SHA384M_B
;
12660 digest
[2] -= SHA384M_C
;
12661 digest
[3] -= SHA384M_D
;
12662 digest
[4] -= SHA384M_E
;
12663 digest
[5] -= SHA384M_F
;
12667 return (PARSER_OK
);
12670 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12672 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12674 u64
*digest
= (u64
*) hash_buf
->digest
;
12676 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12677 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12678 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12679 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12680 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12681 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12682 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12683 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12685 digest
[0] -= SHA512M_A
;
12686 digest
[1] -= SHA512M_B
;
12687 digest
[2] -= SHA512M_C
;
12688 digest
[3] -= SHA512M_D
;
12689 digest
[4] -= SHA512M_E
;
12690 digest
[5] -= SHA512M_F
;
12691 digest
[6] -= SHA512M_G
;
12692 digest
[7] -= SHA512M_H
;
12694 return (PARSER_OK
);
12697 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12699 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12701 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12705 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12708 u64
*digest
= (u64
*) hash_buf
->digest
;
12710 salt_t
*salt
= hash_buf
->salt
;
12712 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12713 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12714 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12715 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12716 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12717 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12718 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12719 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12721 digest
[0] -= SHA512M_A
;
12722 digest
[1] -= SHA512M_B
;
12723 digest
[2] -= SHA512M_C
;
12724 digest
[3] -= SHA512M_D
;
12725 digest
[4] -= SHA512M_E
;
12726 digest
[5] -= SHA512M_F
;
12727 digest
[6] -= SHA512M_G
;
12728 digest
[7] -= SHA512M_H
;
12730 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12732 uint salt_len
= input_len
- 128 - 1;
12734 char *salt_buf
= input_buf
+ 128 + 1;
12736 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12738 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12740 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12742 salt
->salt_len
= salt_len
;
12744 return (PARSER_OK
);
12747 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12749 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12751 u64
*digest
= (u64
*) hash_buf
->digest
;
12753 salt_t
*salt
= hash_buf
->salt
;
12755 char *salt_pos
= input_buf
+ 3;
12757 uint iterations_len
= 0;
12759 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12763 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12765 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12766 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12770 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12774 iterations_len
+= 8;
12778 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12781 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12783 char *hash_pos
= strchr (salt_pos
, '$');
12785 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12787 uint salt_len
= hash_pos
- salt_pos
;
12789 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12791 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12793 salt
->salt_len
= salt_len
;
12797 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12799 return (PARSER_OK
);
12802 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12804 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12806 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12808 u64
*digest
= (u64
*) hash_buf
->digest
;
12810 salt_t
*salt
= hash_buf
->salt
;
12812 uint keccak_mdlen
= input_len
/ 2;
12814 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12816 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12818 digest
[i
] = byte_swap_64 (digest
[i
]);
12821 salt
->keccak_mdlen
= keccak_mdlen
;
12823 return (PARSER_OK
);
12826 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12828 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12830 u32
*digest
= (u32
*) hash_buf
->digest
;
12832 salt_t
*salt
= hash_buf
->salt
;
12834 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12837 * Parse that strange long line
12842 size_t in_len
[9] = { 0 };
12844 in_off
[0] = strtok (input_buf
, ":");
12846 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12848 in_len
[0] = strlen (in_off
[0]);
12852 for (i
= 1; i
< 9; i
++)
12854 in_off
[i
] = strtok (NULL
, ":");
12856 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12858 in_len
[i
] = strlen (in_off
[i
]);
12861 char *ptr
= (char *) ikepsk
->msg_buf
;
12863 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12864 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12865 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12866 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12867 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12868 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12872 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12874 ptr
= (char *) ikepsk
->nr_buf
;
12876 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12877 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12881 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12884 * Store to database
12889 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12890 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12891 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12892 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12894 digest
[0] = byte_swap_32 (digest
[0]);
12895 digest
[1] = byte_swap_32 (digest
[1]);
12896 digest
[2] = byte_swap_32 (digest
[2]);
12897 digest
[3] = byte_swap_32 (digest
[3]);
12899 salt
->salt_len
= 32;
12901 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12902 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12903 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12904 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12905 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12906 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12907 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12908 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12910 return (PARSER_OK
);
12913 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12915 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12917 u32
*digest
= (u32
*) hash_buf
->digest
;
12919 salt_t
*salt
= hash_buf
->salt
;
12921 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12924 * Parse that strange long line
12929 size_t in_len
[9] = { 0 };
12931 in_off
[0] = strtok (input_buf
, ":");
12933 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12935 in_len
[0] = strlen (in_off
[0]);
12939 for (i
= 1; i
< 9; i
++)
12941 in_off
[i
] = strtok (NULL
, ":");
12943 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12945 in_len
[i
] = strlen (in_off
[i
]);
12948 char *ptr
= (char *) ikepsk
->msg_buf
;
12950 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12951 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12952 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12953 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12954 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12955 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12959 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12961 ptr
= (char *) ikepsk
->nr_buf
;
12963 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12964 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12968 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12971 * Store to database
12976 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12977 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12978 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12979 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12980 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12982 salt
->salt_len
= 32;
12984 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12985 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12986 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12987 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12988 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12989 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12990 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12991 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12993 return (PARSER_OK
);
12996 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12998 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
13000 u32
*digest
= (u32
*) hash_buf
->digest
;
13002 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13003 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13004 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13005 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13006 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13008 digest
[0] = byte_swap_32 (digest
[0]);
13009 digest
[1] = byte_swap_32 (digest
[1]);
13010 digest
[2] = byte_swap_32 (digest
[2]);
13011 digest
[3] = byte_swap_32 (digest
[3]);
13012 digest
[4] = byte_swap_32 (digest
[4]);
13014 return (PARSER_OK
);
13017 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13019 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
13021 u32
*digest
= (u32
*) hash_buf
->digest
;
13023 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13024 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13025 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
13026 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
13027 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
13028 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
13029 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
13030 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
13031 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
13032 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
13033 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
13034 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
13035 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
13036 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
13037 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
13038 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
13040 return (PARSER_OK
);
13043 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13045 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
13047 u32
*digest
= (u32
*) hash_buf
->digest
;
13049 salt_t
*salt
= hash_buf
->salt
;
13051 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13052 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13053 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13054 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13055 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13057 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13059 uint salt_len
= input_len
- 40 - 1;
13061 char *salt_buf
= input_buf
+ 40 + 1;
13063 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13065 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13067 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13069 salt
->salt_len
= salt_len
;
13071 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
13073 return (PARSER_OK
);
13076 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13078 u32
*digest
= (u32
*) hash_buf
->digest
;
13080 salt_t
*salt
= hash_buf
->salt
;
13082 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13084 if (input_len
== 0)
13086 log_error ("TrueCrypt container not specified");
13091 FILE *fp
= fopen (input_buf
, "rb");
13095 log_error ("%s: %s", input_buf
, strerror (errno
));
13100 char buf
[512] = { 0 };
13102 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13106 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13108 memcpy (tc
->salt_buf
, buf
, 64);
13110 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13112 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13114 salt
->salt_len
= 4;
13116 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
13118 tc
->signature
= 0x45555254; // "TRUE"
13120 digest
[0] = tc
->data_buf
[0];
13122 return (PARSER_OK
);
13125 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13127 u32
*digest
= (u32
*) hash_buf
->digest
;
13129 salt_t
*salt
= hash_buf
->salt
;
13131 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13133 if (input_len
== 0)
13135 log_error ("TrueCrypt container not specified");
13140 FILE *fp
= fopen (input_buf
, "rb");
13144 log_error ("%s: %s", input_buf
, strerror (errno
));
13149 char buf
[512] = { 0 };
13151 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13155 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13157 memcpy (tc
->salt_buf
, buf
, 64);
13159 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13161 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13163 salt
->salt_len
= 4;
13165 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13167 tc
->signature
= 0x45555254; // "TRUE"
13169 digest
[0] = tc
->data_buf
[0];
13171 return (PARSER_OK
);
13174 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13176 u32
*digest
= (u32
*) hash_buf
->digest
;
13178 salt_t
*salt
= hash_buf
->salt
;
13180 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13182 if (input_len
== 0)
13184 log_error ("VeraCrypt container not specified");
13189 FILE *fp
= fopen (input_buf
, "rb");
13193 log_error ("%s: %s", input_buf
, strerror (errno
));
13198 char buf
[512] = { 0 };
13200 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13204 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13206 memcpy (tc
->salt_buf
, buf
, 64);
13208 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13210 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13212 salt
->salt_len
= 4;
13214 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13216 tc
->signature
= 0x41524556; // "VERA"
13218 digest
[0] = tc
->data_buf
[0];
13220 return (PARSER_OK
);
13223 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13225 u32
*digest
= (u32
*) hash_buf
->digest
;
13227 salt_t
*salt
= hash_buf
->salt
;
13229 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13231 if (input_len
== 0)
13233 log_error ("VeraCrypt container not specified");
13238 FILE *fp
= fopen (input_buf
, "rb");
13242 log_error ("%s: %s", input_buf
, strerror (errno
));
13247 char buf
[512] = { 0 };
13249 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13253 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13255 memcpy (tc
->salt_buf
, buf
, 64);
13257 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13259 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13261 salt
->salt_len
= 4;
13263 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13265 tc
->signature
= 0x41524556; // "VERA"
13267 digest
[0] = tc
->data_buf
[0];
13269 return (PARSER_OK
);
13272 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13274 u32
*digest
= (u32
*) hash_buf
->digest
;
13276 salt_t
*salt
= hash_buf
->salt
;
13278 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13280 if (input_len
== 0)
13282 log_error ("VeraCrypt container not specified");
13287 FILE *fp
= fopen (input_buf
, "rb");
13291 log_error ("%s: %s", input_buf
, strerror (errno
));
13296 char buf
[512] = { 0 };
13298 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13302 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13304 memcpy (tc
->salt_buf
, buf
, 64);
13306 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13308 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13310 salt
->salt_len
= 4;
13312 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13314 tc
->signature
= 0x41524556; // "VERA"
13316 digest
[0] = tc
->data_buf
[0];
13318 return (PARSER_OK
);
13321 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13323 u32
*digest
= (u32
*) hash_buf
->digest
;
13325 salt_t
*salt
= hash_buf
->salt
;
13327 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13329 if (input_len
== 0)
13331 log_error ("VeraCrypt container not specified");
13336 FILE *fp
= fopen (input_buf
, "rb");
13340 log_error ("%s: %s", input_buf
, strerror (errno
));
13345 char buf
[512] = { 0 };
13347 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13351 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13353 memcpy (tc
->salt_buf
, buf
, 64);
13355 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13357 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13359 salt
->salt_len
= 4;
13361 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13363 tc
->signature
= 0x41524556; // "VERA"
13365 digest
[0] = tc
->data_buf
[0];
13367 return (PARSER_OK
);
13370 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13372 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13374 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13376 u32
*digest
= (u32
*) hash_buf
->digest
;
13378 salt_t
*salt
= hash_buf
->salt
;
13380 char *salt_pos
= input_buf
+ 6;
13382 char *hash_pos
= strchr (salt_pos
, '$');
13384 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13386 uint salt_len
= hash_pos
- salt_pos
;
13388 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13390 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13392 salt
->salt_len
= salt_len
;
13394 salt
->salt_iter
= 1000;
13398 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13400 return (PARSER_OK
);
13403 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13405 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13407 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13409 u32
*digest
= (u32
*) hash_buf
->digest
;
13411 salt_t
*salt
= hash_buf
->salt
;
13413 char *iter_pos
= input_buf
+ 7;
13415 char *salt_pos
= strchr (iter_pos
, '$');
13417 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13421 char *hash_pos
= strchr (salt_pos
, '$');
13423 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13425 uint salt_len
= hash_pos
- salt_pos
;
13427 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13429 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13431 salt
->salt_len
= salt_len
;
13433 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13435 salt
->salt_sign
[0] = atoi (salt_iter
);
13437 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13441 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13443 digest
[0] = byte_swap_32 (digest
[0]);
13444 digest
[1] = byte_swap_32 (digest
[1]);
13445 digest
[2] = byte_swap_32 (digest
[2]);
13446 digest
[3] = byte_swap_32 (digest
[3]);
13447 digest
[4] = byte_swap_32 (digest
[4]);
13449 return (PARSER_OK
);
13452 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13454 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13456 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13458 u32
*digest
= (u32
*) hash_buf
->digest
;
13460 salt_t
*salt
= hash_buf
->salt
;
13462 char *iter_pos
= input_buf
+ 9;
13464 char *salt_pos
= strchr (iter_pos
, '$');
13466 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13470 char *hash_pos
= strchr (salt_pos
, '$');
13472 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13474 uint salt_len
= hash_pos
- salt_pos
;
13476 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13478 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13480 salt
->salt_len
= salt_len
;
13482 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13484 salt
->salt_sign
[0] = atoi (salt_iter
);
13486 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13490 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13492 digest
[0] = byte_swap_32 (digest
[0]);
13493 digest
[1] = byte_swap_32 (digest
[1]);
13494 digest
[2] = byte_swap_32 (digest
[2]);
13495 digest
[3] = byte_swap_32 (digest
[3]);
13496 digest
[4] = byte_swap_32 (digest
[4]);
13497 digest
[5] = byte_swap_32 (digest
[5]);
13498 digest
[6] = byte_swap_32 (digest
[6]);
13499 digest
[7] = byte_swap_32 (digest
[7]);
13501 return (PARSER_OK
);
13504 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13506 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13508 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13510 u64
*digest
= (u64
*) hash_buf
->digest
;
13512 salt_t
*salt
= hash_buf
->salt
;
13514 char *iter_pos
= input_buf
+ 9;
13516 char *salt_pos
= strchr (iter_pos
, '$');
13518 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13522 char *hash_pos
= strchr (salt_pos
, '$');
13524 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13526 uint salt_len
= hash_pos
- salt_pos
;
13528 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13530 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13532 salt
->salt_len
= salt_len
;
13534 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13536 salt
->salt_sign
[0] = atoi (salt_iter
);
13538 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13542 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13544 digest
[0] = byte_swap_64 (digest
[0]);
13545 digest
[1] = byte_swap_64 (digest
[1]);
13546 digest
[2] = byte_swap_64 (digest
[2]);
13547 digest
[3] = byte_swap_64 (digest
[3]);
13548 digest
[4] = byte_swap_64 (digest
[4]);
13549 digest
[5] = byte_swap_64 (digest
[5]);
13550 digest
[6] = byte_swap_64 (digest
[6]);
13551 digest
[7] = byte_swap_64 (digest
[7]);
13553 return (PARSER_OK
);
13556 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13558 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13560 u32
*digest
= (u32
*) hash_buf
->digest
;
13562 salt_t
*salt
= hash_buf
->salt
;
13564 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13570 char *iterations_pos
= input_buf
;
13572 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13574 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13576 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13578 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13582 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13584 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13586 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13588 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13590 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13592 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13597 * pbkdf2 iterations
13600 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13603 * handle salt encoding
13606 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13608 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13610 const char p0
= saltbuf_pos
[i
+ 0];
13611 const char p1
= saltbuf_pos
[i
+ 1];
13613 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13614 | hex_convert (p0
) << 4;
13617 salt
->salt_len
= saltbuf_len
/ 2;
13620 * handle cipher encoding
13623 uint
*tmp
= (uint
*) mymalloc (32);
13625 char *cipherbuf_ptr
= (char *) tmp
;
13627 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13629 const char p0
= cipherbuf_pos
[i
+ 0];
13630 const char p1
= cipherbuf_pos
[i
+ 1];
13632 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13633 | hex_convert (p0
) << 4;
13636 // iv is stored at salt_buf 4 (length 16)
13637 // data is stored at salt_buf 8 (length 16)
13639 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13640 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13641 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13642 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13644 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13645 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13646 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13647 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13651 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13653 const char p0
= cipherbuf_pos
[j
+ 0];
13654 const char p1
= cipherbuf_pos
[j
+ 1];
13656 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13657 | hex_convert (p0
) << 4;
13664 digest
[0] = 0x10101010;
13665 digest
[1] = 0x10101010;
13666 digest
[2] = 0x10101010;
13667 digest
[3] = 0x10101010;
13669 return (PARSER_OK
);
13672 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13674 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13676 u32
*digest
= (u32
*) hash_buf
->digest
;
13678 salt_t
*salt
= hash_buf
->salt
;
13680 char *hashbuf_pos
= input_buf
;
13682 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13684 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13686 uint hash_len
= iterations_pos
- hashbuf_pos
;
13688 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13692 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13694 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13696 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13700 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13702 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13704 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13706 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13708 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13710 salt
->salt_len
= salt_len
;
13712 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13714 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13715 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13716 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13717 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13719 return (PARSER_OK
);
13722 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13724 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13726 u32
*digest
= (u32
*) hash_buf
->digest
;
13728 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13729 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13730 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13731 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13732 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13733 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13734 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13735 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13737 digest
[0] = byte_swap_32 (digest
[0]);
13738 digest
[1] = byte_swap_32 (digest
[1]);
13739 digest
[2] = byte_swap_32 (digest
[2]);
13740 digest
[3] = byte_swap_32 (digest
[3]);
13741 digest
[4] = byte_swap_32 (digest
[4]);
13742 digest
[5] = byte_swap_32 (digest
[5]);
13743 digest
[6] = byte_swap_32 (digest
[6]);
13744 digest
[7] = byte_swap_32 (digest
[7]);
13746 return (PARSER_OK
);
13749 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13751 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13753 u32
*digest
= (u32
*) hash_buf
->digest
;
13755 salt_t
*salt
= hash_buf
->salt
;
13757 char *salt_pos
= input_buf
+ 3;
13759 uint iterations_len
= 0;
13761 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13765 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13767 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13768 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13772 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13776 iterations_len
+= 8;
13780 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13783 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13785 char *hash_pos
= strchr (salt_pos
, '$');
13787 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13789 uint salt_len
= hash_pos
- salt_pos
;
13791 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13793 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13795 salt
->salt_len
= salt_len
;
13799 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13801 return (PARSER_OK
);
13804 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13806 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13808 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13810 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13812 u64
*digest
= (u64
*) hash_buf
->digest
;
13814 salt_t
*salt
= hash_buf
->salt
;
13816 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13818 char *iter_pos
= input_buf
+ 4;
13820 char *salt_pos
= strchr (iter_pos
, '$');
13822 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13826 char *hash_pos
= strchr (salt_pos
, '$');
13828 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13830 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13834 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13835 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13836 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13837 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13838 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13839 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13840 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13841 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13843 uint salt_len
= hash_pos
- salt_pos
- 1;
13845 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13847 salt
->salt_len
= salt_len
/ 2;
13849 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13850 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13851 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13852 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13853 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13854 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13855 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13856 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13858 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13859 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13860 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13861 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13862 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13863 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13864 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13865 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13866 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13867 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13869 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13871 salt
->salt_iter
= atoi (iter_pos
) - 1;
13873 return (PARSER_OK
);
13876 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13878 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13880 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13882 u32
*digest
= (u32
*) hash_buf
->digest
;
13884 salt_t
*salt
= hash_buf
->salt
;
13886 char *salt_pos
= input_buf
+ 14;
13888 char *hash_pos
= strchr (salt_pos
, '*');
13890 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13894 uint salt_len
= hash_pos
- salt_pos
- 1;
13896 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13898 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13900 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13902 salt
->salt_len
= salt_len
;
13904 u8 tmp_buf
[100] = { 0 };
13906 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13908 memcpy (digest
, tmp_buf
, 32);
13910 digest
[0] = byte_swap_32 (digest
[0]);
13911 digest
[1] = byte_swap_32 (digest
[1]);
13912 digest
[2] = byte_swap_32 (digest
[2]);
13913 digest
[3] = byte_swap_32 (digest
[3]);
13914 digest
[4] = byte_swap_32 (digest
[4]);
13915 digest
[5] = byte_swap_32 (digest
[5]);
13916 digest
[6] = byte_swap_32 (digest
[6]);
13917 digest
[7] = byte_swap_32 (digest
[7]);
13919 digest
[0] -= SHA256M_A
;
13920 digest
[1] -= SHA256M_B
;
13921 digest
[2] -= SHA256M_C
;
13922 digest
[3] -= SHA256M_D
;
13923 digest
[4] -= SHA256M_E
;
13924 digest
[5] -= SHA256M_F
;
13925 digest
[6] -= SHA256M_G
;
13926 digest
[7] -= SHA256M_H
;
13928 return (PARSER_OK
);
13931 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13933 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13935 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13937 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13939 u64
*digest
= (u64
*) hash_buf
->digest
;
13941 salt_t
*salt
= hash_buf
->salt
;
13943 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13945 char *iter_pos
= input_buf
+ 19;
13947 char *salt_pos
= strchr (iter_pos
, '.');
13949 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13953 char *hash_pos
= strchr (salt_pos
, '.');
13955 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13957 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13961 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13962 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13963 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13964 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13965 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13966 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13967 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13968 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13970 uint salt_len
= hash_pos
- salt_pos
- 1;
13974 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13978 for (i
= 0; i
< salt_len
; i
++)
13980 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13983 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13984 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13986 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13988 salt
->salt_len
= salt_len
;
13990 salt
->salt_iter
= atoi (iter_pos
) - 1;
13992 return (PARSER_OK
);
13995 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13997 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13999 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
14001 u64
*digest
= (u64
*) hash_buf
->digest
;
14003 salt_t
*salt
= hash_buf
->salt
;
14005 u8 tmp_buf
[120] = { 0 };
14007 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
14009 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
14011 memcpy (digest
, tmp_buf
, 64);
14013 digest
[0] = byte_swap_64 (digest
[0]);
14014 digest
[1] = byte_swap_64 (digest
[1]);
14015 digest
[2] = byte_swap_64 (digest
[2]);
14016 digest
[3] = byte_swap_64 (digest
[3]);
14017 digest
[4] = byte_swap_64 (digest
[4]);
14018 digest
[5] = byte_swap_64 (digest
[5]);
14019 digest
[6] = byte_swap_64 (digest
[6]);
14020 digest
[7] = byte_swap_64 (digest
[7]);
14022 digest
[0] -= SHA512M_A
;
14023 digest
[1] -= SHA512M_B
;
14024 digest
[2] -= SHA512M_C
;
14025 digest
[3] -= SHA512M_D
;
14026 digest
[4] -= SHA512M_E
;
14027 digest
[5] -= SHA512M_F
;
14028 digest
[6] -= SHA512M_G
;
14029 digest
[7] -= SHA512M_H
;
14031 int salt_len
= tmp_len
- 64;
14033 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
14035 salt
->salt_len
= salt_len
;
14037 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
14039 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
14041 char *ptr
= (char *) salt
->salt_buf
;
14043 ptr
[salt
->salt_len
] = 0x80;
14046 return (PARSER_OK
);
14049 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14051 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14053 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
14057 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
14060 u32
*digest
= (u32
*) hash_buf
->digest
;
14062 salt_t
*salt
= hash_buf
->salt
;
14064 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14065 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14066 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14067 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14069 digest
[0] = byte_swap_32 (digest
[0]);
14070 digest
[1] = byte_swap_32 (digest
[1]);
14071 digest
[2] = byte_swap_32 (digest
[2]);
14072 digest
[3] = byte_swap_32 (digest
[3]);
14074 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14076 uint salt_len
= input_len
- 32 - 1;
14078 char *salt_buf
= input_buf
+ 32 + 1;
14080 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14082 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14084 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14086 salt
->salt_len
= salt_len
;
14088 return (PARSER_OK
);
14091 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14093 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14095 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
14099 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
14102 u32
*digest
= (u32
*) hash_buf
->digest
;
14104 salt_t
*salt
= hash_buf
->salt
;
14106 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14107 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14108 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14109 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14110 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14112 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14114 uint salt_len
= input_len
- 40 - 1;
14116 char *salt_buf
= input_buf
+ 40 + 1;
14118 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14120 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14122 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14124 salt
->salt_len
= salt_len
;
14126 return (PARSER_OK
);
14129 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14131 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14133 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14137 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14140 u32
*digest
= (u32
*) hash_buf
->digest
;
14142 salt_t
*salt
= hash_buf
->salt
;
14144 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14145 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14146 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14147 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14148 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14149 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14150 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14151 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14153 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14155 uint salt_len
= input_len
- 64 - 1;
14157 char *salt_buf
= input_buf
+ 64 + 1;
14159 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14161 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14163 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14165 salt
->salt_len
= salt_len
;
14167 return (PARSER_OK
);
14170 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14172 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14174 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14178 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14181 u64
*digest
= (u64
*) hash_buf
->digest
;
14183 salt_t
*salt
= hash_buf
->salt
;
14185 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14186 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14187 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14188 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14189 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14190 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14191 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14192 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14194 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14196 uint salt_len
= input_len
- 128 - 1;
14198 char *salt_buf
= input_buf
+ 128 + 1;
14200 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14202 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14204 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14206 salt
->salt_len
= salt_len
;
14208 return (PARSER_OK
);
14211 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14213 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14215 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14217 u32
*digest
= (u32
*) hash_buf
->digest
;
14219 salt_t
*salt
= hash_buf
->salt
;
14221 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14227 char *user_pos
= input_buf
+ 10 + 1;
14229 char *realm_pos
= strchr (user_pos
, '$');
14231 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14233 uint user_len
= realm_pos
- user_pos
;
14235 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14239 char *salt_pos
= strchr (realm_pos
, '$');
14241 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14243 uint realm_len
= salt_pos
- realm_pos
;
14245 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14249 char *data_pos
= strchr (salt_pos
, '$');
14251 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14253 uint salt_len
= data_pos
- salt_pos
;
14255 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14259 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14261 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14267 memcpy (krb5pa
->user
, user_pos
, user_len
);
14268 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14269 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14271 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14273 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14275 const char p0
= data_pos
[i
+ 0];
14276 const char p1
= data_pos
[i
+ 1];
14278 *timestamp_ptr
++ = hex_convert (p1
) << 0
14279 | hex_convert (p0
) << 4;
14282 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14284 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14286 const char p0
= data_pos
[i
+ 0];
14287 const char p1
= data_pos
[i
+ 1];
14289 *checksum_ptr
++ = hex_convert (p1
) << 0
14290 | hex_convert (p0
) << 4;
14294 * copy some data to generic buffers to make sorting happy
14297 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14298 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14299 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14300 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14301 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14302 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14303 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14304 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14305 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14307 salt
->salt_len
= 36;
14309 digest
[0] = krb5pa
->checksum
[0];
14310 digest
[1] = krb5pa
->checksum
[1];
14311 digest
[2] = krb5pa
->checksum
[2];
14312 digest
[3] = krb5pa
->checksum
[3];
14314 return (PARSER_OK
);
14317 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14319 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14321 u32
*digest
= (u32
*) hash_buf
->digest
;
14323 salt_t
*salt
= hash_buf
->salt
;
14329 char *salt_pos
= input_buf
;
14331 char *hash_pos
= strchr (salt_pos
, '$');
14333 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14335 uint salt_len
= hash_pos
- salt_pos
;
14337 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14341 uint hash_len
= input_len
- 1 - salt_len
;
14343 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14351 for (uint i
= 0; i
< salt_len
; i
++)
14353 if (salt_pos
[i
] == ' ') continue;
14358 // SAP user names cannot be longer than 12 characters
14359 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14361 // SAP user name cannot start with ! or ?
14362 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14368 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14370 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14372 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14374 salt
->salt_len
= salt_len
;
14376 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14377 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14381 digest
[0] = byte_swap_32 (digest
[0]);
14382 digest
[1] = byte_swap_32 (digest
[1]);
14384 return (PARSER_OK
);
14387 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14389 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14391 u32
*digest
= (u32
*) hash_buf
->digest
;
14393 salt_t
*salt
= hash_buf
->salt
;
14399 char *salt_pos
= input_buf
;
14401 char *hash_pos
= strchr (salt_pos
, '$');
14403 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14405 uint salt_len
= hash_pos
- salt_pos
;
14407 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14411 uint hash_len
= input_len
- 1 - salt_len
;
14413 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14421 for (uint i
= 0; i
< salt_len
; i
++)
14423 if (salt_pos
[i
] == ' ') continue;
14428 // SAP user names cannot be longer than 12 characters
14429 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14430 // so far nobody complained so we stay with this because it helps in optimization
14431 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14433 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14435 // SAP user name cannot start with ! or ?
14436 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14442 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14444 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14446 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14448 salt
->salt_len
= salt_len
;
14450 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14451 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14452 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14453 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14454 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14456 return (PARSER_OK
);
14459 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14461 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14463 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14465 u64
*digest
= (u64
*) hash_buf
->digest
;
14467 salt_t
*salt
= hash_buf
->salt
;
14469 char *iter_pos
= input_buf
+ 3;
14471 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14473 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14475 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14477 salt
->salt_iter
= salt_iter
;
14479 char *salt_pos
= iter_pos
+ 1;
14483 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14485 salt
->salt_len
= salt_len
;
14487 char *hash_pos
= salt_pos
+ salt_len
;
14489 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14493 char *tmp
= (char *) salt
->salt_buf_pc
;
14495 tmp
[0] = hash_pos
[42];
14499 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14500 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14501 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14502 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14508 return (PARSER_OK
);
14511 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14513 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14515 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14517 u32
*digest
= (u32
*) hash_buf
->digest
;
14519 salt_t
*salt
= hash_buf
->salt
;
14521 char *salt_buf
= input_buf
+ 6;
14523 uint salt_len
= 16;
14525 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14527 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14529 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14531 salt
->salt_len
= salt_len
;
14533 char *hash_pos
= input_buf
+ 6 + 16;
14535 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14536 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14537 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14538 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14539 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14540 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14541 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14542 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14544 return (PARSER_OK
);
14547 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14549 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14551 u32
*digest
= (u32
*) hash_buf
->digest
;
14553 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14554 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14558 return (PARSER_OK
);
14561 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14563 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14565 u32
*digest
= (u32
*) hash_buf
->digest
;
14567 salt_t
*salt
= hash_buf
->salt
;
14569 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14571 char *saltbuf_pos
= input_buf
;
14573 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14575 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14577 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14579 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14580 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14582 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14586 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14588 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14590 char *salt_ptr
= (char *) saltbuf_pos
;
14591 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14596 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14598 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14601 rakp_ptr
[j
] = 0x80;
14603 rakp
->salt_len
= j
;
14605 for (i
= 0; i
< 64; i
++)
14607 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14610 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14611 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14612 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14613 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14614 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14615 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14616 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14617 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14619 salt
->salt_len
= 32; // muss min. 32 haben
14621 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14622 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14623 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14624 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14625 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14627 return (PARSER_OK
);
14630 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14632 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14634 u32
*digest
= (u32
*) hash_buf
->digest
;
14636 salt_t
*salt
= hash_buf
->salt
;
14638 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14640 char *salt_pos
= input_buf
+ 1;
14642 memcpy (salt
->salt_buf
, salt_pos
, 8);
14644 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14645 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14647 salt
->salt_len
= 8;
14649 char *hash_pos
= salt_pos
+ 8;
14651 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14652 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14653 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14654 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14655 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14657 digest
[0] -= SHA1M_A
;
14658 digest
[1] -= SHA1M_B
;
14659 digest
[2] -= SHA1M_C
;
14660 digest
[3] -= SHA1M_D
;
14661 digest
[4] -= SHA1M_E
;
14663 return (PARSER_OK
);
14666 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14668 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14670 u32
*digest
= (u32
*) hash_buf
->digest
;
14672 salt_t
*salt
= hash_buf
->salt
;
14674 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14675 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14676 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14677 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14679 digest
[0] = byte_swap_32 (digest
[0]);
14680 digest
[1] = byte_swap_32 (digest
[1]);
14681 digest
[2] = byte_swap_32 (digest
[2]);
14682 digest
[3] = byte_swap_32 (digest
[3]);
14684 digest
[0] -= MD5M_A
;
14685 digest
[1] -= MD5M_B
;
14686 digest
[2] -= MD5M_C
;
14687 digest
[3] -= MD5M_D
;
14689 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14691 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14693 u32
*salt_buf
= salt
->salt_buf
;
14695 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14696 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14697 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14698 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14700 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14701 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14702 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14703 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14705 salt
->salt_len
= 16 + 1;
14707 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14709 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14711 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14713 return (PARSER_OK
);
14716 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14718 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14720 u32
*digest
= (u32
*) hash_buf
->digest
;
14722 salt_t
*salt
= hash_buf
->salt
;
14724 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14730 char *hashbuf_pos
= input_buf
;
14732 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14734 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14736 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14738 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14742 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14744 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14746 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14748 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14752 char *databuf_pos
= strchr (iteration_pos
, ':');
14754 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14756 const uint iteration_len
= databuf_pos
- iteration_pos
;
14758 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14759 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14761 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14763 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14764 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14770 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14771 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14772 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14773 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14774 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14775 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14776 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14777 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14781 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14783 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14785 const char p0
= saltbuf_pos
[i
+ 0];
14786 const char p1
= saltbuf_pos
[i
+ 1];
14788 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14789 | hex_convert (p0
) << 4;
14792 salt
->salt_buf
[4] = 0x01000000;
14793 salt
->salt_buf
[5] = 0x80;
14795 salt
->salt_len
= saltbuf_len
/ 2;
14799 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14803 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14805 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14807 const char p0
= databuf_pos
[i
+ 0];
14808 const char p1
= databuf_pos
[i
+ 1];
14810 *databuf_ptr
++ = hex_convert (p1
) << 0
14811 | hex_convert (p0
) << 4;
14814 *databuf_ptr
++ = 0x80;
14816 for (uint i
= 0; i
< 512; i
++)
14818 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14821 cloudkey
->data_len
= databuf_len
/ 2;
14823 return (PARSER_OK
);
14826 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14828 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14830 u32
*digest
= (u32
*) hash_buf
->digest
;
14832 salt_t
*salt
= hash_buf
->salt
;
14838 char *hashbuf_pos
= input_buf
;
14840 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14842 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14844 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14846 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14850 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14852 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14854 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14856 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14858 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14862 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14864 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14866 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14868 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14870 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14874 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14876 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14877 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14879 // ok, the plan for this algorithm is the following:
14880 // we have 2 salts here, the domain-name and a random salt
14881 // while both are used in the initial transformation,
14882 // only the random salt is used in the following iterations
14883 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14884 // and one that includes only the real salt (stored into salt_buf[]).
14885 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14887 u8 tmp_buf
[100] = { 0 };
14889 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14891 memcpy (digest
, tmp_buf
, 20);
14893 digest
[0] = byte_swap_32 (digest
[0]);
14894 digest
[1] = byte_swap_32 (digest
[1]);
14895 digest
[2] = byte_swap_32 (digest
[2]);
14896 digest
[3] = byte_swap_32 (digest
[3]);
14897 digest
[4] = byte_swap_32 (digest
[4]);
14901 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14903 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14905 char *len_ptr
= NULL
;
14907 for (uint i
= 0; i
< domainbuf_len
; i
++)
14909 if (salt_buf_pc_ptr
[i
] == '.')
14911 len_ptr
= &salt_buf_pc_ptr
[i
];
14921 salt
->salt_buf_pc
[7] = domainbuf_len
;
14925 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14927 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14929 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14931 salt
->salt_len
= salt_len
;
14935 salt
->salt_iter
= atoi (iteration_pos
);
14937 return (PARSER_OK
);
14940 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14942 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14944 u32
*digest
= (u32
*) hash_buf
->digest
;
14946 salt_t
*salt
= hash_buf
->salt
;
14948 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14949 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14950 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14951 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14952 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14954 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14956 uint salt_len
= input_len
- 40 - 1;
14958 char *salt_buf
= input_buf
+ 40 + 1;
14960 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14962 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14964 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14966 salt
->salt_len
= salt_len
;
14968 return (PARSER_OK
);
14971 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14973 const u8 ascii_to_ebcdic
[] =
14975 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14976 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14977 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14978 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14979 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14980 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14981 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14982 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14983 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14984 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14985 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14986 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14987 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14988 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14989 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14990 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14993 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14995 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14997 u32
*digest
= (u32
*) hash_buf
->digest
;
14999 salt_t
*salt
= hash_buf
->salt
;
15001 char *salt_pos
= input_buf
+ 6 + 1;
15003 char *digest_pos
= strchr (salt_pos
, '*');
15005 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15007 uint salt_len
= digest_pos
- salt_pos
;
15009 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
15011 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
15013 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
15017 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15018 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
15020 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
15022 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15024 salt
->salt_len
= salt_len
;
15026 for (uint i
= 0; i
< salt_len
; i
++)
15028 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
15030 for (uint i
= salt_len
; i
< 8; i
++)
15032 salt_buf_pc_ptr
[i
] = 0x40;
15037 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
15039 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
15040 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
15042 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
15043 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
15045 digest
[0] = byte_swap_32 (digest
[0]);
15046 digest
[1] = byte_swap_32 (digest
[1]);
15048 IP (digest
[0], digest
[1], tt
);
15050 digest
[0] = rotr32 (digest
[0], 29);
15051 digest
[1] = rotr32 (digest
[1], 29);
15055 return (PARSER_OK
);
15058 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15060 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
15062 u32
*digest
= (u32
*) hash_buf
->digest
;
15064 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15065 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15066 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15067 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15069 digest
[0] = byte_swap_32 (digest
[0]);
15070 digest
[1] = byte_swap_32 (digest
[1]);
15071 digest
[2] = byte_swap_32 (digest
[2]);
15072 digest
[3] = byte_swap_32 (digest
[3]);
15074 return (PARSER_OK
);
15077 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15079 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
15081 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15083 u32
*digest
= (u32
*) hash_buf
->digest
;
15085 salt_t
*salt
= hash_buf
->salt
;
15087 u8 tmp_buf
[120] = { 0 };
15089 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15091 tmp_buf
[3] += -4; // dont ask!
15093 memcpy (salt
->salt_buf
, tmp_buf
, 5);
15095 salt
->salt_len
= 5;
15097 memcpy (digest
, tmp_buf
+ 5, 9);
15099 // yes, only 9 byte are needed to crack, but 10 to display
15101 salt
->salt_buf_pc
[7] = input_buf
[20];
15103 return (PARSER_OK
);
15106 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15108 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
15110 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15112 u32
*digest
= (u32
*) hash_buf
->digest
;
15114 salt_t
*salt
= hash_buf
->salt
;
15116 u8 tmp_buf
[120] = { 0 };
15118 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15120 tmp_buf
[3] += -4; // dont ask!
15124 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15126 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)
15130 char tmp_iter_buf
[11] = { 0 };
15132 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15134 tmp_iter_buf
[10] = 0;
15136 salt
->salt_iter
= atoi (tmp_iter_buf
);
15138 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15140 return (PARSER_SALT_ITERATION
);
15143 salt
->salt_iter
--; // first round in init
15145 // 2 additional bytes for display only
15147 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15148 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15152 memcpy (digest
, tmp_buf
+ 28, 8);
15154 digest
[0] = byte_swap_32 (digest
[0]);
15155 digest
[1] = byte_swap_32 (digest
[1]);
15159 return (PARSER_OK
);
15162 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15164 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15166 u32
*digest
= (u32
*) hash_buf
->digest
;
15168 salt_t
*salt
= hash_buf
->salt
;
15170 char *salt_buf_pos
= input_buf
;
15172 char *hash_buf_pos
= salt_buf_pos
+ 6;
15174 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15175 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15176 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15177 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15178 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15179 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15180 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15181 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15183 digest
[0] -= SHA256M_A
;
15184 digest
[1] -= SHA256M_B
;
15185 digest
[2] -= SHA256M_C
;
15186 digest
[3] -= SHA256M_D
;
15187 digest
[4] -= SHA256M_E
;
15188 digest
[5] -= SHA256M_F
;
15189 digest
[6] -= SHA256M_G
;
15190 digest
[7] -= SHA256M_H
;
15192 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15194 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15196 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15198 salt
->salt_len
= salt_len
;
15200 return (PARSER_OK
);
15203 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15205 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15207 u32
*digest
= (u32
*) hash_buf
->digest
;
15209 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15211 salt_t
*salt
= hash_buf
->salt
;
15213 char *salt_buf
= input_buf
+ 6;
15215 char *digest_buf
= strchr (salt_buf
, '$');
15217 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15219 uint salt_len
= digest_buf
- salt_buf
;
15221 digest_buf
++; // skip the '$' symbol
15223 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15225 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15227 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15229 salt
->salt_len
= salt_len
;
15231 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15232 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15233 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15234 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15236 digest
[0] = byte_swap_32 (digest
[0]);
15237 digest
[1] = byte_swap_32 (digest
[1]);
15238 digest
[2] = byte_swap_32 (digest
[2]);
15239 digest
[3] = byte_swap_32 (digest
[3]);
15241 digest
[0] -= MD5M_A
;
15242 digest
[1] -= MD5M_B
;
15243 digest
[2] -= MD5M_C
;
15244 digest
[3] -= MD5M_D
;
15246 return (PARSER_OK
);
15249 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15251 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15253 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15255 u32
*digest
= (u32
*) hash_buf
->digest
;
15257 salt_t
*salt
= hash_buf
->salt
;
15259 char *salt_buf
= input_buf
+ 3;
15261 char *digest_buf
= strchr (salt_buf
, '$');
15263 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15265 uint salt_len
= digest_buf
- salt_buf
;
15267 digest_buf
++; // skip the '$' symbol
15269 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15271 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15273 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15275 salt_buf_ptr
[salt_len
] = 0x2d;
15277 salt
->salt_len
= salt_len
+ 1;
15279 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15280 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15281 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15282 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15284 digest
[0] = byte_swap_32 (digest
[0]);
15285 digest
[1] = byte_swap_32 (digest
[1]);
15286 digest
[2] = byte_swap_32 (digest
[2]);
15287 digest
[3] = byte_swap_32 (digest
[3]);
15289 digest
[0] -= MD5M_A
;
15290 digest
[1] -= MD5M_B
;
15291 digest
[2] -= MD5M_C
;
15292 digest
[3] -= MD5M_D
;
15294 return (PARSER_OK
);
15297 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15299 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15301 u32
*digest
= (u32
*) hash_buf
->digest
;
15303 salt_t
*salt
= hash_buf
->salt
;
15305 u8 tmp_buf
[100] = { 0 };
15307 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15309 memcpy (digest
, tmp_buf
, 20);
15311 digest
[0] = byte_swap_32 (digest
[0]);
15312 digest
[1] = byte_swap_32 (digest
[1]);
15313 digest
[2] = byte_swap_32 (digest
[2]);
15314 digest
[3] = byte_swap_32 (digest
[3]);
15315 digest
[4] = byte_swap_32 (digest
[4]);
15317 digest
[0] -= SHA1M_A
;
15318 digest
[1] -= SHA1M_B
;
15319 digest
[2] -= SHA1M_C
;
15320 digest
[3] -= SHA1M_D
;
15321 digest
[4] -= SHA1M_E
;
15323 salt
->salt_buf
[0] = 0x80;
15325 salt
->salt_len
= 0;
15327 return (PARSER_OK
);
15330 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15332 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15334 u32
*digest
= (u32
*) hash_buf
->digest
;
15336 salt_t
*salt
= hash_buf
->salt
;
15338 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15339 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15340 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15341 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15343 digest
[0] = byte_swap_32 (digest
[0]);
15344 digest
[1] = byte_swap_32 (digest
[1]);
15345 digest
[2] = byte_swap_32 (digest
[2]);
15346 digest
[3] = byte_swap_32 (digest
[3]);
15348 digest
[0] -= MD5M_A
;
15349 digest
[1] -= MD5M_B
;
15350 digest
[2] -= MD5M_C
;
15351 digest
[3] -= MD5M_D
;
15353 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15355 uint salt_len
= input_len
- 32 - 1;
15357 char *salt_buf
= input_buf
+ 32 + 1;
15359 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15361 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15363 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15366 * add static "salt" part
15369 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15373 salt
->salt_len
= salt_len
;
15375 return (PARSER_OK
);
15378 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15380 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15382 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15384 u32
*digest
= (u32
*) hash_buf
->digest
;
15386 salt_t
*salt
= hash_buf
->salt
;
15388 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15394 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15396 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15398 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15400 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15402 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15406 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15408 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15410 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15412 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15416 char *keybuf_pos
= strchr (keylen_pos
, '$');
15418 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15420 uint keylen_len
= keybuf_pos
- keylen_pos
;
15422 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15426 char *databuf_pos
= strchr (keybuf_pos
, '$');
15428 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15430 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15432 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15436 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15438 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15444 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15445 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15446 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15447 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15449 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15450 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15451 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15452 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15454 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15455 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15456 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15457 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15459 salt
->salt_len
= 16;
15460 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15462 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15464 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15467 return (PARSER_OK
);
15470 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15472 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15474 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15476 u32
*digest
= (u32
*) hash_buf
->digest
;
15478 salt_t
*salt
= hash_buf
->salt
;
15484 // first is the N salt parameter
15486 char *N_pos
= input_buf
+ 6;
15488 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15492 salt
->scrypt_N
= atoi (N_pos
);
15496 char *r_pos
= strchr (N_pos
, ':');
15498 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15502 salt
->scrypt_r
= atoi (r_pos
);
15506 char *p_pos
= strchr (r_pos
, ':');
15508 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15512 salt
->scrypt_p
= atoi (p_pos
);
15516 char *saltbuf_pos
= strchr (p_pos
, ':');
15518 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15522 char *hash_pos
= strchr (saltbuf_pos
, ':');
15524 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15530 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15532 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15534 u8 tmp_buf
[33] = { 0 };
15536 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15538 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15540 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15542 salt
->salt_len
= tmp_len
;
15543 salt
->salt_iter
= 1;
15545 // digest - base64 decode
15547 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15549 tmp_len
= input_len
- (hash_pos
- input_buf
);
15551 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15553 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15555 memcpy (digest
, tmp_buf
, 32);
15557 return (PARSER_OK
);
15560 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15562 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15564 u32
*digest
= (u32
*) hash_buf
->digest
;
15566 salt_t
*salt
= hash_buf
->salt
;
15572 char decrypted
[76] = { 0 }; // iv + hash
15574 juniper_decrypt_hash (input_buf
, decrypted
);
15576 char *md5crypt_hash
= decrypted
+ 12;
15578 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15580 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15582 char *salt_pos
= md5crypt_hash
+ 3;
15584 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15586 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15588 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15592 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15594 return (PARSER_OK
);
15597 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15599 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15601 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15603 u32
*digest
= (u32
*) hash_buf
->digest
;
15605 salt_t
*salt
= hash_buf
->salt
;
15607 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15613 // first is *raw* salt
15615 char *salt_pos
= input_buf
+ 3;
15617 char *hash_pos
= strchr (salt_pos
, '$');
15619 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15621 uint salt_len
= hash_pos
- salt_pos
;
15623 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15627 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15629 memcpy (salt_buf_ptr
, salt_pos
, 14);
15631 salt_buf_ptr
[17] = 0x01;
15632 salt_buf_ptr
[18] = 0x80;
15634 // add some stuff to normal salt to make sorted happy
15636 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15637 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15638 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15639 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15641 salt
->salt_len
= salt_len
;
15642 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15644 // base64 decode hash
15646 u8 tmp_buf
[100] = { 0 };
15648 uint hash_len
= input_len
- 3 - salt_len
- 1;
15650 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15652 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15654 memcpy (digest
, tmp_buf
, 32);
15656 digest
[0] = byte_swap_32 (digest
[0]);
15657 digest
[1] = byte_swap_32 (digest
[1]);
15658 digest
[2] = byte_swap_32 (digest
[2]);
15659 digest
[3] = byte_swap_32 (digest
[3]);
15660 digest
[4] = byte_swap_32 (digest
[4]);
15661 digest
[5] = byte_swap_32 (digest
[5]);
15662 digest
[6] = byte_swap_32 (digest
[6]);
15663 digest
[7] = byte_swap_32 (digest
[7]);
15665 return (PARSER_OK
);
15668 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15670 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15672 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15674 u32
*digest
= (u32
*) hash_buf
->digest
;
15676 salt_t
*salt
= hash_buf
->salt
;
15682 // first is *raw* salt
15684 char *salt_pos
= input_buf
+ 3;
15686 char *hash_pos
= strchr (salt_pos
, '$');
15688 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15690 uint salt_len
= hash_pos
- salt_pos
;
15692 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15694 salt
->salt_len
= salt_len
;
15697 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15699 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15700 salt_buf_ptr
[salt_len
] = 0;
15702 // base64 decode hash
15704 u8 tmp_buf
[100] = { 0 };
15706 uint hash_len
= input_len
- 3 - salt_len
- 1;
15708 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15710 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15712 memcpy (digest
, tmp_buf
, 32);
15715 salt
->scrypt_N
= 16384;
15716 salt
->scrypt_r
= 1;
15717 salt
->scrypt_p
= 1;
15718 salt
->salt_iter
= 1;
15720 return (PARSER_OK
);
15723 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15725 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15727 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15729 u32
*digest
= (u32
*) hash_buf
->digest
;
15731 salt_t
*salt
= hash_buf
->salt
;
15733 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15739 char *version_pos
= input_buf
+ 8 + 1;
15741 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15743 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15745 u32 version_len
= verifierHashSize_pos
- version_pos
;
15747 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15749 verifierHashSize_pos
++;
15751 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15753 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15755 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15757 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15761 char *saltSize_pos
= strchr (keySize_pos
, '*');
15763 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15765 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15767 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15771 char *osalt_pos
= strchr (saltSize_pos
, '*');
15773 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15775 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15777 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15781 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15783 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15785 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15787 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15789 encryptedVerifier_pos
++;
15791 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15793 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15795 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15797 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15799 encryptedVerifierHash_pos
++;
15801 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;
15803 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15805 const uint version
= atoi (version_pos
);
15807 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15809 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15811 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15813 const uint keySize
= atoi (keySize_pos
);
15815 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15817 office2007
->keySize
= keySize
;
15819 const uint saltSize
= atoi (saltSize_pos
);
15821 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15827 salt
->salt_len
= 16;
15828 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15830 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15831 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15832 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15833 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15839 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15840 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15841 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15842 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15844 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15845 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15846 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15847 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15848 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15854 digest
[0] = office2007
->encryptedVerifierHash
[0];
15855 digest
[1] = office2007
->encryptedVerifierHash
[1];
15856 digest
[2] = office2007
->encryptedVerifierHash
[2];
15857 digest
[3] = office2007
->encryptedVerifierHash
[3];
15859 return (PARSER_OK
);
15862 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15864 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15866 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15868 u32
*digest
= (u32
*) hash_buf
->digest
;
15870 salt_t
*salt
= hash_buf
->salt
;
15872 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15878 char *version_pos
= input_buf
+ 8 + 1;
15880 char *spinCount_pos
= strchr (version_pos
, '*');
15882 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15884 u32 version_len
= spinCount_pos
- version_pos
;
15886 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15890 char *keySize_pos
= strchr (spinCount_pos
, '*');
15892 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15894 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15896 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15900 char *saltSize_pos
= strchr (keySize_pos
, '*');
15902 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15904 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15906 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15910 char *osalt_pos
= strchr (saltSize_pos
, '*');
15912 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15914 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15916 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15920 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15922 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15924 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15926 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15928 encryptedVerifier_pos
++;
15930 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15932 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15934 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15936 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15938 encryptedVerifierHash_pos
++;
15940 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;
15942 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15944 const uint version
= atoi (version_pos
);
15946 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15948 const uint spinCount
= atoi (spinCount_pos
);
15950 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15952 const uint keySize
= atoi (keySize_pos
);
15954 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15956 const uint saltSize
= atoi (saltSize_pos
);
15958 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15964 salt
->salt_len
= 16;
15965 salt
->salt_iter
= spinCount
;
15967 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15968 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15969 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15970 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15976 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15977 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15978 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15979 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15981 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15982 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15983 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15984 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15985 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15986 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15987 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15988 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15994 digest
[0] = office2010
->encryptedVerifierHash
[0];
15995 digest
[1] = office2010
->encryptedVerifierHash
[1];
15996 digest
[2] = office2010
->encryptedVerifierHash
[2];
15997 digest
[3] = office2010
->encryptedVerifierHash
[3];
15999 return (PARSER_OK
);
16002 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16004 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
16006 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
16008 u32
*digest
= (u32
*) hash_buf
->digest
;
16010 salt_t
*salt
= hash_buf
->salt
;
16012 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
16018 char *version_pos
= input_buf
+ 8 + 1;
16020 char *spinCount_pos
= strchr (version_pos
, '*');
16022 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16024 u32 version_len
= spinCount_pos
- version_pos
;
16026 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
16030 char *keySize_pos
= strchr (spinCount_pos
, '*');
16032 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16034 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
16036 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
16040 char *saltSize_pos
= strchr (keySize_pos
, '*');
16042 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16044 u32 keySize_len
= saltSize_pos
- keySize_pos
;
16046 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
16050 char *osalt_pos
= strchr (saltSize_pos
, '*');
16052 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16054 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
16056 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
16060 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16062 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16064 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16066 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16068 encryptedVerifier_pos
++;
16070 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16072 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16074 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16076 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16078 encryptedVerifierHash_pos
++;
16080 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;
16082 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
16084 const uint version
= atoi (version_pos
);
16086 if (version
!= 2013) return (PARSER_SALT_VALUE
);
16088 const uint spinCount
= atoi (spinCount_pos
);
16090 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
16092 const uint keySize
= atoi (keySize_pos
);
16094 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
16096 const uint saltSize
= atoi (saltSize_pos
);
16098 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
16104 salt
->salt_len
= 16;
16105 salt
->salt_iter
= spinCount
;
16107 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16108 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16109 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16110 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16116 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16117 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16118 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16119 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16121 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16122 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16123 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16124 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16125 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16126 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16127 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16128 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16134 digest
[0] = office2013
->encryptedVerifierHash
[0];
16135 digest
[1] = office2013
->encryptedVerifierHash
[1];
16136 digest
[2] = office2013
->encryptedVerifierHash
[2];
16137 digest
[3] = office2013
->encryptedVerifierHash
[3];
16139 return (PARSER_OK
);
16142 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16144 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16146 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16148 u32
*digest
= (u32
*) hash_buf
->digest
;
16150 salt_t
*salt
= hash_buf
->salt
;
16152 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16158 char *version_pos
= input_buf
+ 11;
16160 char *osalt_pos
= strchr (version_pos
, '*');
16162 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16164 u32 version_len
= osalt_pos
- version_pos
;
16166 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16170 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16172 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16174 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16176 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16178 encryptedVerifier_pos
++;
16180 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16182 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16184 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16186 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16188 encryptedVerifierHash_pos
++;
16190 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16192 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16194 const uint version
= *version_pos
- 0x30;
16196 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16202 oldoffice01
->version
= version
;
16204 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16205 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16206 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16207 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16209 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16210 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16211 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16212 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16214 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16215 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16216 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16217 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16219 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16220 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16221 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16222 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16228 salt
->salt_len
= 16;
16230 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16231 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16232 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16233 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16235 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16236 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16237 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16238 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16240 // this is a workaround as office produces multiple documents with the same salt
16242 salt
->salt_len
+= 32;
16244 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16245 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16246 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16247 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16248 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16249 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16250 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16251 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16257 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16258 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16259 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16260 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16262 return (PARSER_OK
);
16265 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16267 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16270 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16272 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16274 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16276 u32
*digest
= (u32
*) hash_buf
->digest
;
16278 salt_t
*salt
= hash_buf
->salt
;
16280 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16286 char *version_pos
= input_buf
+ 11;
16288 char *osalt_pos
= strchr (version_pos
, '*');
16290 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16292 u32 version_len
= osalt_pos
- version_pos
;
16294 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16298 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16300 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16302 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16304 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16306 encryptedVerifier_pos
++;
16308 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16310 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16312 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16314 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16316 encryptedVerifierHash_pos
++;
16318 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16320 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16322 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16324 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16328 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16330 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16332 const uint version
= *version_pos
- 0x30;
16334 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16340 oldoffice01
->version
= version
;
16342 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16343 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16344 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16345 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16347 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16348 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16349 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16350 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16352 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16353 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16354 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16355 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16357 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16358 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16359 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16360 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16362 oldoffice01
->rc4key
[1] = 0;
16363 oldoffice01
->rc4key
[0] = 0;
16365 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16366 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16367 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16368 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16369 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16370 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16371 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16372 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16373 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16374 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16376 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16377 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16383 salt
->salt_len
= 16;
16385 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16386 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16387 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16388 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16390 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16391 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16392 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16393 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16395 // this is a workaround as office produces multiple documents with the same salt
16397 salt
->salt_len
+= 32;
16399 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16400 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16401 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16402 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16403 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16404 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16405 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16406 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16412 digest
[0] = oldoffice01
->rc4key
[0];
16413 digest
[1] = oldoffice01
->rc4key
[1];
16417 return (PARSER_OK
);
16420 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16422 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16424 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16426 u32
*digest
= (u32
*) hash_buf
->digest
;
16428 salt_t
*salt
= hash_buf
->salt
;
16430 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16436 char *version_pos
= input_buf
+ 11;
16438 char *osalt_pos
= strchr (version_pos
, '*');
16440 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16442 u32 version_len
= osalt_pos
- version_pos
;
16444 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16448 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16450 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16452 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16454 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16456 encryptedVerifier_pos
++;
16458 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16460 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16462 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16464 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16466 encryptedVerifierHash_pos
++;
16468 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16470 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16472 const uint version
= *version_pos
- 0x30;
16474 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16480 oldoffice34
->version
= version
;
16482 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16483 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16484 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16485 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16487 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16488 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16489 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16490 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16492 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16493 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16494 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16495 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16496 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16498 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16499 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16500 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16501 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16502 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16508 salt
->salt_len
= 16;
16510 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16511 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16512 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16513 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16515 // this is a workaround as office produces multiple documents with the same salt
16517 salt
->salt_len
+= 32;
16519 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16520 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16521 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16522 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16523 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16524 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16525 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16526 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16532 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16533 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16534 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16535 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16537 return (PARSER_OK
);
16540 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16542 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16544 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16547 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16549 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16551 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16553 u32
*digest
= (u32
*) hash_buf
->digest
;
16555 salt_t
*salt
= hash_buf
->salt
;
16557 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16563 char *version_pos
= input_buf
+ 11;
16565 char *osalt_pos
= strchr (version_pos
, '*');
16567 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16569 u32 version_len
= osalt_pos
- version_pos
;
16571 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16575 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16577 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16579 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16581 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16583 encryptedVerifier_pos
++;
16585 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16587 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16589 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16591 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16593 encryptedVerifierHash_pos
++;
16595 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16597 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16599 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16601 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16605 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16607 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16609 const uint version
= *version_pos
- 0x30;
16611 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16617 oldoffice34
->version
= version
;
16619 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16620 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16621 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16622 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16624 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16625 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16626 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16627 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16629 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16630 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16631 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16632 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16633 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16635 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16636 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16637 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16638 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16639 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16641 oldoffice34
->rc4key
[1] = 0;
16642 oldoffice34
->rc4key
[0] = 0;
16644 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16645 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16646 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16647 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16648 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16649 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16650 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16651 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16652 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16653 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16655 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16656 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16662 salt
->salt_len
= 16;
16664 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16665 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16666 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16667 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16669 // this is a workaround as office produces multiple documents with the same salt
16671 salt
->salt_len
+= 32;
16673 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16674 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16675 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16676 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16677 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16678 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16679 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16680 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16686 digest
[0] = oldoffice34
->rc4key
[0];
16687 digest
[1] = oldoffice34
->rc4key
[1];
16691 return (PARSER_OK
);
16694 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16696 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16698 u32
*digest
= (u32
*) hash_buf
->digest
;
16700 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16701 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16702 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16703 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16705 digest
[0] = byte_swap_32 (digest
[0]);
16706 digest
[1] = byte_swap_32 (digest
[1]);
16707 digest
[2] = byte_swap_32 (digest
[2]);
16708 digest
[3] = byte_swap_32 (digest
[3]);
16710 return (PARSER_OK
);
16713 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16715 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16717 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16719 u32
*digest
= (u32
*) hash_buf
->digest
;
16721 salt_t
*salt
= hash_buf
->salt
;
16723 char *signature_pos
= input_buf
;
16725 char *salt_pos
= strchr (signature_pos
, '$');
16727 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16729 u32 signature_len
= salt_pos
- signature_pos
;
16731 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16735 char *hash_pos
= strchr (salt_pos
, '$');
16737 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16739 u32 salt_len
= hash_pos
- salt_pos
;
16741 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16745 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16747 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16749 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16750 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16751 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16752 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16753 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16755 digest
[0] -= SHA1M_A
;
16756 digest
[1] -= SHA1M_B
;
16757 digest
[2] -= SHA1M_C
;
16758 digest
[3] -= SHA1M_D
;
16759 digest
[4] -= SHA1M_E
;
16761 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16763 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16765 salt
->salt_len
= salt_len
;
16767 return (PARSER_OK
);
16770 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16772 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16774 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16776 u32
*digest
= (u32
*) hash_buf
->digest
;
16778 salt_t
*salt
= hash_buf
->salt
;
16780 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16786 char *iter_pos
= input_buf
+ 14;
16788 const int iter
= atoi (iter_pos
);
16790 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16792 salt
->salt_iter
= iter
- 1;
16794 char *salt_pos
= strchr (iter_pos
, '$');
16796 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16800 char *hash_pos
= strchr (salt_pos
, '$');
16802 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16804 const uint salt_len
= hash_pos
- salt_pos
;
16808 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16810 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16812 salt
->salt_len
= salt_len
;
16814 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16815 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16817 // add some stuff to normal salt to make sorted happy
16819 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16820 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16821 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16822 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16823 salt
->salt_buf
[4] = salt
->salt_iter
;
16825 // base64 decode hash
16827 u8 tmp_buf
[100] = { 0 };
16829 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16831 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16833 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16835 memcpy (digest
, tmp_buf
, 32);
16837 digest
[0] = byte_swap_32 (digest
[0]);
16838 digest
[1] = byte_swap_32 (digest
[1]);
16839 digest
[2] = byte_swap_32 (digest
[2]);
16840 digest
[3] = byte_swap_32 (digest
[3]);
16841 digest
[4] = byte_swap_32 (digest
[4]);
16842 digest
[5] = byte_swap_32 (digest
[5]);
16843 digest
[6] = byte_swap_32 (digest
[6]);
16844 digest
[7] = byte_swap_32 (digest
[7]);
16846 return (PARSER_OK
);
16849 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16851 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16853 u32
*digest
= (u32
*) hash_buf
->digest
;
16855 salt_t
*salt
= hash_buf
->salt
;
16857 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16858 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16862 digest
[0] = byte_swap_32 (digest
[0]);
16863 digest
[1] = byte_swap_32 (digest
[1]);
16865 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16866 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16867 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16869 char iter_c
= input_buf
[17];
16870 char iter_d
= input_buf
[19];
16872 // atm only defaults, let's see if there's more request
16873 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16874 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16876 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16878 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16879 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16880 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16881 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16883 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16884 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16885 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16886 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16888 salt
->salt_len
= 16;
16890 return (PARSER_OK
);
16893 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16895 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16897 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16899 u32
*digest
= (u32
*) hash_buf
->digest
;
16901 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16903 salt_t
*salt
= hash_buf
->salt
;
16905 char *salt_pos
= input_buf
+ 10;
16907 char *hash_pos
= strchr (salt_pos
, '$');
16909 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16911 uint salt_len
= hash_pos
- salt_pos
;
16915 uint hash_len
= input_len
- 10 - salt_len
- 1;
16917 // base64 decode salt
16919 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16921 u8 tmp_buf
[100] = { 0 };
16923 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16925 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16927 tmp_buf
[salt_len
] = 0x80;
16929 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16931 salt
->salt_len
= salt_len
;
16933 // base64 decode hash
16935 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16937 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16939 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16941 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16943 uint user_len
= hash_len
- 32;
16945 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16947 user_len
--; // skip the trailing space
16949 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16950 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16951 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16952 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16954 digest
[0] = byte_swap_32 (digest
[0]);
16955 digest
[1] = byte_swap_32 (digest
[1]);
16956 digest
[2] = byte_swap_32 (digest
[2]);
16957 digest
[3] = byte_swap_32 (digest
[3]);
16959 // store username for host only (output hash if cracked)
16961 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16962 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16964 return (PARSER_OK
);
16967 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16969 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16971 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16973 u32
*digest
= (u32
*) hash_buf
->digest
;
16975 salt_t
*salt
= hash_buf
->salt
;
16977 char *iter_pos
= input_buf
+ 10;
16979 u32 iter
= atoi (iter_pos
);
16983 return (PARSER_SALT_ITERATION
);
16986 iter
--; // first iteration is special
16988 salt
->salt_iter
= iter
;
16990 char *base64_pos
= strchr (iter_pos
, '}');
16992 if (base64_pos
== NULL
)
16994 return (PARSER_SIGNATURE_UNMATCHED
);
16999 // base64 decode salt
17001 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
17003 u8 tmp_buf
[100] = { 0 };
17005 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
17007 if (decoded_len
< 24)
17009 return (PARSER_SALT_LENGTH
);
17014 uint salt_len
= decoded_len
- 20;
17016 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
17017 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
17019 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
17021 salt
->salt_len
= salt_len
;
17025 u32
*digest_ptr
= (u32
*) tmp_buf
;
17027 digest
[0] = byte_swap_32 (digest_ptr
[0]);
17028 digest
[1] = byte_swap_32 (digest_ptr
[1]);
17029 digest
[2] = byte_swap_32 (digest_ptr
[2]);
17030 digest
[3] = byte_swap_32 (digest_ptr
[3]);
17031 digest
[4] = byte_swap_32 (digest_ptr
[4]);
17033 return (PARSER_OK
);
17036 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17038 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
17040 u32
*digest
= (u32
*) hash_buf
->digest
;
17042 salt_t
*salt
= hash_buf
->salt
;
17044 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17045 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17046 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17047 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17048 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
17050 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17052 uint salt_len
= input_len
- 40 - 1;
17054 char *salt_buf
= input_buf
+ 40 + 1;
17056 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17058 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17060 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
17062 salt
->salt_len
= salt_len
;
17064 return (PARSER_OK
);
17067 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17069 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
17071 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17073 u32
*digest
= (u32
*) hash_buf
->digest
;
17075 salt_t
*salt
= hash_buf
->salt
;
17077 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17083 char *V_pos
= input_buf
+ 5;
17085 char *R_pos
= strchr (V_pos
, '*');
17087 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17089 u32 V_len
= R_pos
- V_pos
;
17093 char *bits_pos
= strchr (R_pos
, '*');
17095 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17097 u32 R_len
= bits_pos
- R_pos
;
17101 char *P_pos
= strchr (bits_pos
, '*');
17103 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17105 u32 bits_len
= P_pos
- bits_pos
;
17109 char *enc_md_pos
= strchr (P_pos
, '*');
17111 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17113 u32 P_len
= enc_md_pos
- P_pos
;
17117 char *id_len_pos
= strchr (enc_md_pos
, '*');
17119 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17121 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17125 char *id_buf_pos
= strchr (id_len_pos
, '*');
17127 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17129 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17133 char *u_len_pos
= strchr (id_buf_pos
, '*');
17135 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17137 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17139 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17143 char *u_buf_pos
= strchr (u_len_pos
, '*');
17145 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17147 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17151 char *o_len_pos
= strchr (u_buf_pos
, '*');
17153 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17155 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17157 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17161 char *o_buf_pos
= strchr (o_len_pos
, '*');
17163 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17165 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17169 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;
17171 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17175 const int V
= atoi (V_pos
);
17176 const int R
= atoi (R_pos
);
17177 const int P
= atoi (P_pos
);
17179 if (V
!= 1) return (PARSER_SALT_VALUE
);
17180 if (R
!= 2) return (PARSER_SALT_VALUE
);
17182 const int enc_md
= atoi (enc_md_pos
);
17184 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17186 const int id_len
= atoi (id_len_pos
);
17187 const int u_len
= atoi (u_len_pos
);
17188 const int o_len
= atoi (o_len_pos
);
17190 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17191 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17192 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17194 const int bits
= atoi (bits_pos
);
17196 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17198 // copy data to esalt
17204 pdf
->enc_md
= enc_md
;
17206 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17207 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17208 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17209 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17210 pdf
->id_len
= id_len
;
17212 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17213 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17214 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17215 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17216 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17217 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17218 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17219 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17220 pdf
->u_len
= u_len
;
17222 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17223 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17224 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17225 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17226 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17227 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17228 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17229 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17230 pdf
->o_len
= o_len
;
17232 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17233 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17234 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17235 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17237 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17238 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17239 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17240 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17241 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17242 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17243 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17244 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17246 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17247 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17248 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17249 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17250 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17251 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17252 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17253 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17255 // we use ID for salt, maybe needs to change, we will see...
17257 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17258 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17259 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17260 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17261 salt
->salt_len
= pdf
->id_len
;
17263 digest
[0] = pdf
->u_buf
[0];
17264 digest
[1] = pdf
->u_buf
[1];
17265 digest
[2] = pdf
->u_buf
[2];
17266 digest
[3] = pdf
->u_buf
[3];
17268 return (PARSER_OK
);
17271 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17273 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17276 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17278 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17280 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17282 u32
*digest
= (u32
*) hash_buf
->digest
;
17284 salt_t
*salt
= hash_buf
->salt
;
17286 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17292 char *V_pos
= input_buf
+ 5;
17294 char *R_pos
= strchr (V_pos
, '*');
17296 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17298 u32 V_len
= R_pos
- V_pos
;
17302 char *bits_pos
= strchr (R_pos
, '*');
17304 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17306 u32 R_len
= bits_pos
- R_pos
;
17310 char *P_pos
= strchr (bits_pos
, '*');
17312 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17314 u32 bits_len
= P_pos
- bits_pos
;
17318 char *enc_md_pos
= strchr (P_pos
, '*');
17320 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17322 u32 P_len
= enc_md_pos
- P_pos
;
17326 char *id_len_pos
= strchr (enc_md_pos
, '*');
17328 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17330 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17334 char *id_buf_pos
= strchr (id_len_pos
, '*');
17336 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17338 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17342 char *u_len_pos
= strchr (id_buf_pos
, '*');
17344 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17346 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17348 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17352 char *u_buf_pos
= strchr (u_len_pos
, '*');
17354 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17356 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17360 char *o_len_pos
= strchr (u_buf_pos
, '*');
17362 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17364 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17366 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17370 char *o_buf_pos
= strchr (o_len_pos
, '*');
17372 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17374 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17378 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17380 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17382 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17384 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17388 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;
17390 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17394 const int V
= atoi (V_pos
);
17395 const int R
= atoi (R_pos
);
17396 const int P
= atoi (P_pos
);
17398 if (V
!= 1) return (PARSER_SALT_VALUE
);
17399 if (R
!= 2) return (PARSER_SALT_VALUE
);
17401 const int enc_md
= atoi (enc_md_pos
);
17403 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17405 const int id_len
= atoi (id_len_pos
);
17406 const int u_len
= atoi (u_len_pos
);
17407 const int o_len
= atoi (o_len_pos
);
17409 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17410 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17411 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17413 const int bits
= atoi (bits_pos
);
17415 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17417 // copy data to esalt
17423 pdf
->enc_md
= enc_md
;
17425 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17426 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17427 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17428 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17429 pdf
->id_len
= id_len
;
17431 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17432 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17433 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17434 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17435 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17436 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17437 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17438 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17439 pdf
->u_len
= u_len
;
17441 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17442 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17443 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17444 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17445 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17446 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17447 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17448 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17449 pdf
->o_len
= o_len
;
17451 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17452 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17453 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17454 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17456 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17457 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17458 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17459 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17460 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17461 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17462 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17463 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17465 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17466 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17467 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17468 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17469 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17470 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17471 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17472 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17474 pdf
->rc4key
[1] = 0;
17475 pdf
->rc4key
[0] = 0;
17477 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17478 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17479 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17480 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17481 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17482 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17483 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17484 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17485 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17486 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17488 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17489 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17491 // we use ID for salt, maybe needs to change, we will see...
17493 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17494 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17495 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17496 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17497 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17498 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17499 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17500 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17501 salt
->salt_len
= pdf
->id_len
+ 16;
17503 digest
[0] = pdf
->rc4key
[0];
17504 digest
[1] = pdf
->rc4key
[1];
17508 return (PARSER_OK
);
17511 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17513 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17515 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17517 u32
*digest
= (u32
*) hash_buf
->digest
;
17519 salt_t
*salt
= hash_buf
->salt
;
17521 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17527 char *V_pos
= input_buf
+ 5;
17529 char *R_pos
= strchr (V_pos
, '*');
17531 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17533 u32 V_len
= R_pos
- V_pos
;
17537 char *bits_pos
= strchr (R_pos
, '*');
17539 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17541 u32 R_len
= bits_pos
- R_pos
;
17545 char *P_pos
= strchr (bits_pos
, '*');
17547 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17549 u32 bits_len
= P_pos
- bits_pos
;
17553 char *enc_md_pos
= strchr (P_pos
, '*');
17555 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17557 u32 P_len
= enc_md_pos
- P_pos
;
17561 char *id_len_pos
= strchr (enc_md_pos
, '*');
17563 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17565 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17569 char *id_buf_pos
= strchr (id_len_pos
, '*');
17571 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17573 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17577 char *u_len_pos
= strchr (id_buf_pos
, '*');
17579 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17581 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17583 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17587 char *u_buf_pos
= strchr (u_len_pos
, '*');
17589 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17591 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17595 char *o_len_pos
= strchr (u_buf_pos
, '*');
17597 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17599 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17601 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17605 char *o_buf_pos
= strchr (o_len_pos
, '*');
17607 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17609 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17613 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;
17615 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17619 const int V
= atoi (V_pos
);
17620 const int R
= atoi (R_pos
);
17621 const int P
= atoi (P_pos
);
17625 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17626 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17628 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17630 const int id_len
= atoi (id_len_pos
);
17631 const int u_len
= atoi (u_len_pos
);
17632 const int o_len
= atoi (o_len_pos
);
17634 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17636 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17637 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17639 const int bits
= atoi (bits_pos
);
17641 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17647 enc_md
= atoi (enc_md_pos
);
17650 // copy data to esalt
17656 pdf
->enc_md
= enc_md
;
17658 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17659 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17660 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17661 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17665 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17666 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17667 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17668 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17671 pdf
->id_len
= id_len
;
17673 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17674 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17675 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17676 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17677 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17678 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17679 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17680 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17681 pdf
->u_len
= u_len
;
17683 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17684 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17685 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17686 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17687 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17688 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17689 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17690 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17691 pdf
->o_len
= o_len
;
17693 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17694 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17695 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17696 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17700 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17701 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17702 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17703 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17706 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17707 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17708 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17709 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17710 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17711 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17712 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17713 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17715 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17716 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17717 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17718 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17719 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17720 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17721 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17722 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17724 // precompute rc4 data for later use
17740 uint salt_pc_block
[32] = { 0 };
17742 char *salt_pc_ptr
= (char *) salt_pc_block
;
17744 memcpy (salt_pc_ptr
, padding
, 32);
17745 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17747 uint salt_pc_digest
[4] = { 0 };
17749 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17751 pdf
->rc4data
[0] = salt_pc_digest
[0];
17752 pdf
->rc4data
[1] = salt_pc_digest
[1];
17754 // we use ID for salt, maybe needs to change, we will see...
17756 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17757 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17758 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17759 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17760 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17761 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17762 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17763 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17764 salt
->salt_len
= pdf
->id_len
+ 16;
17766 salt
->salt_iter
= ROUNDS_PDF14
;
17768 digest
[0] = pdf
->u_buf
[0];
17769 digest
[1] = pdf
->u_buf
[1];
17773 return (PARSER_OK
);
17776 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17778 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17780 if (ret
!= PARSER_OK
)
17785 u32
*digest
= (u32
*) hash_buf
->digest
;
17787 salt_t
*salt
= hash_buf
->salt
;
17789 digest
[0] -= SHA256M_A
;
17790 digest
[1] -= SHA256M_B
;
17791 digest
[2] -= SHA256M_C
;
17792 digest
[3] -= SHA256M_D
;
17793 digest
[4] -= SHA256M_E
;
17794 digest
[5] -= SHA256M_F
;
17795 digest
[6] -= SHA256M_G
;
17796 digest
[7] -= SHA256M_H
;
17798 salt
->salt_buf
[2] = 0x80;
17800 return (PARSER_OK
);
17803 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17805 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17807 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17809 u32
*digest
= (u32
*) hash_buf
->digest
;
17811 salt_t
*salt
= hash_buf
->salt
;
17813 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17819 char *V_pos
= input_buf
+ 5;
17821 char *R_pos
= strchr (V_pos
, '*');
17823 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17825 u32 V_len
= R_pos
- V_pos
;
17829 char *bits_pos
= strchr (R_pos
, '*');
17831 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17833 u32 R_len
= bits_pos
- R_pos
;
17837 char *P_pos
= strchr (bits_pos
, '*');
17839 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17841 u32 bits_len
= P_pos
- bits_pos
;
17845 char *enc_md_pos
= strchr (P_pos
, '*');
17847 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17849 u32 P_len
= enc_md_pos
- P_pos
;
17853 char *id_len_pos
= strchr (enc_md_pos
, '*');
17855 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17857 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17861 char *id_buf_pos
= strchr (id_len_pos
, '*');
17863 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17865 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17869 char *u_len_pos
= strchr (id_buf_pos
, '*');
17871 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17873 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17877 char *u_buf_pos
= strchr (u_len_pos
, '*');
17879 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17881 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17885 char *o_len_pos
= strchr (u_buf_pos
, '*');
17887 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17889 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17893 char *o_buf_pos
= strchr (o_len_pos
, '*');
17895 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17897 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17901 char *last
= strchr (o_buf_pos
, '*');
17903 if (last
== NULL
) last
= input_buf
+ input_len
;
17905 u32 o_buf_len
= last
- o_buf_pos
;
17909 const int V
= atoi (V_pos
);
17910 const int R
= atoi (R_pos
);
17914 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17915 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17917 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17919 const int bits
= atoi (bits_pos
);
17921 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17923 int enc_md
= atoi (enc_md_pos
);
17925 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17927 const uint id_len
= atoi (id_len_pos
);
17928 const uint u_len
= atoi (u_len_pos
);
17929 const uint o_len
= atoi (o_len_pos
);
17931 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17932 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17933 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17934 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17935 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17936 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17937 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17938 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17940 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17941 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17942 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17944 // copy data to esalt
17946 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17948 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17950 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17953 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17954 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17956 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17957 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17959 salt
->salt_len
= 8;
17960 salt
->salt_iter
= ROUNDS_PDF17L8
;
17962 digest
[0] = pdf
->u_buf
[0];
17963 digest
[1] = pdf
->u_buf
[1];
17964 digest
[2] = pdf
->u_buf
[2];
17965 digest
[3] = pdf
->u_buf
[3];
17966 digest
[4] = pdf
->u_buf
[4];
17967 digest
[5] = pdf
->u_buf
[5];
17968 digest
[6] = pdf
->u_buf
[6];
17969 digest
[7] = pdf
->u_buf
[7];
17971 return (PARSER_OK
);
17974 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17976 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17978 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17980 u32
*digest
= (u32
*) hash_buf
->digest
;
17982 salt_t
*salt
= hash_buf
->salt
;
17984 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17992 char *iter_pos
= input_buf
+ 7;
17994 u32 iter
= atoi (iter_pos
);
17996 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17997 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17999 // first is *raw* salt
18001 char *salt_pos
= strchr (iter_pos
, ':');
18003 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18007 char *hash_pos
= strchr (salt_pos
, ':');
18009 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18011 u32 salt_len
= hash_pos
- salt_pos
;
18013 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18017 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18019 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18023 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
18025 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18027 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18029 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18030 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18032 salt
->salt_len
= salt_len
;
18033 salt
->salt_iter
= iter
- 1;
18037 u8 tmp_buf
[100] = { 0 };
18039 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18041 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18043 memcpy (digest
, tmp_buf
, 16);
18045 digest
[0] = byte_swap_32 (digest
[0]);
18046 digest
[1] = byte_swap_32 (digest
[1]);
18047 digest
[2] = byte_swap_32 (digest
[2]);
18048 digest
[3] = byte_swap_32 (digest
[3]);
18050 // add some stuff to normal salt to make sorted happy
18052 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
18053 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
18054 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
18055 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
18056 salt
->salt_buf
[4] = salt
->salt_iter
;
18058 return (PARSER_OK
);
18061 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18063 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
18065 u32
*digest
= (u32
*) hash_buf
->digest
;
18067 salt_t
*salt
= hash_buf
->salt
;
18069 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18070 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18071 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18072 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18074 digest
[0] = byte_swap_32 (digest
[0]);
18075 digest
[1] = byte_swap_32 (digest
[1]);
18076 digest
[2] = byte_swap_32 (digest
[2]);
18077 digest
[3] = byte_swap_32 (digest
[3]);
18079 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18081 uint salt_len
= input_len
- 32 - 1;
18083 char *salt_buf
= input_buf
+ 32 + 1;
18085 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18087 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18089 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18091 salt
->salt_len
= salt_len
;
18093 return (PARSER_OK
);
18096 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18098 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
18100 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18102 u32
*digest
= (u32
*) hash_buf
->digest
;
18104 salt_t
*salt
= hash_buf
->salt
;
18106 char *user_pos
= input_buf
+ 10;
18108 char *salt_pos
= strchr (user_pos
, '*');
18110 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18114 char *hash_pos
= strchr (salt_pos
, '*');
18118 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18120 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18122 uint user_len
= salt_pos
- user_pos
- 1;
18124 uint salt_len
= hash_pos
- salt_pos
- 1;
18126 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18132 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18133 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18134 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18135 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18137 digest
[0] = byte_swap_32 (digest
[0]);
18138 digest
[1] = byte_swap_32 (digest
[1]);
18139 digest
[2] = byte_swap_32 (digest
[2]);
18140 digest
[3] = byte_swap_32 (digest
[3]);
18142 digest
[0] -= MD5M_A
;
18143 digest
[1] -= MD5M_B
;
18144 digest
[2] -= MD5M_C
;
18145 digest
[3] -= MD5M_D
;
18151 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18153 // first 4 bytes are the "challenge"
18155 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18156 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18157 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18158 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18160 // append the user name
18162 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18164 salt
->salt_len
= 4 + user_len
;
18166 return (PARSER_OK
);
18169 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18171 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18173 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18175 u32
*digest
= (u32
*) hash_buf
->digest
;
18177 salt_t
*salt
= hash_buf
->salt
;
18179 char *salt_pos
= input_buf
+ 9;
18181 char *hash_pos
= strchr (salt_pos
, '*');
18183 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18187 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18189 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18191 uint salt_len
= hash_pos
- salt_pos
- 1;
18193 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18199 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18200 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18201 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18202 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18203 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18209 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18211 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18213 salt
->salt_len
= salt_len
;
18215 return (PARSER_OK
);
18218 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18220 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18222 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18224 u32
*digest
= (u32
*) hash_buf
->digest
;
18226 salt_t
*salt
= hash_buf
->salt
;
18228 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18234 char *cry_master_len_pos
= input_buf
+ 9;
18236 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18238 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18240 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18242 cry_master_buf_pos
++;
18244 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18246 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18248 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18250 cry_salt_len_pos
++;
18252 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18254 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18256 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18258 cry_salt_buf_pos
++;
18260 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18262 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18264 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18268 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18270 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18272 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18276 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18278 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18280 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18284 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18286 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18288 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18290 public_key_len_pos
++;
18292 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18294 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18296 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18298 public_key_buf_pos
++;
18300 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;
18302 const uint cry_master_len
= atoi (cry_master_len_pos
);
18303 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18304 const uint ckey_len
= atoi (ckey_len_pos
);
18305 const uint public_key_len
= atoi (public_key_len_pos
);
18307 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18308 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18309 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18310 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18312 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18314 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18316 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18319 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18321 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18323 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18326 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18328 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18330 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18333 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18334 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18335 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18338 * store digest (should be unique enought, hopefully)
18341 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18342 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18343 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18344 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18350 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18352 const uint cry_rounds
= atoi (cry_rounds_pos
);
18354 salt
->salt_iter
= cry_rounds
- 1;
18356 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18358 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18360 salt
->salt_len
= salt_len
;
18362 return (PARSER_OK
);
18365 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18367 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18369 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18371 u32
*digest
= (u32
*) hash_buf
->digest
;
18373 salt_t
*salt
= hash_buf
->salt
;
18375 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18377 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18379 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18381 memcpy (temp_input_buf
, input_buf
, input_len
);
18385 char *URI_server_pos
= temp_input_buf
+ 6;
18387 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18389 if (URI_client_pos
== NULL
)
18391 myfree (temp_input_buf
);
18393 return (PARSER_SEPARATOR_UNMATCHED
);
18396 URI_client_pos
[0] = 0;
18399 uint URI_server_len
= strlen (URI_server_pos
);
18401 if (URI_server_len
> 512)
18403 myfree (temp_input_buf
);
18405 return (PARSER_SALT_LENGTH
);
18410 char *user_pos
= strchr (URI_client_pos
, '*');
18412 if (user_pos
== NULL
)
18414 myfree (temp_input_buf
);
18416 return (PARSER_SEPARATOR_UNMATCHED
);
18422 uint URI_client_len
= strlen (URI_client_pos
);
18424 if (URI_client_len
> 512)
18426 myfree (temp_input_buf
);
18428 return (PARSER_SALT_LENGTH
);
18433 char *realm_pos
= strchr (user_pos
, '*');
18435 if (realm_pos
== NULL
)
18437 myfree (temp_input_buf
);
18439 return (PARSER_SEPARATOR_UNMATCHED
);
18445 uint user_len
= strlen (user_pos
);
18447 if (user_len
> 116)
18449 myfree (temp_input_buf
);
18451 return (PARSER_SALT_LENGTH
);
18456 char *method_pos
= strchr (realm_pos
, '*');
18458 if (method_pos
== NULL
)
18460 myfree (temp_input_buf
);
18462 return (PARSER_SEPARATOR_UNMATCHED
);
18468 uint realm_len
= strlen (realm_pos
);
18470 if (realm_len
> 116)
18472 myfree (temp_input_buf
);
18474 return (PARSER_SALT_LENGTH
);
18479 char *URI_prefix_pos
= strchr (method_pos
, '*');
18481 if (URI_prefix_pos
== NULL
)
18483 myfree (temp_input_buf
);
18485 return (PARSER_SEPARATOR_UNMATCHED
);
18488 URI_prefix_pos
[0] = 0;
18491 uint method_len
= strlen (method_pos
);
18493 if (method_len
> 246)
18495 myfree (temp_input_buf
);
18497 return (PARSER_SALT_LENGTH
);
18502 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18504 if (URI_resource_pos
== NULL
)
18506 myfree (temp_input_buf
);
18508 return (PARSER_SEPARATOR_UNMATCHED
);
18511 URI_resource_pos
[0] = 0;
18512 URI_resource_pos
++;
18514 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18516 if (URI_prefix_len
> 245)
18518 myfree (temp_input_buf
);
18520 return (PARSER_SALT_LENGTH
);
18525 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18527 if (URI_suffix_pos
== NULL
)
18529 myfree (temp_input_buf
);
18531 return (PARSER_SEPARATOR_UNMATCHED
);
18534 URI_suffix_pos
[0] = 0;
18537 uint URI_resource_len
= strlen (URI_resource_pos
);
18539 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18541 myfree (temp_input_buf
);
18543 return (PARSER_SALT_LENGTH
);
18548 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18550 if (nonce_pos
== NULL
)
18552 myfree (temp_input_buf
);
18554 return (PARSER_SEPARATOR_UNMATCHED
);
18560 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18562 if (URI_suffix_len
> 245)
18564 myfree (temp_input_buf
);
18566 return (PARSER_SALT_LENGTH
);
18571 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18573 if (nonce_client_pos
== NULL
)
18575 myfree (temp_input_buf
);
18577 return (PARSER_SEPARATOR_UNMATCHED
);
18580 nonce_client_pos
[0] = 0;
18581 nonce_client_pos
++;
18583 uint nonce_len
= strlen (nonce_pos
);
18585 if (nonce_len
< 1 || nonce_len
> 50)
18587 myfree (temp_input_buf
);
18589 return (PARSER_SALT_LENGTH
);
18594 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18596 if (nonce_count_pos
== NULL
)
18598 myfree (temp_input_buf
);
18600 return (PARSER_SEPARATOR_UNMATCHED
);
18603 nonce_count_pos
[0] = 0;
18606 uint nonce_client_len
= strlen (nonce_client_pos
);
18608 if (nonce_client_len
> 50)
18610 myfree (temp_input_buf
);
18612 return (PARSER_SALT_LENGTH
);
18617 char *qop_pos
= strchr (nonce_count_pos
, '*');
18619 if (qop_pos
== NULL
)
18621 myfree (temp_input_buf
);
18623 return (PARSER_SEPARATOR_UNMATCHED
);
18629 uint nonce_count_len
= strlen (nonce_count_pos
);
18631 if (nonce_count_len
> 50)
18633 myfree (temp_input_buf
);
18635 return (PARSER_SALT_LENGTH
);
18640 char *directive_pos
= strchr (qop_pos
, '*');
18642 if (directive_pos
== NULL
)
18644 myfree (temp_input_buf
);
18646 return (PARSER_SEPARATOR_UNMATCHED
);
18649 directive_pos
[0] = 0;
18652 uint qop_len
= strlen (qop_pos
);
18656 myfree (temp_input_buf
);
18658 return (PARSER_SALT_LENGTH
);
18663 char *digest_pos
= strchr (directive_pos
, '*');
18665 if (digest_pos
== NULL
)
18667 myfree (temp_input_buf
);
18669 return (PARSER_SEPARATOR_UNMATCHED
);
18675 uint directive_len
= strlen (directive_pos
);
18677 if (directive_len
!= 3)
18679 myfree (temp_input_buf
);
18681 return (PARSER_SALT_LENGTH
);
18684 if (memcmp (directive_pos
, "MD5", 3))
18686 log_info ("ERROR: Only the MD5 directive is currently supported\n");
18688 myfree (temp_input_buf
);
18690 return (PARSER_SIP_AUTH_DIRECTIVE
);
18694 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18699 uint md5_max_len
= 4 * 64;
18701 uint md5_remaining_len
= md5_max_len
;
18703 uint tmp_md5_buf
[64] = { 0 };
18705 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18707 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18709 md5_len
+= method_len
+ 1;
18710 tmp_md5_ptr
+= method_len
+ 1;
18712 if (URI_prefix_len
> 0)
18714 md5_remaining_len
= md5_max_len
- md5_len
;
18716 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18718 md5_len
+= URI_prefix_len
+ 1;
18719 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18722 md5_remaining_len
= md5_max_len
- md5_len
;
18724 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18726 md5_len
+= URI_resource_len
;
18727 tmp_md5_ptr
+= URI_resource_len
;
18729 if (URI_suffix_len
> 0)
18731 md5_remaining_len
= md5_max_len
- md5_len
;
18733 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18735 md5_len
+= 1 + URI_suffix_len
;
18738 uint tmp_digest
[4] = { 0 };
18740 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18742 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18743 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18744 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18745 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18751 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18753 uint esalt_len
= 0;
18755 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18757 // there are 2 possibilities for the esalt:
18759 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18761 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18763 if (esalt_len
> max_esalt_len
)
18765 myfree (temp_input_buf
);
18767 return (PARSER_SALT_LENGTH
);
18770 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18782 esalt_len
= 1 + nonce_len
+ 1 + 32;
18784 if (esalt_len
> max_esalt_len
)
18786 myfree (temp_input_buf
);
18788 return (PARSER_SALT_LENGTH
);
18791 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18799 // add 0x80 to esalt
18801 esalt_buf_ptr
[esalt_len
] = 0x80;
18803 sip
->esalt_len
= esalt_len
;
18809 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18811 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18813 uint max_salt_len
= 119;
18815 if (salt_len
> max_salt_len
)
18817 myfree (temp_input_buf
);
18819 return (PARSER_SALT_LENGTH
);
18822 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18824 sip
->salt_len
= salt_len
;
18827 * fake salt (for sorting)
18830 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18834 uint fake_salt_len
= salt_len
;
18836 if (fake_salt_len
> max_salt_len
)
18838 fake_salt_len
= max_salt_len
;
18841 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18843 salt
->salt_len
= fake_salt_len
;
18849 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18850 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18851 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18852 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18854 digest
[0] = byte_swap_32 (digest
[0]);
18855 digest
[1] = byte_swap_32 (digest
[1]);
18856 digest
[2] = byte_swap_32 (digest
[2]);
18857 digest
[3] = byte_swap_32 (digest
[3]);
18859 myfree (temp_input_buf
);
18861 return (PARSER_OK
);
18864 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18866 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18868 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18870 u32
*digest
= (u32
*) hash_buf
->digest
;
18872 salt_t
*salt
= hash_buf
->salt
;
18876 char *digest_pos
= input_buf
;
18878 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18885 char *salt_buf
= input_buf
+ 8 + 1;
18889 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18891 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18893 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18895 salt
->salt_len
= salt_len
;
18897 return (PARSER_OK
);
18900 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18902 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18904 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18906 u32
*digest
= (u32
*) hash_buf
->digest
;
18908 salt_t
*salt
= hash_buf
->salt
;
18910 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18916 char *p_buf_pos
= input_buf
+ 4;
18918 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18920 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18922 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18924 NumCyclesPower_pos
++;
18926 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18928 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18930 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18934 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18936 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18938 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18942 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18944 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18946 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18950 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18952 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18954 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18958 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18960 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18962 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18966 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18968 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18970 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18974 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18976 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18978 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18982 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18984 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18986 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18990 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;
18992 const uint iter
= atoi (NumCyclesPower_pos
);
18993 const uint crc
= atoi (crc_buf_pos
);
18994 const uint p_buf
= atoi (p_buf_pos
);
18995 const uint salt_len
= atoi (salt_len_pos
);
18996 const uint iv_len
= atoi (iv_len_pos
);
18997 const uint unpack_size
= atoi (unpack_size_pos
);
18998 const uint data_len
= atoi (data_len_pos
);
19004 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
19005 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
19007 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
19009 if (data_len
> 384) return (PARSER_SALT_VALUE
);
19011 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
19017 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
19018 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
19019 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
19020 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
19022 seven_zip
->iv_len
= iv_len
;
19024 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
19026 seven_zip
->salt_len
= 0;
19028 seven_zip
->crc
= crc
;
19030 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
19032 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
19034 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
19037 seven_zip
->data_len
= data_len
;
19039 seven_zip
->unpack_size
= unpack_size
;
19043 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
19044 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
19045 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
19046 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
19048 salt
->salt_len
= 16;
19050 salt
->salt_sign
[0] = iter
;
19052 salt
->salt_iter
= 1 << iter
;
19063 return (PARSER_OK
);
19066 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19068 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
19070 u32
*digest
= (u32
*) hash_buf
->digest
;
19072 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19073 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19074 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19075 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19076 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19077 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19078 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19079 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19081 digest
[0] = byte_swap_32 (digest
[0]);
19082 digest
[1] = byte_swap_32 (digest
[1]);
19083 digest
[2] = byte_swap_32 (digest
[2]);
19084 digest
[3] = byte_swap_32 (digest
[3]);
19085 digest
[4] = byte_swap_32 (digest
[4]);
19086 digest
[5] = byte_swap_32 (digest
[5]);
19087 digest
[6] = byte_swap_32 (digest
[6]);
19088 digest
[7] = byte_swap_32 (digest
[7]);
19090 return (PARSER_OK
);
19093 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19095 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
19097 u32
*digest
= (u32
*) hash_buf
->digest
;
19099 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19100 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19101 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
19102 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
19103 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
19104 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
19105 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
19106 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
19107 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
19108 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
19109 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
19110 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
19111 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
19112 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
19113 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
19114 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
19116 digest
[ 0] = byte_swap_32 (digest
[ 0]);
19117 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19118 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19119 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19120 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19121 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19122 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19123 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19124 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19125 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19126 digest
[10] = byte_swap_32 (digest
[10]);
19127 digest
[11] = byte_swap_32 (digest
[11]);
19128 digest
[12] = byte_swap_32 (digest
[12]);
19129 digest
[13] = byte_swap_32 (digest
[13]);
19130 digest
[14] = byte_swap_32 (digest
[14]);
19131 digest
[15] = byte_swap_32 (digest
[15]);
19133 return (PARSER_OK
);
19136 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19138 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19140 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19142 u32
*digest
= (u32
*) hash_buf
->digest
;
19144 salt_t
*salt
= hash_buf
->salt
;
19146 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19154 char *iter_pos
= input_buf
+ 4;
19156 u32 iter
= atoi (iter_pos
);
19158 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19159 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19161 // first is *raw* salt
19163 char *salt_pos
= strchr (iter_pos
, ':');
19165 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19169 char *hash_pos
= strchr (salt_pos
, ':');
19171 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19173 u32 salt_len
= hash_pos
- salt_pos
;
19175 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19179 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19181 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19185 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19187 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19189 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19191 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19192 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19194 salt
->salt_len
= salt_len
;
19195 salt
->salt_iter
= iter
- 1;
19199 u8 tmp_buf
[100] = { 0 };
19201 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19203 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19205 memcpy (digest
, tmp_buf
, 16);
19207 // add some stuff to normal salt to make sorted happy
19209 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19210 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19211 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19212 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19213 salt
->salt_buf
[4] = salt
->salt_iter
;
19215 return (PARSER_OK
);
19218 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19220 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19222 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19224 u32
*digest
= (u32
*) hash_buf
->digest
;
19226 salt_t
*salt
= hash_buf
->salt
;
19228 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19236 char *iter_pos
= input_buf
+ 5;
19238 u32 iter
= atoi (iter_pos
);
19240 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19241 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19243 // first is *raw* salt
19245 char *salt_pos
= strchr (iter_pos
, ':');
19247 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19251 char *hash_pos
= strchr (salt_pos
, ':');
19253 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19255 u32 salt_len
= hash_pos
- salt_pos
;
19257 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19261 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19263 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19267 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19269 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19271 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19273 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19274 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19276 salt
->salt_len
= salt_len
;
19277 salt
->salt_iter
= iter
- 1;
19281 u8 tmp_buf
[100] = { 0 };
19283 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19285 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19287 memcpy (digest
, tmp_buf
, 16);
19289 digest
[0] = byte_swap_32 (digest
[0]);
19290 digest
[1] = byte_swap_32 (digest
[1]);
19291 digest
[2] = byte_swap_32 (digest
[2]);
19292 digest
[3] = byte_swap_32 (digest
[3]);
19294 // add some stuff to normal salt to make sorted happy
19296 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19297 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19298 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19299 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19300 salt
->salt_buf
[4] = salt
->salt_iter
;
19302 return (PARSER_OK
);
19305 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19307 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19309 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19311 u64
*digest
= (u64
*) hash_buf
->digest
;
19313 salt_t
*salt
= hash_buf
->salt
;
19315 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19323 char *iter_pos
= input_buf
+ 7;
19325 u32 iter
= atoi (iter_pos
);
19327 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19328 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19330 // first is *raw* salt
19332 char *salt_pos
= strchr (iter_pos
, ':');
19334 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19338 char *hash_pos
= strchr (salt_pos
, ':');
19340 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19342 u32 salt_len
= hash_pos
- salt_pos
;
19344 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19348 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19350 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19354 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19356 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19358 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19360 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19361 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19363 salt
->salt_len
= salt_len
;
19364 salt
->salt_iter
= iter
- 1;
19368 u8 tmp_buf
[100] = { 0 };
19370 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19372 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19374 memcpy (digest
, tmp_buf
, 64);
19376 digest
[0] = byte_swap_64 (digest
[0]);
19377 digest
[1] = byte_swap_64 (digest
[1]);
19378 digest
[2] = byte_swap_64 (digest
[2]);
19379 digest
[3] = byte_swap_64 (digest
[3]);
19380 digest
[4] = byte_swap_64 (digest
[4]);
19381 digest
[5] = byte_swap_64 (digest
[5]);
19382 digest
[6] = byte_swap_64 (digest
[6]);
19383 digest
[7] = byte_swap_64 (digest
[7]);
19385 // add some stuff to normal salt to make sorted happy
19387 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19388 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19389 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19390 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19391 salt
->salt_buf
[4] = salt
->salt_iter
;
19393 return (PARSER_OK
);
19396 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19398 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19400 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19402 uint
*digest
= (uint
*) hash_buf
->digest
;
19404 salt_t
*salt
= hash_buf
->salt
;
19410 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19412 char *hash_pos
= strchr (salt_pos
, '$');
19414 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19416 u32 salt_len
= hash_pos
- salt_pos
;
19418 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19422 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19424 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19428 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19429 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19447 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19448 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19450 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19451 salt
->salt_len
= 8;
19453 return (PARSER_OK
);
19456 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19458 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19460 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19462 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19464 if (c19
& 3) return (PARSER_HASH_VALUE
);
19466 salt_t
*salt
= hash_buf
->salt
;
19468 u32
*digest
= (u32
*) hash_buf
->digest
;
19472 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19473 | itoa64_to_int (input_buf
[2]) << 6
19474 | itoa64_to_int (input_buf
[3]) << 12
19475 | itoa64_to_int (input_buf
[4]) << 18;
19479 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19480 | itoa64_to_int (input_buf
[6]) << 6
19481 | itoa64_to_int (input_buf
[7]) << 12
19482 | itoa64_to_int (input_buf
[8]) << 18;
19484 salt
->salt_len
= 4;
19486 u8 tmp_buf
[100] = { 0 };
19488 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19490 memcpy (digest
, tmp_buf
, 8);
19494 IP (digest
[0], digest
[1], tt
);
19496 digest
[0] = rotr32 (digest
[0], 31);
19497 digest
[1] = rotr32 (digest
[1], 31);
19501 return (PARSER_OK
);
19504 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19506 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19508 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19510 u32
*digest
= (u32
*) hash_buf
->digest
;
19512 salt_t
*salt
= hash_buf
->salt
;
19518 char *type_pos
= input_buf
+ 6 + 1;
19520 char *salt_pos
= strchr (type_pos
, '*');
19522 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19524 u32 type_len
= salt_pos
- type_pos
;
19526 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19530 char *crypted_pos
= strchr (salt_pos
, '*');
19532 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19534 u32 salt_len
= crypted_pos
- salt_pos
;
19536 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19540 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19542 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19548 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19549 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19551 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19552 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19554 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19555 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19556 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19557 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19559 salt
->salt_len
= 24;
19560 salt
->salt_iter
= ROUNDS_RAR3
;
19562 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19563 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19565 digest
[0] = 0xc43d7b00;
19566 digest
[1] = 0x40070000;
19570 return (PARSER_OK
);
19573 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19575 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19577 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19579 u32
*digest
= (u32
*) hash_buf
->digest
;
19581 salt_t
*salt
= hash_buf
->salt
;
19583 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19589 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19591 char *param1_pos
= strchr (param0_pos
, '$');
19593 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19595 u32 param0_len
= param1_pos
- param0_pos
;
19599 char *param2_pos
= strchr (param1_pos
, '$');
19601 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19603 u32 param1_len
= param2_pos
- param1_pos
;
19607 char *param3_pos
= strchr (param2_pos
, '$');
19609 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19611 u32 param2_len
= param3_pos
- param2_pos
;
19615 char *param4_pos
= strchr (param3_pos
, '$');
19617 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19619 u32 param3_len
= param4_pos
- param3_pos
;
19623 char *param5_pos
= strchr (param4_pos
, '$');
19625 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19627 u32 param4_len
= param5_pos
- param4_pos
;
19631 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19633 char *salt_buf
= param1_pos
;
19634 char *iv
= param3_pos
;
19635 char *pswcheck
= param5_pos
;
19637 const uint salt_len
= atoi (param0_pos
);
19638 const uint iterations
= atoi (param2_pos
);
19639 const uint pswcheck_len
= atoi (param4_pos
);
19645 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19646 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19647 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19649 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19650 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19651 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19657 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19658 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19659 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19660 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19662 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19663 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19664 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19665 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19667 salt
->salt_len
= 16;
19669 salt
->salt_sign
[0] = iterations
;
19671 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19677 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19678 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19682 return (PARSER_OK
);
19685 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19687 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19689 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19691 u32
*digest
= (u32
*) hash_buf
->digest
;
19693 salt_t
*salt
= hash_buf
->salt
;
19695 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19702 char *account_pos
= input_buf
+ 11 + 1;
19708 if (account_pos
[0] == '*')
19712 data_pos
= strchr (account_pos
, '*');
19717 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19719 uint account_len
= data_pos
- account_pos
+ 1;
19721 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19726 data_len
= input_len
- 11 - 1 - account_len
- 2;
19728 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19732 /* assume $krb5tgs$23$checksum$edata2 */
19733 data_pos
= account_pos
;
19735 memcpy (krb5tgs
->account_info
, "**", 3);
19737 data_len
= input_len
- 11 - 1 - 1;
19740 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19742 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19744 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19746 const char p0
= data_pos
[i
+ 0];
19747 const char p1
= data_pos
[i
+ 1];
19749 *checksum_ptr
++ = hex_convert (p1
) << 0
19750 | hex_convert (p0
) << 4;
19753 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19755 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19758 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19760 const char p0
= data_pos
[i
+ 0];
19761 const char p1
= data_pos
[i
+ 1];
19762 *edata_ptr
++ = hex_convert (p1
) << 0
19763 | hex_convert (p0
) << 4;
19766 /* this is needed for hmac_md5 */
19767 *edata_ptr
++ = 0x80;
19769 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19770 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19771 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19772 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19774 salt
->salt_len
= 32;
19776 digest
[0] = krb5tgs
->checksum
[0];
19777 digest
[1] = krb5tgs
->checksum
[1];
19778 digest
[2] = krb5tgs
->checksum
[2];
19779 digest
[3] = krb5tgs
->checksum
[3];
19781 return (PARSER_OK
);
19784 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19786 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19788 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19790 u32
*digest
= (u32
*) hash_buf
->digest
;
19792 salt_t
*salt
= hash_buf
->salt
;
19799 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19803 char *wrapped_key_pos
;
19807 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19809 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19811 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19813 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19818 data_pos
= salt_pos
;
19820 wrapped_key_pos
= strchr (salt_pos
, '*');
19822 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19824 uint salt_len
= wrapped_key_pos
- salt_pos
;
19826 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19831 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19833 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19835 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19836 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19837 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19838 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19842 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19843 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19844 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19845 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19846 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19847 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19849 salt
->salt_len
= 40;
19851 digest
[0] = salt
->salt_buf
[0];
19852 digest
[1] = salt
->salt_buf
[1];
19853 digest
[2] = salt
->salt_buf
[2];
19854 digest
[3] = salt
->salt_buf
[3];
19856 return (PARSER_OK
);
19859 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19861 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19863 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19865 u32
*digest
= (u32
*) hash_buf
->digest
;
19867 salt_t
*salt
= hash_buf
->salt
;
19869 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19879 char *algorithm_pos
;
19881 char *final_random_seed_pos
;
19882 u32 final_random_seed_len
;
19884 char *transf_random_seed_pos
;
19885 u32 transf_random_seed_len
;
19890 /* default is no keyfile provided */
19891 char *keyfile_len_pos
;
19892 u32 keyfile_len
= 0;
19893 u32 is_keyfile_present
= 0;
19894 char *keyfile_inline_pos
;
19897 /* specific to version 1 */
19898 char *contents_len_pos
;
19900 char *contents_pos
;
19902 /* specific to version 2 */
19903 char *expected_bytes_pos
;
19904 u32 expected_bytes_len
;
19906 char *contents_hash_pos
;
19907 u32 contents_hash_len
;
19909 version_pos
= input_buf
+ 8 + 1 + 1;
19911 keepass
->version
= atoi (version_pos
);
19913 rounds_pos
= strchr (version_pos
, '*');
19915 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19919 salt
->salt_iter
= (atoi (rounds_pos
));
19921 algorithm_pos
= strchr (rounds_pos
, '*');
19923 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19927 keepass
->algorithm
= atoi (algorithm_pos
);
19929 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19931 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19933 final_random_seed_pos
++;
19935 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19936 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19937 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19938 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19940 if (keepass
->version
== 2)
19942 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19943 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19944 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19945 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19948 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19950 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19952 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19954 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19955 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19957 transf_random_seed_pos
++;
19959 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19960 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19961 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19962 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19963 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19964 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19965 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19966 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19968 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19970 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19972 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19974 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19978 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19979 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19980 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19981 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19983 if (keepass
->version
== 1)
19985 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19987 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19989 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19991 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19993 contents_hash_pos
++;
19995 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19996 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19997 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19998 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19999 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20000 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20001 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20002 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20004 /* get length of contents following */
20005 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
20007 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20009 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
20011 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20015 u32 inline_flag
= atoi (inline_flag_pos
);
20017 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
20019 contents_len_pos
= strchr (inline_flag_pos
, '*');
20021 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20023 contents_len_pos
++;
20025 contents_len
= atoi (contents_len_pos
);
20027 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
20029 contents_pos
= strchr (contents_len_pos
, '*');
20031 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20037 keepass
->contents_len
= contents_len
;
20039 contents_len
= contents_len
/ 4;
20041 keyfile_inline_pos
= strchr (contents_pos
, '*');
20043 u32 real_contents_len
;
20045 if (keyfile_inline_pos
== NULL
)
20046 real_contents_len
= input_len
- (contents_pos
- input_buf
);
20049 real_contents_len
= keyfile_inline_pos
- contents_pos
;
20050 keyfile_inline_pos
++;
20051 is_keyfile_present
= 1;
20054 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
20056 for (i
= 0; i
< contents_len
; i
++)
20057 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
20059 else if (keepass
->version
== 2)
20061 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
20063 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20065 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
20067 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
20069 expected_bytes_pos
++;
20071 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
20072 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
20073 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
20074 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
20075 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
20076 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
20077 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
20078 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
20080 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
20082 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20084 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
20086 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
20088 contents_hash_pos
++;
20090 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
20091 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
20092 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
20093 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20094 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20095 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20096 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20097 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20099 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
20101 if (keyfile_inline_pos
== NULL
)
20102 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
20105 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
20106 keyfile_inline_pos
++;
20107 is_keyfile_present
= 1;
20109 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20112 if (is_keyfile_present
!= 0)
20114 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20118 keyfile_len
= atoi (keyfile_len_pos
);
20120 keepass
->keyfile_len
= keyfile_len
;
20122 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20124 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20126 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20130 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20132 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20134 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20135 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20136 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20137 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20138 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20139 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20140 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20141 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20144 digest
[0] = keepass
->enc_iv
[0];
20145 digest
[1] = keepass
->enc_iv
[1];
20146 digest
[2] = keepass
->enc_iv
[2];
20147 digest
[3] = keepass
->enc_iv
[3];
20149 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20150 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20151 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20152 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20153 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20154 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20155 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20156 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20158 return (PARSER_OK
);
20161 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20163 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20165 u32
*digest
= (u32
*) hash_buf
->digest
;
20167 salt_t
*salt
= hash_buf
->salt
;
20169 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20170 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20171 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20172 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20173 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20174 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20175 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20176 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20178 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20180 uint salt_len
= input_len
- 64 - 1;
20182 char *salt_buf
= input_buf
+ 64 + 1;
20184 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20186 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20188 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20190 salt
->salt_len
= salt_len
;
20193 * we can precompute the first sha256 transform
20196 uint w
[16] = { 0 };
20198 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20199 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20200 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20201 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20202 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20203 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20204 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20205 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20206 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20207 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20208 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20209 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20210 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20211 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20212 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20213 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20215 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20217 sha256_64 (w
, pc256
);
20219 salt
->salt_buf_pc
[0] = pc256
[0];
20220 salt
->salt_buf_pc
[1] = pc256
[1];
20221 salt
->salt_buf_pc
[2] = pc256
[2];
20222 salt
->salt_buf_pc
[3] = pc256
[3];
20223 salt
->salt_buf_pc
[4] = pc256
[4];
20224 salt
->salt_buf_pc
[5] = pc256
[5];
20225 salt
->salt_buf_pc
[6] = pc256
[6];
20226 salt
->salt_buf_pc
[7] = pc256
[7];
20228 digest
[0] -= pc256
[0];
20229 digest
[1] -= pc256
[1];
20230 digest
[2] -= pc256
[2];
20231 digest
[3] -= pc256
[3];
20232 digest
[4] -= pc256
[4];
20233 digest
[5] -= pc256
[5];
20234 digest
[6] -= pc256
[6];
20235 digest
[7] -= pc256
[7];
20237 return (PARSER_OK
);
20240 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20242 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20244 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20246 u32
*digest
= (u32
*) hash_buf
->digest
;
20248 salt_t
*salt
= hash_buf
->salt
;
20254 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20256 char *data_buf_pos
= strchr (data_len_pos
, '$');
20258 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20260 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20262 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20263 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20267 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20269 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20271 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20273 u32 data_len
= atoi (data_len_pos
);
20275 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20281 char *salt_pos
= data_buf_pos
;
20283 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20284 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20285 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20286 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20288 // this is actually the CT, which is also the hash later (if matched)
20290 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20291 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20292 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20293 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20295 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20297 salt
->salt_iter
= 10 - 1;
20303 digest
[0] = salt
->salt_buf
[4];
20304 digest
[1] = salt
->salt_buf
[5];
20305 digest
[2] = salt
->salt_buf
[6];
20306 digest
[3] = salt
->salt_buf
[7];
20308 return (PARSER_OK
);
20311 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20313 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20315 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20317 u32
*digest
= (u32
*) hash_buf
->digest
;
20319 salt_t
*salt
= hash_buf
->salt
;
20325 char *salt_pos
= input_buf
+ 11 + 1;
20327 char *iter_pos
= strchr (salt_pos
, ',');
20329 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20331 u32 salt_len
= iter_pos
- salt_pos
;
20333 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20337 char *hash_pos
= strchr (iter_pos
, ',');
20339 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20341 u32 iter_len
= hash_pos
- iter_pos
;
20343 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20347 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20349 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20355 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20356 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20357 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20358 salt
->salt_buf
[3] = 0x00018000;
20360 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20361 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20362 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20363 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20365 salt
->salt_len
= salt_len
/ 2;
20367 salt
->salt_iter
= atoi (iter_pos
) - 1;
20373 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20374 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20375 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20376 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20377 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20378 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20379 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20380 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20382 return (PARSER_OK
);
20385 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20387 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20389 u32
*digest
= (u32
*) hash_buf
->digest
;
20391 salt_t
*salt
= hash_buf
->salt
;
20397 char *hash_pos
= input_buf
+ 64;
20398 char *salt1_pos
= input_buf
+ 128;
20399 char *salt2_pos
= input_buf
;
20405 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20406 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20407 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20408 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20410 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20411 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20412 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20413 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20415 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20416 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20417 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20418 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20420 salt
->salt_len
= 48;
20422 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20428 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20429 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20430 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20431 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20432 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20433 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20434 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20435 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20437 return (PARSER_OK
);
20440 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20442 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20444 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20445 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20447 u32
*digest
= (u32
*) hash_buf
->digest
;
20449 salt_t
*salt
= hash_buf
->salt
;
20451 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20457 char *param0_pos
= input_buf
+ 6 + 1;
20459 char *param1_pos
= strchr (param0_pos
, '*');
20461 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20463 u32 param0_len
= param1_pos
- param0_pos
;
20467 char *param2_pos
= strchr (param1_pos
, '*');
20469 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20471 u32 param1_len
= param2_pos
- param1_pos
;
20475 char *param3_pos
= strchr (param2_pos
, '*');
20477 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20479 u32 param2_len
= param3_pos
- param2_pos
;
20483 char *param4_pos
= strchr (param3_pos
, '*');
20485 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20487 u32 param3_len
= param4_pos
- param3_pos
;
20491 char *param5_pos
= strchr (param4_pos
, '*');
20493 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20495 u32 param4_len
= param5_pos
- param4_pos
;
20499 char *param6_pos
= strchr (param5_pos
, '*');
20501 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20503 u32 param5_len
= param6_pos
- param5_pos
;
20507 char *param7_pos
= strchr (param6_pos
, '*');
20509 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20511 u32 param6_len
= param7_pos
- param6_pos
;
20515 char *param8_pos
= strchr (param7_pos
, '*');
20517 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20519 u32 param7_len
= param8_pos
- param7_pos
;
20523 const uint type
= atoi (param0_pos
);
20524 const uint mode
= atoi (param1_pos
);
20525 const uint magic
= atoi (param2_pos
);
20527 char *salt_buf
= param3_pos
;
20529 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20531 const uint compress_length
= atoi (param5_pos
);
20533 char *data_buf
= param6_pos
;
20534 char *auth
= param7_pos
;
20540 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20542 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20544 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20546 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20548 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20550 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20552 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20554 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20556 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20558 if (type
!= 0) return (PARSER_SALT_VALUE
);
20560 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20562 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20564 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20572 zip2
->magic
= magic
;
20576 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20577 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20578 zip2
->salt_buf
[2] = 0;
20579 zip2
->salt_buf
[3] = 0;
20581 zip2
->salt_len
= 8;
20583 else if (mode
== 2)
20585 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20586 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20587 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20588 zip2
->salt_buf
[3] = 0;
20590 zip2
->salt_len
= 12;
20592 else if (mode
== 3)
20594 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20595 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20596 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20597 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20599 zip2
->salt_len
= 16;
20602 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20603 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20604 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20605 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20607 zip2
->verify_bytes
= verify_bytes
;
20609 zip2
->compress_length
= compress_length
;
20611 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20613 for (uint i
= 0; i
< param6_len
; i
+= 2)
20615 const char p0
= data_buf
[i
+ 0];
20616 const char p1
= data_buf
[i
+ 1];
20618 *data_buf_ptr
++ = hex_convert (p1
) << 0
20619 | hex_convert (p0
) << 4;
20624 *data_buf_ptr
= 0x80;
20626 char *auth_ptr
= (char *) zip2
->auth_buf
;
20628 for (uint i
= 0; i
< param7_len
; i
+= 2)
20630 const char p0
= auth
[i
+ 0];
20631 const char p1
= auth
[i
+ 1];
20633 *auth_ptr
++ = hex_convert (p1
) << 0
20634 | hex_convert (p0
) << 4;
20643 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20644 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20645 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20646 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20647 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20648 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20649 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20650 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20652 salt
->salt_len
= 32;
20654 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20657 * digest buf (fake)
20660 digest
[0] = zip2
->auth_buf
[0];
20661 digest
[1] = zip2
->auth_buf
[1];
20662 digest
[2] = zip2
->auth_buf
[2];
20663 digest
[3] = zip2
->auth_buf
[3];
20665 return (PARSER_OK
);
20668 int win8phone_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20670 if ((input_len
< DISPLAY_LEN_MIN_13800
) || (input_len
> DISPLAY_LEN_MAX_13800
)) return (PARSER_GLOBAL_LENGTH
);
20672 u32
*digest
= (u32
*) hash_buf
->digest
;
20674 salt_t
*salt
= hash_buf
->salt
;
20676 win8phone_t
*esalt
= hash_buf
->esalt
;
20678 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20679 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20680 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20681 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20682 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20683 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20684 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20685 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20687 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20689 char *salt_buf_ptr
= input_buf
+ 64 + 1;
20691 u32
*salt_buf
= esalt
->salt_buf
;
20693 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
20695 salt_buf
[i
] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[j
]);
20698 salt
->salt_buf
[0] = salt_buf
[0];
20699 salt
->salt_buf
[1] = salt_buf
[1];
20700 salt
->salt_buf
[2] = salt_buf
[2];
20701 salt
->salt_buf
[3] = salt_buf
[3];
20702 salt
->salt_buf
[4] = salt_buf
[4];
20703 salt
->salt_buf
[5] = salt_buf
[5];
20704 salt
->salt_buf
[6] = salt_buf
[6];
20705 salt
->salt_buf
[7] = salt_buf
[7];
20707 salt
->salt_len
= 64;
20709 return (PARSER_OK
);
20713 * parallel running threads
20718 BOOL WINAPI
sigHandler_default (DWORD sig
)
20722 case CTRL_CLOSE_EVENT
:
20725 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20726 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20727 * function otherwise it is too late (e.g. after returning from this function)
20732 SetConsoleCtrlHandler (NULL
, TRUE
);
20739 case CTRL_LOGOFF_EVENT
:
20740 case CTRL_SHUTDOWN_EVENT
:
20744 SetConsoleCtrlHandler (NULL
, TRUE
);
20752 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20756 case CTRL_CLOSE_EVENT
:
20760 SetConsoleCtrlHandler (NULL
, TRUE
);
20767 case CTRL_LOGOFF_EVENT
:
20768 case CTRL_SHUTDOWN_EVENT
:
20772 SetConsoleCtrlHandler (NULL
, TRUE
);
20780 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20782 if (callback
== NULL
)
20784 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20788 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20794 void sigHandler_default (int sig
)
20798 signal (sig
, NULL
);
20801 void sigHandler_benchmark (int sig
)
20805 signal (sig
, NULL
);
20808 void hc_signal (void (callback
) (int))
20810 if (callback
== NULL
) callback
= SIG_DFL
;
20812 signal (SIGINT
, callback
);
20813 signal (SIGTERM
, callback
);
20814 signal (SIGABRT
, callback
);
20819 void status_display ();
20821 void *thread_keypress (void *p
)
20823 uint quiet
= data
.quiet
;
20827 while (data
.shutdown_outer
== 0)
20829 int ch
= tty_getchar();
20831 if (ch
== -1) break;
20833 if (ch
== 0) continue;
20835 //https://github.com/hashcat/hashcat/issues/302
20840 hc_thread_mutex_lock (mux_display
);
20856 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20857 if (quiet
== 0) fflush (stdout
);
20869 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20870 if (quiet
== 0) fflush (stdout
);
20882 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20883 if (quiet
== 0) fflush (stdout
);
20895 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20896 if (quiet
== 0) fflush (stdout
);
20904 stop_at_checkpoint ();
20908 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20909 if (quiet
== 0) fflush (stdout
);
20922 //https://github.com/hashcat/hashcat/issues/302
20927 hc_thread_mutex_unlock (mux_display
);
20939 bool class_num (const u8 c
)
20941 return ((c
>= '0') && (c
<= '9'));
20944 bool class_lower (const u8 c
)
20946 return ((c
>= 'a') && (c
<= 'z'));
20949 bool class_upper (const u8 c
)
20951 return ((c
>= 'A') && (c
<= 'Z'));
20954 bool class_alpha (const u8 c
)
20956 return (class_lower (c
) || class_upper (c
));
20959 int conv_ctoi (const u8 c
)
20965 else if (class_upper (c
))
20967 return c
- 'A' + 10;
20973 int conv_itoc (const u8 c
)
20981 return c
+ 'A' - 10;
20991 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20992 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20993 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20994 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20995 #define MAX_KERNEL_RULES 255
20996 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20997 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20998 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
21000 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
21001 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
21002 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
21003 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
21005 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
21010 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21012 switch (rule_buf
[rule_pos
])
21018 case RULE_OP_MANGLE_NOOP
:
21019 SET_NAME (rule
, rule_buf
[rule_pos
]);
21022 case RULE_OP_MANGLE_LREST
:
21023 SET_NAME (rule
, rule_buf
[rule_pos
]);
21026 case RULE_OP_MANGLE_UREST
:
21027 SET_NAME (rule
, rule_buf
[rule_pos
]);
21030 case RULE_OP_MANGLE_LREST_UFIRST
:
21031 SET_NAME (rule
, rule_buf
[rule_pos
]);
21034 case RULE_OP_MANGLE_UREST_LFIRST
:
21035 SET_NAME (rule
, rule_buf
[rule_pos
]);
21038 case RULE_OP_MANGLE_TREST
:
21039 SET_NAME (rule
, rule_buf
[rule_pos
]);
21042 case RULE_OP_MANGLE_TOGGLE_AT
:
21043 SET_NAME (rule
, rule_buf
[rule_pos
]);
21044 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21047 case RULE_OP_MANGLE_REVERSE
:
21048 SET_NAME (rule
, rule_buf
[rule_pos
]);
21051 case RULE_OP_MANGLE_DUPEWORD
:
21052 SET_NAME (rule
, rule_buf
[rule_pos
]);
21055 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21056 SET_NAME (rule
, rule_buf
[rule_pos
]);
21057 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21060 case RULE_OP_MANGLE_REFLECT
:
21061 SET_NAME (rule
, rule_buf
[rule_pos
]);
21064 case RULE_OP_MANGLE_ROTATE_LEFT
:
21065 SET_NAME (rule
, rule_buf
[rule_pos
]);
21068 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21069 SET_NAME (rule
, rule_buf
[rule_pos
]);
21072 case RULE_OP_MANGLE_APPEND
:
21073 SET_NAME (rule
, rule_buf
[rule_pos
]);
21074 SET_P0 (rule
, rule_buf
[rule_pos
]);
21077 case RULE_OP_MANGLE_PREPEND
:
21078 SET_NAME (rule
, rule_buf
[rule_pos
]);
21079 SET_P0 (rule
, rule_buf
[rule_pos
]);
21082 case RULE_OP_MANGLE_DELETE_FIRST
:
21083 SET_NAME (rule
, rule_buf
[rule_pos
]);
21086 case RULE_OP_MANGLE_DELETE_LAST
:
21087 SET_NAME (rule
, rule_buf
[rule_pos
]);
21090 case RULE_OP_MANGLE_DELETE_AT
:
21091 SET_NAME (rule
, rule_buf
[rule_pos
]);
21092 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21095 case RULE_OP_MANGLE_EXTRACT
:
21096 SET_NAME (rule
, rule_buf
[rule_pos
]);
21097 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21098 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21101 case RULE_OP_MANGLE_OMIT
:
21102 SET_NAME (rule
, rule_buf
[rule_pos
]);
21103 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21104 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21107 case RULE_OP_MANGLE_INSERT
:
21108 SET_NAME (rule
, rule_buf
[rule_pos
]);
21109 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21110 SET_P1 (rule
, rule_buf
[rule_pos
]);
21113 case RULE_OP_MANGLE_OVERSTRIKE
:
21114 SET_NAME (rule
, rule_buf
[rule_pos
]);
21115 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21116 SET_P1 (rule
, rule_buf
[rule_pos
]);
21119 case RULE_OP_MANGLE_TRUNCATE_AT
:
21120 SET_NAME (rule
, rule_buf
[rule_pos
]);
21121 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21124 case RULE_OP_MANGLE_REPLACE
:
21125 SET_NAME (rule
, rule_buf
[rule_pos
]);
21126 SET_P0 (rule
, rule_buf
[rule_pos
]);
21127 SET_P1 (rule
, rule_buf
[rule_pos
]);
21130 case RULE_OP_MANGLE_PURGECHAR
:
21134 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21138 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21139 SET_NAME (rule
, rule_buf
[rule_pos
]);
21140 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21143 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21144 SET_NAME (rule
, rule_buf
[rule_pos
]);
21145 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21148 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21149 SET_NAME (rule
, rule_buf
[rule_pos
]);
21152 case RULE_OP_MANGLE_SWITCH_FIRST
:
21153 SET_NAME (rule
, rule_buf
[rule_pos
]);
21156 case RULE_OP_MANGLE_SWITCH_LAST
:
21157 SET_NAME (rule
, rule_buf
[rule_pos
]);
21160 case RULE_OP_MANGLE_SWITCH_AT
:
21161 SET_NAME (rule
, rule_buf
[rule_pos
]);
21162 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21163 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21166 case RULE_OP_MANGLE_CHR_SHIFTL
:
21167 SET_NAME (rule
, rule_buf
[rule_pos
]);
21168 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21171 case RULE_OP_MANGLE_CHR_SHIFTR
:
21172 SET_NAME (rule
, rule_buf
[rule_pos
]);
21173 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21176 case RULE_OP_MANGLE_CHR_INCR
:
21177 SET_NAME (rule
, rule_buf
[rule_pos
]);
21178 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21181 case RULE_OP_MANGLE_CHR_DECR
:
21182 SET_NAME (rule
, rule_buf
[rule_pos
]);
21183 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21186 case RULE_OP_MANGLE_REPLACE_NP1
:
21187 SET_NAME (rule
, rule_buf
[rule_pos
]);
21188 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21191 case RULE_OP_MANGLE_REPLACE_NM1
:
21192 SET_NAME (rule
, rule_buf
[rule_pos
]);
21193 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21196 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21197 SET_NAME (rule
, rule_buf
[rule_pos
]);
21198 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21201 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21202 SET_NAME (rule
, rule_buf
[rule_pos
]);
21203 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21206 case RULE_OP_MANGLE_TITLE
:
21207 SET_NAME (rule
, rule_buf
[rule_pos
]);
21216 if (rule_pos
< rule_len
) return (-1);
21221 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21225 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21229 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21233 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21237 case RULE_OP_MANGLE_NOOP
:
21238 rule_buf
[rule_pos
] = rule_cmd
;
21241 case RULE_OP_MANGLE_LREST
:
21242 rule_buf
[rule_pos
] = rule_cmd
;
21245 case RULE_OP_MANGLE_UREST
:
21246 rule_buf
[rule_pos
] = rule_cmd
;
21249 case RULE_OP_MANGLE_LREST_UFIRST
:
21250 rule_buf
[rule_pos
] = rule_cmd
;
21253 case RULE_OP_MANGLE_UREST_LFIRST
:
21254 rule_buf
[rule_pos
] = rule_cmd
;
21257 case RULE_OP_MANGLE_TREST
:
21258 rule_buf
[rule_pos
] = rule_cmd
;
21261 case RULE_OP_MANGLE_TOGGLE_AT
:
21262 rule_buf
[rule_pos
] = rule_cmd
;
21263 GET_P0_CONV (rule
);
21266 case RULE_OP_MANGLE_REVERSE
:
21267 rule_buf
[rule_pos
] = rule_cmd
;
21270 case RULE_OP_MANGLE_DUPEWORD
:
21271 rule_buf
[rule_pos
] = rule_cmd
;
21274 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21275 rule_buf
[rule_pos
] = rule_cmd
;
21276 GET_P0_CONV (rule
);
21279 case RULE_OP_MANGLE_REFLECT
:
21280 rule_buf
[rule_pos
] = rule_cmd
;
21283 case RULE_OP_MANGLE_ROTATE_LEFT
:
21284 rule_buf
[rule_pos
] = rule_cmd
;
21287 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21288 rule_buf
[rule_pos
] = rule_cmd
;
21291 case RULE_OP_MANGLE_APPEND
:
21292 rule_buf
[rule_pos
] = rule_cmd
;
21296 case RULE_OP_MANGLE_PREPEND
:
21297 rule_buf
[rule_pos
] = rule_cmd
;
21301 case RULE_OP_MANGLE_DELETE_FIRST
:
21302 rule_buf
[rule_pos
] = rule_cmd
;
21305 case RULE_OP_MANGLE_DELETE_LAST
:
21306 rule_buf
[rule_pos
] = rule_cmd
;
21309 case RULE_OP_MANGLE_DELETE_AT
:
21310 rule_buf
[rule_pos
] = rule_cmd
;
21311 GET_P0_CONV (rule
);
21314 case RULE_OP_MANGLE_EXTRACT
:
21315 rule_buf
[rule_pos
] = rule_cmd
;
21316 GET_P0_CONV (rule
);
21317 GET_P1_CONV (rule
);
21320 case RULE_OP_MANGLE_OMIT
:
21321 rule_buf
[rule_pos
] = rule_cmd
;
21322 GET_P0_CONV (rule
);
21323 GET_P1_CONV (rule
);
21326 case RULE_OP_MANGLE_INSERT
:
21327 rule_buf
[rule_pos
] = rule_cmd
;
21328 GET_P0_CONV (rule
);
21332 case RULE_OP_MANGLE_OVERSTRIKE
:
21333 rule_buf
[rule_pos
] = rule_cmd
;
21334 GET_P0_CONV (rule
);
21338 case RULE_OP_MANGLE_TRUNCATE_AT
:
21339 rule_buf
[rule_pos
] = rule_cmd
;
21340 GET_P0_CONV (rule
);
21343 case RULE_OP_MANGLE_REPLACE
:
21344 rule_buf
[rule_pos
] = rule_cmd
;
21349 case RULE_OP_MANGLE_PURGECHAR
:
21353 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21357 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21358 rule_buf
[rule_pos
] = rule_cmd
;
21359 GET_P0_CONV (rule
);
21362 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21363 rule_buf
[rule_pos
] = rule_cmd
;
21364 GET_P0_CONV (rule
);
21367 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21368 rule_buf
[rule_pos
] = rule_cmd
;
21371 case RULE_OP_MANGLE_SWITCH_FIRST
:
21372 rule_buf
[rule_pos
] = rule_cmd
;
21375 case RULE_OP_MANGLE_SWITCH_LAST
:
21376 rule_buf
[rule_pos
] = rule_cmd
;
21379 case RULE_OP_MANGLE_SWITCH_AT
:
21380 rule_buf
[rule_pos
] = rule_cmd
;
21381 GET_P0_CONV (rule
);
21382 GET_P1_CONV (rule
);
21385 case RULE_OP_MANGLE_CHR_SHIFTL
:
21386 rule_buf
[rule_pos
] = rule_cmd
;
21387 GET_P0_CONV (rule
);
21390 case RULE_OP_MANGLE_CHR_SHIFTR
:
21391 rule_buf
[rule_pos
] = rule_cmd
;
21392 GET_P0_CONV (rule
);
21395 case RULE_OP_MANGLE_CHR_INCR
:
21396 rule_buf
[rule_pos
] = rule_cmd
;
21397 GET_P0_CONV (rule
);
21400 case RULE_OP_MANGLE_CHR_DECR
:
21401 rule_buf
[rule_pos
] = rule_cmd
;
21402 GET_P0_CONV (rule
);
21405 case RULE_OP_MANGLE_REPLACE_NP1
:
21406 rule_buf
[rule_pos
] = rule_cmd
;
21407 GET_P0_CONV (rule
);
21410 case RULE_OP_MANGLE_REPLACE_NM1
:
21411 rule_buf
[rule_pos
] = rule_cmd
;
21412 GET_P0_CONV (rule
);
21415 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21416 rule_buf
[rule_pos
] = rule_cmd
;
21417 GET_P0_CONV (rule
);
21420 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21421 rule_buf
[rule_pos
] = rule_cmd
;
21422 GET_P0_CONV (rule
);
21425 case RULE_OP_MANGLE_TITLE
:
21426 rule_buf
[rule_pos
] = rule_cmd
;
21430 return rule_pos
- 1;
21448 * CPU rules : this is from hashcat sources, cpu based rules
21451 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21452 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21454 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21455 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21456 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21458 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21459 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21460 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21462 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21466 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21471 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21475 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21480 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21484 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21489 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21494 for (l
= 0; l
< arr_len
; l
++)
21496 r
= arr_len
- 1 - l
;
21500 MANGLE_SWITCH (arr
, l
, r
);
21506 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21508 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21510 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21512 return (arr_len
* 2);
21515 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21517 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21519 int orig_len
= arr_len
;
21523 for (i
= 0; i
< times
; i
++)
21525 memcpy (&arr
[arr_len
], arr
, orig_len
);
21527 arr_len
+= orig_len
;
21533 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21535 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21537 mangle_double (arr
, arr_len
);
21539 mangle_reverse (arr
+ arr_len
, arr_len
);
21541 return (arr_len
* 2);
21544 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21549 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21551 MANGLE_SWITCH (arr
, l
, r
);
21557 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21562 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21564 MANGLE_SWITCH (arr
, l
, r
);
21570 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21572 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21576 return (arr_len
+ 1);
21579 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21581 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21585 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21587 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21592 return (arr_len
+ 1);
21595 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21597 if (upos
>= arr_len
) return (arr_len
);
21601 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21603 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21606 return (arr_len
- 1);
21609 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21611 if (upos
>= arr_len
) return (arr_len
);
21613 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21617 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21619 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21625 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21627 if (upos
>= arr_len
) return (arr_len
);
21629 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21633 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21635 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21638 return (arr_len
- ulen
);
21641 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21643 if (upos
>= arr_len
) return (arr_len
);
21645 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21649 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21651 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21656 return (arr_len
+ 1);
21659 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
)
21661 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21663 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21665 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21667 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21669 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21671 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21673 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21675 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21677 return (arr_len
+ arr2_cpy
);
21680 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21682 if (upos
>= arr_len
) return (arr_len
);
21689 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21691 if (upos
>= arr_len
) return (arr_len
);
21693 memset (arr
+ upos
, 0, arr_len
- upos
);
21698 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21702 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21704 if (arr
[arr_pos
] != oldc
) continue;
21706 arr
[arr_pos
] = newc
;
21712 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21718 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21720 if (arr
[arr_pos
] == c
) continue;
21722 arr
[ret_len
] = arr
[arr_pos
];
21730 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21732 if (ulen
> arr_len
) return (arr_len
);
21734 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21736 char cs
[100] = { 0 };
21738 memcpy (cs
, arr
, ulen
);
21742 for (i
= 0; i
< ulen
; i
++)
21746 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21752 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21754 if (ulen
> arr_len
) return (arr_len
);
21756 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21758 int upos
= arr_len
- ulen
;
21762 for (i
= 0; i
< ulen
; i
++)
21764 char c
= arr
[upos
+ i
];
21766 arr_len
= mangle_append (arr
, arr_len
, c
);
21772 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21774 if ( arr_len
== 0) return (arr_len
);
21775 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21777 char c
= arr
[upos
];
21781 for (i
= 0; i
< ulen
; i
++)
21783 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21789 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21791 if ( arr_len
== 0) return (arr_len
);
21792 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21796 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21798 int new_pos
= arr_pos
* 2;
21800 arr
[new_pos
] = arr
[arr_pos
];
21802 arr
[new_pos
+ 1] = arr
[arr_pos
];
21805 return (arr_len
* 2);
21808 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21810 if (upos
>= arr_len
) return (arr_len
);
21811 if (upos2
>= arr_len
) return (arr_len
);
21813 MANGLE_SWITCH (arr
, upos
, upos2
);
21818 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21820 MANGLE_SWITCH (arr
, upos
, upos2
);
21825 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21827 if (upos
>= arr_len
) return (arr_len
);
21834 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21836 if (upos
>= arr_len
) return (arr_len
);
21843 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21845 if (upos
>= arr_len
) return (arr_len
);
21852 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21854 if (upos
>= arr_len
) return (arr_len
);
21861 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21863 int upper_next
= 1;
21867 for (pos
= 0; pos
< arr_len
; pos
++)
21869 if (arr
[pos
] == ' ')
21880 MANGLE_UPPER_AT (arr
, pos
);
21884 MANGLE_LOWER_AT (arr
, pos
);
21891 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21893 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21899 for (j
= 0; j
< rp_gen_num
; j
++)
21906 switch ((char) get_random_num (0, 9))
21909 r
= get_random_num (0, sizeof (grp_op_nop
));
21910 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21914 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21915 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21916 p1
= get_random_num (0, sizeof (grp_pos
));
21917 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21921 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21922 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21923 p1
= get_random_num (1, 6);
21924 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21928 r
= get_random_num (0, sizeof (grp_op_chr
));
21929 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21930 p1
= get_random_num (0x20, 0x7e);
21931 rule_buf
[rule_pos
++] = (char) p1
;
21935 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21936 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21937 p1
= get_random_num (0x20, 0x7e);
21938 rule_buf
[rule_pos
++] = (char) p1
;
21939 p2
= get_random_num (0x20, 0x7e);
21941 p2
= get_random_num (0x20, 0x7e);
21942 rule_buf
[rule_pos
++] = (char) p2
;
21946 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21947 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21948 p1
= get_random_num (0, sizeof (grp_pos
));
21949 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21950 p2
= get_random_num (0x20, 0x7e);
21951 rule_buf
[rule_pos
++] = (char) p2
;
21955 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21956 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21957 p1
= get_random_num (0, sizeof (grp_pos
));
21958 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21959 p2
= get_random_num (0, sizeof (grp_pos
));
21961 p2
= get_random_num (0, sizeof (grp_pos
));
21962 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21966 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21967 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21968 p1
= get_random_num (0, sizeof (grp_pos
));
21969 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21970 p2
= get_random_num (1, sizeof (grp_pos
));
21972 p2
= get_random_num (1, sizeof (grp_pos
));
21973 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21977 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21978 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[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
));
21982 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21983 p3
= get_random_num (0, sizeof (grp_pos
));
21984 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21992 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21994 char mem
[BLOCK_SIZE
] = { 0 };
21996 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21998 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
22000 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22002 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
22004 int out_len
= in_len
;
22005 int mem_len
= in_len
;
22007 memcpy (out
, in
, out_len
);
22011 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
22016 switch (rule
[rule_pos
])
22021 case RULE_OP_MANGLE_NOOP
:
22024 case RULE_OP_MANGLE_LREST
:
22025 out_len
= mangle_lrest (out
, out_len
);
22028 case RULE_OP_MANGLE_UREST
:
22029 out_len
= mangle_urest (out
, out_len
);
22032 case RULE_OP_MANGLE_LREST_UFIRST
:
22033 out_len
= mangle_lrest (out
, out_len
);
22034 if (out_len
) MANGLE_UPPER_AT (out
, 0);
22037 case RULE_OP_MANGLE_UREST_LFIRST
:
22038 out_len
= mangle_urest (out
, out_len
);
22039 if (out_len
) MANGLE_LOWER_AT (out
, 0);
22042 case RULE_OP_MANGLE_TREST
:
22043 out_len
= mangle_trest (out
, out_len
);
22046 case RULE_OP_MANGLE_TOGGLE_AT
:
22047 NEXT_RULEPOS (rule_pos
);
22048 NEXT_RPTOI (rule
, rule_pos
, upos
);
22049 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
22052 case RULE_OP_MANGLE_REVERSE
:
22053 out_len
= mangle_reverse (out
, out_len
);
22056 case RULE_OP_MANGLE_DUPEWORD
:
22057 out_len
= mangle_double (out
, out_len
);
22060 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
22061 NEXT_RULEPOS (rule_pos
);
22062 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22063 out_len
= mangle_double_times (out
, out_len
, ulen
);
22066 case RULE_OP_MANGLE_REFLECT
:
22067 out_len
= mangle_reflect (out
, out_len
);
22070 case RULE_OP_MANGLE_ROTATE_LEFT
:
22071 mangle_rotate_left (out
, out_len
);
22074 case RULE_OP_MANGLE_ROTATE_RIGHT
:
22075 mangle_rotate_right (out
, out_len
);
22078 case RULE_OP_MANGLE_APPEND
:
22079 NEXT_RULEPOS (rule_pos
);
22080 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
22083 case RULE_OP_MANGLE_PREPEND
:
22084 NEXT_RULEPOS (rule_pos
);
22085 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
22088 case RULE_OP_MANGLE_DELETE_FIRST
:
22089 out_len
= mangle_delete_at (out
, out_len
, 0);
22092 case RULE_OP_MANGLE_DELETE_LAST
:
22093 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
22096 case RULE_OP_MANGLE_DELETE_AT
:
22097 NEXT_RULEPOS (rule_pos
);
22098 NEXT_RPTOI (rule
, rule_pos
, upos
);
22099 out_len
= mangle_delete_at (out
, out_len
, upos
);
22102 case RULE_OP_MANGLE_EXTRACT
:
22103 NEXT_RULEPOS (rule_pos
);
22104 NEXT_RPTOI (rule
, rule_pos
, upos
);
22105 NEXT_RULEPOS (rule_pos
);
22106 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22107 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
22110 case RULE_OP_MANGLE_OMIT
:
22111 NEXT_RULEPOS (rule_pos
);
22112 NEXT_RPTOI (rule
, rule_pos
, upos
);
22113 NEXT_RULEPOS (rule_pos
);
22114 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22115 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
22118 case RULE_OP_MANGLE_INSERT
:
22119 NEXT_RULEPOS (rule_pos
);
22120 NEXT_RPTOI (rule
, rule_pos
, upos
);
22121 NEXT_RULEPOS (rule_pos
);
22122 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22125 case RULE_OP_MANGLE_OVERSTRIKE
:
22126 NEXT_RULEPOS (rule_pos
);
22127 NEXT_RPTOI (rule
, rule_pos
, upos
);
22128 NEXT_RULEPOS (rule_pos
);
22129 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22132 case RULE_OP_MANGLE_TRUNCATE_AT
:
22133 NEXT_RULEPOS (rule_pos
);
22134 NEXT_RPTOI (rule
, rule_pos
, upos
);
22135 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22138 case RULE_OP_MANGLE_REPLACE
:
22139 NEXT_RULEPOS (rule_pos
);
22140 NEXT_RULEPOS (rule_pos
);
22141 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22144 case RULE_OP_MANGLE_PURGECHAR
:
22145 NEXT_RULEPOS (rule_pos
);
22146 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22149 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22153 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22154 NEXT_RULEPOS (rule_pos
);
22155 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22156 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22159 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22160 NEXT_RULEPOS (rule_pos
);
22161 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22162 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22165 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22166 out_len
= mangle_dupechar (out
, out_len
);
22169 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22170 NEXT_RULEPOS (rule_pos
);
22171 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22172 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22175 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22176 NEXT_RULEPOS (rule_pos
);
22177 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22178 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22181 case RULE_OP_MANGLE_SWITCH_FIRST
:
22182 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22185 case RULE_OP_MANGLE_SWITCH_LAST
:
22186 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22189 case RULE_OP_MANGLE_SWITCH_AT
:
22190 NEXT_RULEPOS (rule_pos
);
22191 NEXT_RPTOI (rule
, rule_pos
, upos
);
22192 NEXT_RULEPOS (rule_pos
);
22193 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22194 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22197 case RULE_OP_MANGLE_CHR_SHIFTL
:
22198 NEXT_RULEPOS (rule_pos
);
22199 NEXT_RPTOI (rule
, rule_pos
, upos
);
22200 mangle_chr_shiftl (out
, out_len
, upos
);
22203 case RULE_OP_MANGLE_CHR_SHIFTR
:
22204 NEXT_RULEPOS (rule_pos
);
22205 NEXT_RPTOI (rule
, rule_pos
, upos
);
22206 mangle_chr_shiftr (out
, out_len
, upos
);
22209 case RULE_OP_MANGLE_CHR_INCR
:
22210 NEXT_RULEPOS (rule_pos
);
22211 NEXT_RPTOI (rule
, rule_pos
, upos
);
22212 mangle_chr_incr (out
, out_len
, upos
);
22215 case RULE_OP_MANGLE_CHR_DECR
:
22216 NEXT_RULEPOS (rule_pos
);
22217 NEXT_RPTOI (rule
, rule_pos
, upos
);
22218 mangle_chr_decr (out
, out_len
, upos
);
22221 case RULE_OP_MANGLE_REPLACE_NP1
:
22222 NEXT_RULEPOS (rule_pos
);
22223 NEXT_RPTOI (rule
, rule_pos
, upos
);
22224 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22227 case RULE_OP_MANGLE_REPLACE_NM1
:
22228 NEXT_RULEPOS (rule_pos
);
22229 NEXT_RPTOI (rule
, rule_pos
, upos
);
22230 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22233 case RULE_OP_MANGLE_TITLE
:
22234 out_len
= mangle_title (out
, out_len
);
22237 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22238 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22239 NEXT_RULEPOS (rule_pos
);
22240 NEXT_RPTOI (rule
, rule_pos
, upos
);
22241 NEXT_RULEPOS (rule_pos
);
22242 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22243 NEXT_RULEPOS (rule_pos
);
22244 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22245 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22248 case RULE_OP_MANGLE_APPEND_MEMORY
:
22249 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22250 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22251 memcpy (out
+ out_len
, mem
, mem_len
);
22252 out_len
+= mem_len
;
22255 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22256 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22257 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22258 memcpy (mem
+ mem_len
, out
, out_len
);
22259 out_len
+= mem_len
;
22260 memcpy (out
, mem
, out_len
);
22263 case RULE_OP_MEMORIZE_WORD
:
22264 memcpy (mem
, out
, out_len
);
22268 case RULE_OP_REJECT_LESS
:
22269 NEXT_RULEPOS (rule_pos
);
22270 NEXT_RPTOI (rule
, rule_pos
, upos
);
22271 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22274 case RULE_OP_REJECT_GREATER
:
22275 NEXT_RULEPOS (rule_pos
);
22276 NEXT_RPTOI (rule
, rule_pos
, upos
);
22277 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22280 case RULE_OP_REJECT_CONTAIN
:
22281 NEXT_RULEPOS (rule_pos
);
22282 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22285 case RULE_OP_REJECT_NOT_CONTAIN
:
22286 NEXT_RULEPOS (rule_pos
);
22287 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22290 case RULE_OP_REJECT_EQUAL_FIRST
:
22291 NEXT_RULEPOS (rule_pos
);
22292 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22295 case RULE_OP_REJECT_EQUAL_LAST
:
22296 NEXT_RULEPOS (rule_pos
);
22297 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22300 case RULE_OP_REJECT_EQUAL_AT
:
22301 NEXT_RULEPOS (rule_pos
);
22302 NEXT_RPTOI (rule
, rule_pos
, upos
);
22303 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22304 NEXT_RULEPOS (rule_pos
);
22305 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22308 case RULE_OP_REJECT_CONTAINS
:
22309 NEXT_RULEPOS (rule_pos
);
22310 NEXT_RPTOI (rule
, rule_pos
, upos
);
22311 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22312 NEXT_RULEPOS (rule_pos
);
22313 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22314 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22317 case RULE_OP_REJECT_MEMORY
:
22318 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22322 return (RULE_RC_SYNTAX_ERROR
);
22327 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);