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
);
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 size_t size
= sizeof(exec_path
);
4391 const int len
= sysctl(mib
, 4, exec_path
, &size
, NULL
, 0);
4394 #error Your Operating System is not supported or detected
4402 char *get_install_dir (const char *progname
)
4404 char *install_dir
= mystrdup (progname
);
4405 char *last_slash
= NULL
;
4407 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4411 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4417 install_dir
[0] = '.';
4421 return (install_dir
);
4424 char *get_profile_dir (const char *homedir
)
4426 #define DOT_HASHCAT ".hashcat"
4428 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4430 char *profile_dir
= (char *) mymalloc (len
+ 1);
4432 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4437 char *get_session_dir (const char *profile_dir
)
4439 #define SESSIONS_FOLDER "sessions"
4441 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4443 char *session_dir
= (char *) mymalloc (len
+ 1);
4445 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4450 uint
count_lines (FILE *fd
)
4454 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4460 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4462 if (nread
< 1) continue;
4466 for (i
= 0; i
< nread
; i
++)
4468 if (prev
== '\n') cnt
++;
4479 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4483 FILE *fd
= fopen (filename
, "rb");
4487 log_error ("%s: %s", filename
, strerror (errno
));
4492 #define MAX_KEY_SIZE (1024 * 1024)
4494 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4496 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4502 for (int fpos
= 0; fpos
< nread
; fpos
++)
4504 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4506 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4507 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4508 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4509 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4511 if (kpos
>= 64) kpos
= 0;
4518 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4522 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4523 if (CPU_ISSET(core
, cpu_set
)) break;
4525 thread_affinity_policy_data_t policy
= { core
};
4527 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4529 if (data
.quiet
== 0)
4531 if (rc
!= KERN_SUCCESS
)
4533 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4541 void set_cpu_affinity (char *cpu_affinity
)
4544 DWORD_PTR aff_mask
= 0;
4555 char *devices
= strdup (cpu_affinity
);
4557 char *next
= strtok (devices
, ",");
4561 uint cpu_id
= atoi (next
);
4576 log_error ("ERROR: Invalid cpu_id %u specified", cpu_id
);
4582 aff_mask
|= 1 << (cpu_id
- 1);
4584 CPU_SET ((cpu_id
- 1), &cpuset
);
4587 } while ((next
= strtok (NULL
, ",")) != NULL
);
4593 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4594 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4596 pthread_t thread
= pthread_self ();
4597 pthread_setaffinity_np (thread
, sizeof (cpuset_t
), &cpuset
);
4599 pthread_t thread
= pthread_self ();
4600 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4604 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4606 char *element
, *end
;
4608 end
= (char *) base
+ nmemb
* size
;
4610 for (element
= (char *) base
; element
< end
; element
+= size
)
4611 if (!compar (element
, key
))
4617 int sort_by_u32 (const void *v1
, const void *v2
)
4619 const u32
*s1
= (const u32
*) v1
;
4620 const u32
*s2
= (const u32
*) v2
;
4625 int sort_by_salt (const void *v1
, const void *v2
)
4627 const salt_t
*s1
= (const salt_t
*) v1
;
4628 const salt_t
*s2
= (const salt_t
*) v2
;
4630 const int res1
= s1
->salt_len
- s2
->salt_len
;
4632 if (res1
!= 0) return (res1
);
4634 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4636 if (res2
!= 0) return (res2
);
4644 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4645 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4652 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4653 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4659 int sort_by_salt_buf (const void *v1
, const void *v2
)
4661 const pot_t
*p1
= (const pot_t
*) v1
;
4662 const pot_t
*p2
= (const pot_t
*) v2
;
4664 const hash_t
*h1
= &p1
->hash
;
4665 const hash_t
*h2
= &p2
->hash
;
4667 const salt_t
*s1
= h1
->salt
;
4668 const salt_t
*s2
= h2
->salt
;
4674 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4675 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4681 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4683 const hash_t
*h1
= (const hash_t
*) v1
;
4684 const hash_t
*h2
= (const hash_t
*) v2
;
4686 const salt_t
*s1
= h1
->salt
;
4687 const salt_t
*s2
= h2
->salt
;
4689 // testphase: this should work
4694 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4695 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4698 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4699 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4700 if (s1->salt_len > s2->salt_len) return ( 1);
4701 if (s1->salt_len < s2->salt_len) return (-1);
4703 uint n = s1->salt_len;
4707 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4708 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4715 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4717 const hash_t
*h1
= (const hash_t
*) v1
;
4718 const hash_t
*h2
= (const hash_t
*) v2
;
4720 const salt_t
*s1
= h1
->salt
;
4721 const salt_t
*s2
= h2
->salt
;
4723 // 16 - 2 (since last 2 uints contain the digest)
4728 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4729 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4735 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4737 const hash_t
*h1
= (const hash_t
*) v1
;
4738 const hash_t
*h2
= (const hash_t
*) v2
;
4740 const void *d1
= h1
->digest
;
4741 const void *d2
= h2
->digest
;
4743 return data
.sort_by_digest (d1
, d2
);
4746 int sort_by_hash (const void *v1
, const void *v2
)
4748 const hash_t
*h1
= (const hash_t
*) v1
;
4749 const hash_t
*h2
= (const hash_t
*) v2
;
4753 const salt_t
*s1
= h1
->salt
;
4754 const salt_t
*s2
= h2
->salt
;
4756 int res
= sort_by_salt (s1
, s2
);
4758 if (res
!= 0) return (res
);
4761 const void *d1
= h1
->digest
;
4762 const void *d2
= h2
->digest
;
4764 return data
.sort_by_digest (d1
, d2
);
4767 int sort_by_pot (const void *v1
, const void *v2
)
4769 const pot_t
*p1
= (const pot_t
*) v1
;
4770 const pot_t
*p2
= (const pot_t
*) v2
;
4772 const hash_t
*h1
= &p1
->hash
;
4773 const hash_t
*h2
= &p2
->hash
;
4775 return sort_by_hash (h1
, h2
);
4778 int sort_by_mtime (const void *p1
, const void *p2
)
4780 const char **f1
= (const char **) p1
;
4781 const char **f2
= (const char **) p2
;
4783 struct stat s1
; stat (*f1
, &s1
);
4784 struct stat s2
; stat (*f2
, &s2
);
4786 return s2
.st_mtime
- s1
.st_mtime
;
4789 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4791 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4792 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4794 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4797 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4799 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4800 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4802 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4805 int sort_by_stringptr (const void *p1
, const void *p2
)
4807 const char **s1
= (const char **) p1
;
4808 const char **s2
= (const char **) p2
;
4810 return strcmp (*s1
, *s2
);
4813 int sort_by_dictstat (const void *s1
, const void *s2
)
4815 dictstat_t
*d1
= (dictstat_t
*) s1
;
4816 dictstat_t
*d2
= (dictstat_t
*) s2
;
4819 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4821 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4824 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4827 int sort_by_bitmap (const void *p1
, const void *p2
)
4829 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4830 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4832 return b1
->collisions
- b2
->collisions
;
4835 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4837 const u32
*d1
= (const u32
*) v1
;
4838 const u32
*d2
= (const u32
*) v2
;
4844 if (d1
[n
] > d2
[n
]) return ( 1);
4845 if (d1
[n
] < d2
[n
]) return (-1);
4851 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4853 const u32
*d1
= (const u32
*) v1
;
4854 const u32
*d2
= (const u32
*) v2
;
4860 if (d1
[n
] > d2
[n
]) return ( 1);
4861 if (d1
[n
] < d2
[n
]) return (-1);
4867 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4869 const u32
*d1
= (const u32
*) v1
;
4870 const u32
*d2
= (const u32
*) v2
;
4876 if (d1
[n
] > d2
[n
]) return ( 1);
4877 if (d1
[n
] < d2
[n
]) return (-1);
4883 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4885 const u32
*d1
= (const u32
*) v1
;
4886 const u32
*d2
= (const u32
*) v2
;
4892 if (d1
[n
] > d2
[n
]) return ( 1);
4893 if (d1
[n
] < d2
[n
]) return (-1);
4899 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4901 const u32
*d1
= (const u32
*) v1
;
4902 const u32
*d2
= (const u32
*) v2
;
4908 if (d1
[n
] > d2
[n
]) return ( 1);
4909 if (d1
[n
] < d2
[n
]) return (-1);
4915 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4917 const u32
*d1
= (const u32
*) v1
;
4918 const u32
*d2
= (const u32
*) v2
;
4924 if (d1
[n
] > d2
[n
]) return ( 1);
4925 if (d1
[n
] < d2
[n
]) return (-1);
4931 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4933 const u32
*d1
= (const u32
*) v1
;
4934 const u32
*d2
= (const u32
*) v2
;
4940 if (d1
[n
] > d2
[n
]) return ( 1);
4941 if (d1
[n
] < d2
[n
]) return (-1);
4947 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4949 const u32
*d1
= (const u32
*) v1
;
4950 const u32
*d2
= (const u32
*) v2
;
4956 if (d1
[n
] > d2
[n
]) return ( 1);
4957 if (d1
[n
] < d2
[n
]) return (-1);
4963 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4965 const u64
*d1
= (const u64
*) v1
;
4966 const u64
*d2
= (const u64
*) v2
;
4972 if (d1
[n
] > d2
[n
]) return ( 1);
4973 if (d1
[n
] < d2
[n
]) return (-1);
4979 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4981 const u64
*d1
= (const u64
*) v1
;
4982 const u64
*d2
= (const u64
*) v2
;
4988 if (d1
[n
] > d2
[n
]) return ( 1);
4989 if (d1
[n
] < d2
[n
]) return (-1);
4995 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4997 const u64
*d1
= (const u64
*) v1
;
4998 const u64
*d2
= (const u64
*) v2
;
5004 if (d1
[n
] > d2
[n
]) return ( 1);
5005 if (d1
[n
] < d2
[n
]) return (-1);
5011 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
5013 const u32
*d1
= (const u32
*) v1
;
5014 const u32
*d2
= (const u32
*) v2
;
5016 const uint dgst_pos0
= data
.dgst_pos0
;
5017 const uint dgst_pos1
= data
.dgst_pos1
;
5018 const uint dgst_pos2
= data
.dgst_pos2
;
5019 const uint dgst_pos3
= data
.dgst_pos3
;
5021 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
5022 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
5023 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
5024 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
5025 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
5026 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
5027 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
5028 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
5033 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
5035 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
5036 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
5038 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
5040 if (res1
!= 0) return (res1
);
5045 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
5047 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
5048 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
5050 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
5052 if (res1
!= 0) return (res1
);
5054 const int res2
= t1
->attack_mode
5057 if (res2
!= 0) return (res2
);
5059 const int res3
= t1
->hash_type
5062 if (res3
!= 0) return (res3
);
5067 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
)
5069 uint outfile_autohex
= data
.outfile_autohex
;
5071 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
5073 FILE *debug_fp
= NULL
;
5075 if (debug_file
!= NULL
)
5077 debug_fp
= fopen (debug_file
, "ab");
5079 lock_file (debug_fp
);
5086 if (debug_fp
== NULL
)
5088 log_info ("WARNING: Could not open debug-file for writing");
5092 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
5094 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
5096 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
5099 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
5101 if (debug_mode
== 4)
5103 fputc (':', debug_fp
);
5105 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5108 fputc ('\n', debug_fp
);
5110 if (debug_file
!= NULL
) fclose (debug_fp
);
5114 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5116 int needs_hexify
= 0;
5118 if (outfile_autohex
== 1)
5120 for (uint i
= 0; i
< plain_len
; i
++)
5122 if (plain_ptr
[i
] < 0x20)
5129 if (plain_ptr
[i
] > 0x7f)
5138 if (needs_hexify
== 1)
5140 fprintf (fp
, "$HEX[");
5142 for (uint i
= 0; i
< plain_len
; i
++)
5144 fprintf (fp
, "%02x", plain_ptr
[i
]);
5151 fwrite (plain_ptr
, plain_len
, 1, fp
);
5155 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
)
5157 uint outfile_format
= data
.outfile_format
;
5159 char separator
= data
.separator
;
5161 if (outfile_format
& OUTFILE_FMT_HASH
)
5163 fprintf (out_fp
, "%s", out_buf
);
5165 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5167 fputc (separator
, out_fp
);
5170 else if (data
.username
)
5172 if (username
!= NULL
)
5174 for (uint i
= 0; i
< user_len
; i
++)
5176 fprintf (out_fp
, "%c", username
[i
]);
5179 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5181 fputc (separator
, out_fp
);
5186 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5188 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5190 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5192 fputc (separator
, out_fp
);
5196 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5198 for (uint i
= 0; i
< plain_len
; i
++)
5200 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5203 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5205 fputc (separator
, out_fp
);
5209 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5212 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5217 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5219 fprintf (out_fp
, "%llu", crackpos
);
5224 fputc ('\n', out_fp
);
5227 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
)
5231 pot_key
.hash
.salt
= hashes_buf
->salt
;
5232 pot_key
.hash
.digest
= hashes_buf
->digest
;
5234 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5240 input_buf
[input_len
] = 0;
5243 unsigned char *username
= NULL
;
5248 user_t
*user
= hashes_buf
->hash_info
->user
;
5252 username
= (unsigned char *) (user
->user_name
);
5254 user_len
= user
->user_len
;
5258 // do output the line
5259 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5263 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5264 #define LM_MASKED_PLAIN "[notfound]"
5266 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
)
5272 pot_left_key
.hash
.salt
= hash_left
->salt
;
5273 pot_left_key
.hash
.digest
= hash_left
->digest
;
5275 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5279 uint weak_hash_found
= 0;
5281 pot_t pot_right_key
;
5283 pot_right_key
.hash
.salt
= hash_right
->salt
;
5284 pot_right_key
.hash
.digest
= hash_right
->digest
;
5286 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5288 if (pot_right_ptr
== NULL
)
5290 // special case, if "weak hash"
5292 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5294 weak_hash_found
= 1;
5296 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5298 // in theory this is not needed, but we are paranoia:
5300 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5301 pot_right_ptr
->plain_len
= 0;
5305 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5307 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
5312 // at least one half was found:
5316 input_buf
[input_len
] = 0;
5320 unsigned char *username
= NULL
;
5325 user_t
*user
= hash_left
->hash_info
->user
;
5329 username
= (unsigned char *) (user
->user_name
);
5331 user_len
= user
->user_len
;
5335 // mask the part which was not found
5337 uint left_part_masked
= 0;
5338 uint right_part_masked
= 0;
5340 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5342 if (pot_left_ptr
== NULL
)
5344 left_part_masked
= 1;
5346 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5348 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5350 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5351 pot_left_ptr
->plain_len
= mask_plain_len
;
5354 if (pot_right_ptr
== NULL
)
5356 right_part_masked
= 1;
5358 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5360 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5362 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5363 pot_right_ptr
->plain_len
= mask_plain_len
;
5366 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5370 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5372 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5374 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5376 // do output the line
5378 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5380 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5382 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5383 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5386 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
)
5390 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5392 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5394 if (pot_ptr
== NULL
)
5398 input_buf
[input_len
] = 0;
5400 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5404 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
)
5410 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5412 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5416 pot_t pot_right_key
;
5418 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5420 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5422 uint weak_hash_found
= 0;
5424 if (pot_right_ptr
== NULL
)
5426 // special case, if "weak hash"
5428 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5430 weak_hash_found
= 1;
5432 // we just need that pot_right_ptr is not a NULL pointer
5434 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5438 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5440 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5445 // ... at least one part was not cracked
5449 input_buf
[input_len
] = 0;
5451 // only show the hash part which is still not cracked
5453 uint user_len
= input_len
- 32;
5455 char *hash_output
= (char *) mymalloc (33);
5457 memcpy (hash_output
, input_buf
, input_len
);
5459 if (pot_left_ptr
!= NULL
)
5461 // only show right part (because left part was already found)
5463 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5465 hash_output
[user_len
+ 16] = 0;
5468 if (pot_right_ptr
!= NULL
)
5470 // only show left part (because right part was already found)
5472 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5474 hash_output
[user_len
+ 16] = 0;
5477 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5479 myfree (hash_output
);
5481 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5484 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5486 uint opencl_platforms_filter
= 0;
5488 if (opencl_platforms
)
5490 char *platforms
= strdup (opencl_platforms
);
5492 char *next
= strtok (platforms
, ",");
5496 int platform
= atoi (next
);
5498 if (platform
< 1 || platform
> 32)
5500 log_error ("ERROR: Invalid OpenCL platform %u specified", platform
);
5505 opencl_platforms_filter
|= 1 << (platform
- 1);
5507 } while ((next
= strtok (NULL
, ",")) != NULL
);
5513 opencl_platforms_filter
= -1;
5516 return opencl_platforms_filter
;
5519 u32
setup_devices_filter (char *opencl_devices
)
5521 u32 devices_filter
= 0;
5525 char *devices
= strdup (opencl_devices
);
5527 char *next
= strtok (devices
, ",");
5531 int device_id
= atoi (next
);
5533 if (device_id
< 1 || device_id
> 32)
5535 log_error ("ERROR: Invalid device_id %u specified", device_id
);
5540 devices_filter
|= 1 << (device_id
- 1);
5542 } while ((next
= strtok (NULL
, ",")) != NULL
);
5548 devices_filter
= -1;
5551 return devices_filter
;
5554 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5556 cl_device_type device_types_filter
= 0;
5558 if (opencl_device_types
)
5560 char *device_types
= strdup (opencl_device_types
);
5562 char *next
= strtok (device_types
, ",");
5566 int device_type
= atoi (next
);
5568 if (device_type
< 1 || device_type
> 3)
5570 log_error ("ERROR: Invalid device_type %u specified", device_type
);
5575 device_types_filter
|= 1 << device_type
;
5577 } while ((next
= strtok (NULL
, ",")) != NULL
);
5579 free (device_types
);
5583 // Do not use CPU by default, this often reduces GPU performance because
5584 // the CPU is too busy to handle GPU synchronization
5586 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5589 return device_types_filter
;
5592 u32
get_random_num (const u32 min
, const u32 max
)
5594 if (min
== max
) return (min
);
5596 return ((rand () % (max
- min
)) + min
);
5599 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5601 u32 quotient
= dividend
/ divisor
;
5603 if (dividend
% divisor
) quotient
++;
5608 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5610 u64 quotient
= dividend
/ divisor
;
5612 if (dividend
% divisor
) quotient
++;
5617 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5619 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5620 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5622 if (tm
->tm_year
- 70)
5624 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5625 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5627 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5629 else if (tm
->tm_yday
)
5631 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5632 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5634 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5636 else if (tm
->tm_hour
)
5638 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5639 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5641 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5643 else if (tm
->tm_min
)
5645 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5646 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5648 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5652 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5654 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5658 void format_speed_display (float val
, char *buf
, size_t len
)
5669 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5680 /* generate output */
5684 snprintf (buf
, len
- 1, "%.0f ", val
);
5688 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5692 void lowercase (u8
*buf
, int len
)
5694 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5697 void uppercase (u8
*buf
, int len
)
5699 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5702 int fgetl (FILE *fp
, char *line_buf
)
5708 const int c
= fgetc (fp
);
5710 if (c
== EOF
) break;
5712 line_buf
[line_len
] = (char) c
;
5716 if (line_len
== HCBUFSIZ
) line_len
--;
5718 if (c
== '\n') break;
5721 if (line_len
== 0) return 0;
5723 if (line_buf
[line_len
- 1] == '\n')
5727 line_buf
[line_len
] = 0;
5730 if (line_len
== 0) return 0;
5732 if (line_buf
[line_len
- 1] == '\r')
5736 line_buf
[line_len
] = 0;
5742 int in_superchop (char *buf
)
5744 int len
= strlen (buf
);
5748 if (buf
[len
- 1] == '\n')
5755 if (buf
[len
- 1] == '\r')
5770 char **scan_directory (const char *path
)
5772 char *tmp_path
= mystrdup (path
);
5774 size_t tmp_path_len
= strlen (tmp_path
);
5776 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5778 tmp_path
[tmp_path_len
- 1] = 0;
5780 tmp_path_len
= strlen (tmp_path
);
5783 char **files
= NULL
;
5789 if ((d
= opendir (tmp_path
)) != NULL
)
5795 memset (&e
, 0, sizeof (e
));
5796 struct dirent
*de
= NULL
;
5798 if (readdir_r (d
, &e
, &de
) != 0)
5800 log_error ("ERROR: readdir_r() failed");
5805 if (de
== NULL
) break;
5809 while ((de
= readdir (d
)) != NULL
)
5812 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5814 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5816 char *path_file
= (char *) mymalloc (path_size
+ 1);
5818 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5820 path_file
[path_size
] = 0;
5824 if ((d_test
= opendir (path_file
)) != NULL
)
5832 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5836 files
[num_files
- 1] = path_file
;
5842 else if (errno
== ENOTDIR
)
5844 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5848 files
[num_files
- 1] = mystrdup (path
);
5851 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5855 files
[num_files
- 1] = NULL
;
5862 int count_dictionaries (char **dictionary_files
)
5864 if (dictionary_files
== NULL
) return 0;
5868 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5876 char *stroptitype (const uint opti_type
)
5880 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5881 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5882 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5883 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5884 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5885 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5886 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5887 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5888 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5889 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5890 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5891 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5892 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5893 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5894 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5895 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5896 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5897 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5898 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5904 char *strparser (const uint parser_status
)
5906 switch (parser_status
)
5908 case PARSER_OK
: return ((char *) PA_000
); break;
5909 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5910 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5911 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5912 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5913 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5914 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5915 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5916 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5917 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5918 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5919 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5920 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5921 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5922 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5923 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5924 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5927 return ((char *) PA_255
);
5930 char *strhashtype (const uint hash_mode
)
5934 case 0: return ((char *) HT_00000
); break;
5935 case 10: return ((char *) HT_00010
); break;
5936 case 11: return ((char *) HT_00011
); break;
5937 case 12: return ((char *) HT_00012
); break;
5938 case 20: return ((char *) HT_00020
); break;
5939 case 21: return ((char *) HT_00021
); break;
5940 case 22: return ((char *) HT_00022
); break;
5941 case 23: return ((char *) HT_00023
); break;
5942 case 30: return ((char *) HT_00030
); break;
5943 case 40: return ((char *) HT_00040
); break;
5944 case 50: return ((char *) HT_00050
); break;
5945 case 60: return ((char *) HT_00060
); break;
5946 case 100: return ((char *) HT_00100
); break;
5947 case 101: return ((char *) HT_00101
); break;
5948 case 110: return ((char *) HT_00110
); break;
5949 case 111: return ((char *) HT_00111
); break;
5950 case 112: return ((char *) HT_00112
); break;
5951 case 120: return ((char *) HT_00120
); break;
5952 case 121: return ((char *) HT_00121
); break;
5953 case 122: return ((char *) HT_00122
); break;
5954 case 124: return ((char *) HT_00124
); break;
5955 case 125: return ((char *) HT_00125
); break;
5956 case 130: return ((char *) HT_00130
); break;
5957 case 131: return ((char *) HT_00131
); break;
5958 case 132: return ((char *) HT_00132
); break;
5959 case 133: return ((char *) HT_00133
); break;
5960 case 140: return ((char *) HT_00140
); break;
5961 case 141: return ((char *) HT_00141
); break;
5962 case 150: return ((char *) HT_00150
); break;
5963 case 160: return ((char *) HT_00160
); break;
5964 case 200: return ((char *) HT_00200
); break;
5965 case 300: return ((char *) HT_00300
); break;
5966 case 400: return ((char *) HT_00400
); break;
5967 case 500: return ((char *) HT_00500
); break;
5968 case 501: return ((char *) HT_00501
); break;
5969 case 900: return ((char *) HT_00900
); break;
5970 case 910: return ((char *) HT_00910
); break;
5971 case 1000: return ((char *) HT_01000
); break;
5972 case 1100: return ((char *) HT_01100
); break;
5973 case 1400: return ((char *) HT_01400
); break;
5974 case 1410: return ((char *) HT_01410
); break;
5975 case 1420: return ((char *) HT_01420
); break;
5976 case 1421: return ((char *) HT_01421
); break;
5977 case 1430: return ((char *) HT_01430
); break;
5978 case 1440: return ((char *) HT_01440
); break;
5979 case 1441: return ((char *) HT_01441
); break;
5980 case 1450: return ((char *) HT_01450
); break;
5981 case 1460: return ((char *) HT_01460
); break;
5982 case 1500: return ((char *) HT_01500
); break;
5983 case 1600: return ((char *) HT_01600
); break;
5984 case 1700: return ((char *) HT_01700
); break;
5985 case 1710: return ((char *) HT_01710
); break;
5986 case 1711: return ((char *) HT_01711
); break;
5987 case 1720: return ((char *) HT_01720
); break;
5988 case 1722: return ((char *) HT_01722
); break;
5989 case 1730: return ((char *) HT_01730
); break;
5990 case 1731: return ((char *) HT_01731
); break;
5991 case 1740: return ((char *) HT_01740
); break;
5992 case 1750: return ((char *) HT_01750
); break;
5993 case 1760: return ((char *) HT_01760
); break;
5994 case 1800: return ((char *) HT_01800
); break;
5995 case 2100: return ((char *) HT_02100
); break;
5996 case 2400: return ((char *) HT_02400
); break;
5997 case 2410: return ((char *) HT_02410
); break;
5998 case 2500: return ((char *) HT_02500
); break;
5999 case 2600: return ((char *) HT_02600
); break;
6000 case 2611: return ((char *) HT_02611
); break;
6001 case 2612: return ((char *) HT_02612
); break;
6002 case 2711: return ((char *) HT_02711
); break;
6003 case 2811: return ((char *) HT_02811
); break;
6004 case 3000: return ((char *) HT_03000
); break;
6005 case 3100: return ((char *) HT_03100
); break;
6006 case 3200: return ((char *) HT_03200
); break;
6007 case 3710: return ((char *) HT_03710
); break;
6008 case 3711: return ((char *) HT_03711
); break;
6009 case 3800: return ((char *) HT_03800
); break;
6010 case 4300: return ((char *) HT_04300
); break;
6011 case 4400: return ((char *) HT_04400
); break;
6012 case 4500: return ((char *) HT_04500
); break;
6013 case 4700: return ((char *) HT_04700
); break;
6014 case 4800: return ((char *) HT_04800
); break;
6015 case 4900: return ((char *) HT_04900
); break;
6016 case 5000: return ((char *) HT_05000
); break;
6017 case 5100: return ((char *) HT_05100
); break;
6018 case 5200: return ((char *) HT_05200
); break;
6019 case 5300: return ((char *) HT_05300
); break;
6020 case 5400: return ((char *) HT_05400
); break;
6021 case 5500: return ((char *) HT_05500
); break;
6022 case 5600: return ((char *) HT_05600
); break;
6023 case 5700: return ((char *) HT_05700
); break;
6024 case 5800: return ((char *) HT_05800
); break;
6025 case 6000: return ((char *) HT_06000
); break;
6026 case 6100: return ((char *) HT_06100
); break;
6027 case 6211: return ((char *) HT_06211
); break;
6028 case 6212: return ((char *) HT_06212
); break;
6029 case 6213: return ((char *) HT_06213
); break;
6030 case 6221: return ((char *) HT_06221
); break;
6031 case 6222: return ((char *) HT_06222
); break;
6032 case 6223: return ((char *) HT_06223
); break;
6033 case 6231: return ((char *) HT_06231
); break;
6034 case 6232: return ((char *) HT_06232
); break;
6035 case 6233: return ((char *) HT_06233
); break;
6036 case 6241: return ((char *) HT_06241
); break;
6037 case 6242: return ((char *) HT_06242
); break;
6038 case 6243: return ((char *) HT_06243
); break;
6039 case 6300: return ((char *) HT_06300
); break;
6040 case 6400: return ((char *) HT_06400
); break;
6041 case 6500: return ((char *) HT_06500
); break;
6042 case 6600: return ((char *) HT_06600
); break;
6043 case 6700: return ((char *) HT_06700
); break;
6044 case 6800: return ((char *) HT_06800
); break;
6045 case 6900: return ((char *) HT_06900
); break;
6046 case 7100: return ((char *) HT_07100
); break;
6047 case 7200: return ((char *) HT_07200
); break;
6048 case 7300: return ((char *) HT_07300
); break;
6049 case 7400: return ((char *) HT_07400
); break;
6050 case 7500: return ((char *) HT_07500
); break;
6051 case 7600: return ((char *) HT_07600
); break;
6052 case 7700: return ((char *) HT_07700
); break;
6053 case 7800: return ((char *) HT_07800
); break;
6054 case 7900: return ((char *) HT_07900
); break;
6055 case 8000: return ((char *) HT_08000
); break;
6056 case 8100: return ((char *) HT_08100
); break;
6057 case 8200: return ((char *) HT_08200
); break;
6058 case 8300: return ((char *) HT_08300
); break;
6059 case 8400: return ((char *) HT_08400
); break;
6060 case 8500: return ((char *) HT_08500
); break;
6061 case 8600: return ((char *) HT_08600
); break;
6062 case 8700: return ((char *) HT_08700
); break;
6063 case 8800: return ((char *) HT_08800
); break;
6064 case 8900: return ((char *) HT_08900
); break;
6065 case 9000: return ((char *) HT_09000
); break;
6066 case 9100: return ((char *) HT_09100
); break;
6067 case 9200: return ((char *) HT_09200
); break;
6068 case 9300: return ((char *) HT_09300
); break;
6069 case 9400: return ((char *) HT_09400
); break;
6070 case 9500: return ((char *) HT_09500
); break;
6071 case 9600: return ((char *) HT_09600
); break;
6072 case 9700: return ((char *) HT_09700
); break;
6073 case 9710: return ((char *) HT_09710
); break;
6074 case 9720: return ((char *) HT_09720
); break;
6075 case 9800: return ((char *) HT_09800
); break;
6076 case 9810: return ((char *) HT_09810
); break;
6077 case 9820: return ((char *) HT_09820
); break;
6078 case 9900: return ((char *) HT_09900
); break;
6079 case 10000: return ((char *) HT_10000
); break;
6080 case 10100: return ((char *) HT_10100
); break;
6081 case 10200: return ((char *) HT_10200
); break;
6082 case 10300: return ((char *) HT_10300
); break;
6083 case 10400: return ((char *) HT_10400
); break;
6084 case 10410: return ((char *) HT_10410
); break;
6085 case 10420: return ((char *) HT_10420
); break;
6086 case 10500: return ((char *) HT_10500
); break;
6087 case 10600: return ((char *) HT_10600
); break;
6088 case 10700: return ((char *) HT_10700
); break;
6089 case 10800: return ((char *) HT_10800
); break;
6090 case 10900: return ((char *) HT_10900
); break;
6091 case 11000: return ((char *) HT_11000
); break;
6092 case 11100: return ((char *) HT_11100
); break;
6093 case 11200: return ((char *) HT_11200
); break;
6094 case 11300: return ((char *) HT_11300
); break;
6095 case 11400: return ((char *) HT_11400
); break;
6096 case 11500: return ((char *) HT_11500
); break;
6097 case 11600: return ((char *) HT_11600
); break;
6098 case 11700: return ((char *) HT_11700
); break;
6099 case 11800: return ((char *) HT_11800
); break;
6100 case 11900: return ((char *) HT_11900
); break;
6101 case 12000: return ((char *) HT_12000
); break;
6102 case 12100: return ((char *) HT_12100
); break;
6103 case 12200: return ((char *) HT_12200
); break;
6104 case 12300: return ((char *) HT_12300
); break;
6105 case 12400: return ((char *) HT_12400
); break;
6106 case 12500: return ((char *) HT_12500
); break;
6107 case 12600: return ((char *) HT_12600
); break;
6108 case 12700: return ((char *) HT_12700
); break;
6109 case 12800: return ((char *) HT_12800
); break;
6110 case 12900: return ((char *) HT_12900
); break;
6111 case 13000: return ((char *) HT_13000
); break;
6112 case 13100: return ((char *) HT_13100
); break;
6113 case 13200: return ((char *) HT_13200
); break;
6114 case 13300: return ((char *) HT_13300
); break;
6115 case 13400: return ((char *) HT_13400
); break;
6116 case 13500: return ((char *) HT_13500
); break;
6117 case 13600: return ((char *) HT_13600
); break;
6118 case 13711: return ((char *) HT_13711
); break;
6119 case 13712: return ((char *) HT_13712
); break;
6120 case 13713: return ((char *) HT_13713
); break;
6121 case 13721: return ((char *) HT_13721
); break;
6122 case 13722: return ((char *) HT_13722
); break;
6123 case 13723: return ((char *) HT_13723
); break;
6124 case 13731: return ((char *) HT_13731
); break;
6125 case 13732: return ((char *) HT_13732
); break;
6126 case 13733: return ((char *) HT_13733
); break;
6127 case 13741: return ((char *) HT_13741
); break;
6128 case 13742: return ((char *) HT_13742
); break;
6129 case 13743: return ((char *) HT_13743
); break;
6130 case 13751: return ((char *) HT_13751
); break;
6131 case 13752: return ((char *) HT_13752
); break;
6132 case 13753: return ((char *) HT_13753
); break;
6133 case 13761: return ((char *) HT_13761
); break;
6134 case 13762: return ((char *) HT_13762
); break;
6135 case 13763: return ((char *) HT_13763
); break;
6136 case 13800: return ((char *) HT_13800
); break;
6139 return ((char *) "Unknown");
6142 char *strstatus (const uint devices_status
)
6144 switch (devices_status
)
6146 case STATUS_INIT
: return ((char *) ST_0000
); break;
6147 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6148 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6149 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6150 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6151 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6152 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6153 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6154 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6155 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6156 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6159 return ((char *) "Unknown");
6162 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6164 uint hash_type
= data
.hash_type
;
6165 uint hash_mode
= data
.hash_mode
;
6166 uint salt_type
= data
.salt_type
;
6167 uint opts_type
= data
.opts_type
;
6168 uint opti_type
= data
.opti_type
;
6169 uint dgst_size
= data
.dgst_size
;
6171 char *hashfile
= data
.hashfile
;
6175 uint digest_buf
[64] = { 0 };
6177 u64
*digest_buf64
= (u64
*) digest_buf
;
6179 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6181 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6183 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6189 case HASH_TYPE_DESCRYPT
:
6190 FP (digest_buf
[1], digest_buf
[0], tt
);
6193 case HASH_TYPE_DESRACF
:
6194 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6195 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6197 FP (digest_buf
[1], digest_buf
[0], tt
);
6201 FP (digest_buf
[1], digest_buf
[0], tt
);
6204 case HASH_TYPE_NETNTLM
:
6205 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6206 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6207 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6208 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6210 FP (digest_buf
[1], digest_buf
[0], tt
);
6211 FP (digest_buf
[3], digest_buf
[2], tt
);
6214 case HASH_TYPE_BSDICRYPT
:
6215 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6216 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6218 FP (digest_buf
[1], digest_buf
[0], tt
);
6223 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6228 digest_buf
[0] += MD4M_A
;
6229 digest_buf
[1] += MD4M_B
;
6230 digest_buf
[2] += MD4M_C
;
6231 digest_buf
[3] += MD4M_D
;
6235 digest_buf
[0] += MD5M_A
;
6236 digest_buf
[1] += MD5M_B
;
6237 digest_buf
[2] += MD5M_C
;
6238 digest_buf
[3] += MD5M_D
;
6241 case HASH_TYPE_SHA1
:
6242 digest_buf
[0] += SHA1M_A
;
6243 digest_buf
[1] += SHA1M_B
;
6244 digest_buf
[2] += SHA1M_C
;
6245 digest_buf
[3] += SHA1M_D
;
6246 digest_buf
[4] += SHA1M_E
;
6249 case HASH_TYPE_SHA256
:
6250 digest_buf
[0] += SHA256M_A
;
6251 digest_buf
[1] += SHA256M_B
;
6252 digest_buf
[2] += SHA256M_C
;
6253 digest_buf
[3] += SHA256M_D
;
6254 digest_buf
[4] += SHA256M_E
;
6255 digest_buf
[5] += SHA256M_F
;
6256 digest_buf
[6] += SHA256M_G
;
6257 digest_buf
[7] += SHA256M_H
;
6260 case HASH_TYPE_SHA384
:
6261 digest_buf64
[0] += SHA384M_A
;
6262 digest_buf64
[1] += SHA384M_B
;
6263 digest_buf64
[2] += SHA384M_C
;
6264 digest_buf64
[3] += SHA384M_D
;
6265 digest_buf64
[4] += SHA384M_E
;
6266 digest_buf64
[5] += SHA384M_F
;
6267 digest_buf64
[6] += 0;
6268 digest_buf64
[7] += 0;
6271 case HASH_TYPE_SHA512
:
6272 digest_buf64
[0] += SHA512M_A
;
6273 digest_buf64
[1] += SHA512M_B
;
6274 digest_buf64
[2] += SHA512M_C
;
6275 digest_buf64
[3] += SHA512M_D
;
6276 digest_buf64
[4] += SHA512M_E
;
6277 digest_buf64
[5] += SHA512M_F
;
6278 digest_buf64
[6] += SHA512M_G
;
6279 digest_buf64
[7] += SHA512M_H
;
6284 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6286 if (dgst_size
== DGST_SIZE_4_2
)
6288 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6290 else if (dgst_size
== DGST_SIZE_4_4
)
6292 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6294 else if (dgst_size
== DGST_SIZE_4_5
)
6296 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6298 else if (dgst_size
== DGST_SIZE_4_6
)
6300 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6302 else if (dgst_size
== DGST_SIZE_4_8
)
6304 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6306 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6308 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6310 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6312 else if (hash_type
== HASH_TYPE_SHA384
)
6314 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6316 else if (hash_type
== HASH_TYPE_SHA512
)
6318 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6320 else if (hash_type
== HASH_TYPE_GOST
)
6322 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6325 else if (dgst_size
== DGST_SIZE_4_64
)
6327 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6329 else if (dgst_size
== DGST_SIZE_8_25
)
6331 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6335 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6336 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6337 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6343 memset (&salt
, 0, sizeof (salt_t
));
6345 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6347 char *ptr
= (char *) salt
.salt_buf
;
6349 uint len
= salt
.salt_len
;
6351 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6357 case HASH_TYPE_NETNTLM
:
6359 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6360 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6362 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6368 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6370 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6378 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6380 uint max
= salt
.salt_len
/ 4;
6384 for (uint i
= 0; i
< max
; i
++)
6386 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6390 if (opts_type
& OPTS_TYPE_ST_HEX
)
6392 char tmp
[64] = { 0 };
6394 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6396 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6401 memcpy (ptr
, tmp
, len
);
6404 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6406 memset (ptr
+ len
, 0, memset_size
);
6408 salt
.salt_len
= len
;
6412 // some modes require special encoding
6415 uint out_buf_plain
[256] = { 0 };
6416 uint out_buf_salt
[256] = { 0 };
6418 char tmp_buf
[1024] = { 0 };
6420 char *ptr_plain
= (char *) out_buf_plain
;
6421 char *ptr_salt
= (char *) out_buf_salt
;
6423 if (hash_mode
== 22)
6425 char username
[30] = { 0 };
6427 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6429 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6431 u16
*ptr
= (u16
*) digest_buf
;
6433 tmp_buf
[ 0] = sig
[0];
6434 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6435 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6436 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6437 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6438 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6439 tmp_buf
[ 6] = sig
[1];
6440 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6441 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6442 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6443 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6444 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6445 tmp_buf
[12] = sig
[2];
6446 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6447 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6448 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6449 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6450 tmp_buf
[17] = sig
[3];
6451 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6452 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6453 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6454 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6455 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6456 tmp_buf
[23] = sig
[4];
6457 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6458 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6459 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6460 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6461 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6462 tmp_buf
[29] = sig
[5];
6464 snprintf (out_buf
, len
-1, "%s:%s",
6468 else if (hash_mode
== 23)
6470 // do not show the skyper part in output
6472 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6474 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6476 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6483 else if (hash_mode
== 101)
6485 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6487 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6488 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6489 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6490 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6491 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6493 memcpy (tmp_buf
, digest_buf
, 20);
6495 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6497 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6499 else if (hash_mode
== 111)
6501 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6503 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6504 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6505 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6506 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6507 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6509 memcpy (tmp_buf
, digest_buf
, 20);
6510 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6512 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6514 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6516 else if ((hash_mode
== 122) || (hash_mode
== 125))
6518 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6519 (char *) salt
.salt_buf
,
6526 else if (hash_mode
== 124)
6528 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6529 (char *) salt
.salt_buf
,
6536 else if (hash_mode
== 131)
6538 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6539 (char *) salt
.salt_buf
,
6547 else if (hash_mode
== 132)
6549 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6550 (char *) salt
.salt_buf
,
6557 else if (hash_mode
== 133)
6559 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6561 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6562 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6563 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6564 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6565 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6567 memcpy (tmp_buf
, digest_buf
, 20);
6569 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6571 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6573 else if (hash_mode
== 141)
6575 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6577 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6579 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6581 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6583 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6584 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6585 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6586 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6587 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6589 memcpy (tmp_buf
, digest_buf
, 20);
6591 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6595 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6597 else if (hash_mode
== 400)
6599 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6601 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6602 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6603 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6604 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6606 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6608 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6610 else if (hash_mode
== 500)
6612 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6614 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6615 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6616 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6617 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6619 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6621 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6623 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6627 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6630 else if (hash_mode
== 501)
6632 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6634 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6635 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6637 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6639 else if (hash_mode
== 1421)
6641 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6643 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6659 else if (hash_mode
== 1441)
6661 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6663 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6665 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6667 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6669 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6670 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6671 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6672 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6673 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6674 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6675 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6676 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6678 memcpy (tmp_buf
, digest_buf
, 32);
6680 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6684 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6686 else if (hash_mode
== 1500)
6688 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6689 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6690 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6691 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6692 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6694 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6696 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6698 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6699 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6701 memcpy (tmp_buf
, digest_buf
, 8);
6703 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6705 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6709 else if (hash_mode
== 1600)
6711 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6713 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6714 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6715 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6716 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6718 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6720 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6722 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6726 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6729 else if (hash_mode
== 1711)
6731 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6733 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6734 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6735 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6736 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6737 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6738 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6739 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6740 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6742 memcpy (tmp_buf
, digest_buf
, 64);
6743 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6745 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6747 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6749 else if (hash_mode
== 1722)
6751 uint
*ptr
= digest_buf
;
6753 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6754 (unsigned char *) salt
.salt_buf
,
6764 else if (hash_mode
== 1731)
6766 uint
*ptr
= digest_buf
;
6768 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6769 (unsigned char *) salt
.salt_buf
,
6779 else if (hash_mode
== 1800)
6783 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6784 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6785 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6786 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6787 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6788 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6789 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6790 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6792 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6794 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6796 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6800 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6803 else if (hash_mode
== 2100)
6807 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6809 salt
.salt_iter
+ 1);
6811 uint signature_len
= strlen (out_buf
);
6813 pos
+= signature_len
;
6814 len
-= signature_len
;
6816 char *salt_ptr
= (char *) salt
.salt_buf
;
6818 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6820 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6821 byte_swap_32 (digest_buf
[0]),
6822 byte_swap_32 (digest_buf
[1]),
6823 byte_swap_32 (digest_buf
[2]),
6824 byte_swap_32 (digest_buf
[3]));
6826 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6828 memcpy (tmp_buf
, digest_buf
, 16);
6830 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6832 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6833 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6834 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6835 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6837 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6838 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6839 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6840 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6842 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6843 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6844 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6845 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6847 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6848 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6849 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6850 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6852 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6853 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6854 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6855 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6859 else if (hash_mode
== 2500)
6861 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6863 wpa_t
*wpa
= &wpas
[salt_pos
];
6865 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6866 (char *) salt
.salt_buf
,
6880 else if (hash_mode
== 4400)
6882 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6883 byte_swap_32 (digest_buf
[0]),
6884 byte_swap_32 (digest_buf
[1]),
6885 byte_swap_32 (digest_buf
[2]),
6886 byte_swap_32 (digest_buf
[3]));
6888 else if (hash_mode
== 4700)
6890 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6891 byte_swap_32 (digest_buf
[0]),
6892 byte_swap_32 (digest_buf
[1]),
6893 byte_swap_32 (digest_buf
[2]),
6894 byte_swap_32 (digest_buf
[3]),
6895 byte_swap_32 (digest_buf
[4]));
6897 else if (hash_mode
== 4800)
6899 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6901 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6906 byte_swap_32 (salt
.salt_buf
[0]),
6907 byte_swap_32 (salt
.salt_buf
[1]),
6908 byte_swap_32 (salt
.salt_buf
[2]),
6909 byte_swap_32 (salt
.salt_buf
[3]),
6912 else if (hash_mode
== 4900)
6914 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6915 byte_swap_32 (digest_buf
[0]),
6916 byte_swap_32 (digest_buf
[1]),
6917 byte_swap_32 (digest_buf
[2]),
6918 byte_swap_32 (digest_buf
[3]),
6919 byte_swap_32 (digest_buf
[4]));
6921 else if (hash_mode
== 5100)
6923 snprintf (out_buf
, len
-1, "%08x%08x",
6927 else if (hash_mode
== 5200)
6929 snprintf (out_buf
, len
-1, "%s", hashfile
);
6931 else if (hash_mode
== 5300)
6933 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6935 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6937 int buf_len
= len
-1;
6941 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6943 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6945 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6947 snprintf (out_buf
, buf_len
, ":");
6953 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6961 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6963 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6965 if ((i
== 0) || (i
== 5))
6967 snprintf (out_buf
, buf_len
, ":");
6973 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6981 for (uint i
= 0; i
< 4; i
++)
6985 snprintf (out_buf
, buf_len
, ":");
6991 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6997 else if (hash_mode
== 5400)
6999 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
7001 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
7003 int buf_len
= len
-1;
7007 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
7009 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
7011 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
7013 snprintf (out_buf
, buf_len
, ":");
7019 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
7027 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
7029 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
7031 if ((i
== 0) || (i
== 5))
7033 snprintf (out_buf
, buf_len
, ":");
7039 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
7047 for (uint i
= 0; i
< 5; i
++)
7051 snprintf (out_buf
, buf_len
, ":");
7057 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
7063 else if (hash_mode
== 5500)
7065 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7067 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7069 char user_buf
[64] = { 0 };
7070 char domain_buf
[64] = { 0 };
7071 char srvchall_buf
[1024] = { 0 };
7072 char clichall_buf
[1024] = { 0 };
7074 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7076 char *ptr
= (char *) netntlm
->userdomain_buf
;
7078 user_buf
[i
] = ptr
[j
];
7081 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7083 char *ptr
= (char *) netntlm
->userdomain_buf
;
7085 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7088 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7090 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7092 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7095 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7097 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7099 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7102 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7110 byte_swap_32 (salt
.salt_buf_pc
[0]),
7111 byte_swap_32 (salt
.salt_buf_pc
[1]),
7114 else if (hash_mode
== 5600)
7116 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7118 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7120 char user_buf
[64] = { 0 };
7121 char domain_buf
[64] = { 0 };
7122 char srvchall_buf
[1024] = { 0 };
7123 char clichall_buf
[1024] = { 0 };
7125 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7127 char *ptr
= (char *) netntlm
->userdomain_buf
;
7129 user_buf
[i
] = ptr
[j
];
7132 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7134 char *ptr
= (char *) netntlm
->userdomain_buf
;
7136 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7139 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7141 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7143 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7146 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7148 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7150 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7153 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7163 else if (hash_mode
== 5700)
7165 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7167 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7168 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7169 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7170 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7171 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7172 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7173 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7174 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7176 memcpy (tmp_buf
, digest_buf
, 32);
7178 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7182 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7184 else if (hash_mode
== 5800)
7186 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7187 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7188 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7189 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7190 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7192 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7199 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7201 snprintf (out_buf
, len
-1, "%s", hashfile
);
7203 else if (hash_mode
== 6300)
7205 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7207 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7208 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7209 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7210 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7212 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7214 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7216 else if (hash_mode
== 6400)
7218 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7220 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7222 else if (hash_mode
== 6500)
7224 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7226 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7228 else if (hash_mode
== 6600)
7230 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7232 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7234 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7235 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7237 uint buf_len
= len
- 1;
7239 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7242 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7244 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7249 else if (hash_mode
== 6700)
7251 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7253 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7255 else if (hash_mode
== 6800)
7257 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7259 else if (hash_mode
== 7100)
7261 uint
*ptr
= digest_buf
;
7263 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7265 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7267 uint esalt
[8] = { 0 };
7269 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7270 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7271 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7272 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7273 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7274 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7275 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7276 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7278 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",
7279 SIGNATURE_SHA512OSX
,
7281 esalt
[ 0], esalt
[ 1],
7282 esalt
[ 2], esalt
[ 3],
7283 esalt
[ 4], esalt
[ 5],
7284 esalt
[ 6], esalt
[ 7],
7292 ptr
[15], ptr
[14]);
7294 else if (hash_mode
== 7200)
7296 uint
*ptr
= digest_buf
;
7298 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7300 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7304 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7306 len_used
= strlen (out_buf
);
7308 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7310 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7312 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7315 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",
7323 ptr
[15], ptr
[14]);
7325 else if (hash_mode
== 7300)
7327 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7329 rakp_t
*rakp
= &rakps
[salt_pos
];
7331 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7333 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7336 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7343 else if (hash_mode
== 7400)
7345 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7347 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7348 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7349 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7350 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7351 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7352 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7353 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7354 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7356 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7358 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7360 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7364 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7367 else if (hash_mode
== 7500)
7369 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7371 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7373 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7374 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7376 char data
[128] = { 0 };
7378 char *ptr_data
= data
;
7380 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7382 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7385 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7387 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7392 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7394 (char *) krb5pa
->user
,
7395 (char *) krb5pa
->realm
,
7396 (char *) krb5pa
->salt
,
7399 else if (hash_mode
== 7700)
7401 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7402 (char *) salt
.salt_buf
,
7406 else if (hash_mode
== 7800)
7408 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7409 (char *) salt
.salt_buf
,
7416 else if (hash_mode
== 7900)
7418 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7422 char *tmp
= (char *) salt
.salt_buf_pc
;
7424 ptr_plain
[42] = tmp
[0];
7430 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7432 else if (hash_mode
== 8000)
7434 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7435 (unsigned char *) salt
.salt_buf
,
7445 else if (hash_mode
== 8100)
7447 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7448 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7450 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7451 (unsigned char *) salt
.salt_buf
,
7458 else if (hash_mode
== 8200)
7460 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7462 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7464 char data_buf
[4096] = { 0 };
7466 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7468 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7471 data_buf
[cloudkey
->data_len
* 2] = 0;
7473 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7474 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7475 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7476 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7477 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7478 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7479 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7480 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7482 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7483 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7484 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7485 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7487 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7503 else if (hash_mode
== 8300)
7505 char digest_buf_c
[34] = { 0 };
7507 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7508 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7509 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7510 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7511 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7513 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7515 digest_buf_c
[32] = 0;
7519 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7521 char domain_buf_c
[33] = { 0 };
7523 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7525 for (uint i
= 0; i
< salt_pc_len
; i
++)
7527 const char next
= domain_buf_c
[i
];
7529 domain_buf_c
[i
] = '.';
7534 domain_buf_c
[salt_pc_len
] = 0;
7538 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7540 else if (hash_mode
== 8500)
7542 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7544 else if (hash_mode
== 2612)
7546 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7548 (char *) salt
.salt_buf
,
7554 else if (hash_mode
== 3711)
7556 char *salt_ptr
= (char *) salt
.salt_buf
;
7558 salt_ptr
[salt
.salt_len
- 1] = 0;
7560 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7561 SIGNATURE_MEDIAWIKI_B
,
7568 else if (hash_mode
== 8800)
7570 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7572 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7574 char tmp
[3073] = { 0 };
7576 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7578 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7583 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7584 SIGNATURE_ANDROIDFDE
,
7585 byte_swap_32 (salt
.salt_buf
[0]),
7586 byte_swap_32 (salt
.salt_buf
[1]),
7587 byte_swap_32 (salt
.salt_buf
[2]),
7588 byte_swap_32 (salt
.salt_buf
[3]),
7589 byte_swap_32 (digest_buf
[0]),
7590 byte_swap_32 (digest_buf
[1]),
7591 byte_swap_32 (digest_buf
[2]),
7592 byte_swap_32 (digest_buf
[3]),
7595 else if (hash_mode
== 8900)
7597 uint N
= salt
.scrypt_N
;
7598 uint r
= salt
.scrypt_r
;
7599 uint p
= salt
.scrypt_p
;
7601 char base64_salt
[32] = { 0 };
7603 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7605 memset (tmp_buf
, 0, 46);
7607 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7608 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7609 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7610 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7611 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7612 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7613 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7614 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7615 digest_buf
[8] = 0; // needed for base64_encode ()
7617 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7619 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7627 else if (hash_mode
== 9000)
7629 snprintf (out_buf
, len
-1, "%s", hashfile
);
7631 else if (hash_mode
== 9200)
7635 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7637 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7639 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7643 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7644 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7645 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7646 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7647 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7648 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7649 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7650 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7651 digest_buf
[8] = 0; // needed for base64_encode ()
7653 char tmp_buf
[64] = { 0 };
7655 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7656 tmp_buf
[43] = 0; // cut it here
7660 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7662 else if (hash_mode
== 9300)
7664 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7665 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7666 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7667 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7668 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7669 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7670 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7671 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7672 digest_buf
[8] = 0; // needed for base64_encode ()
7674 char tmp_buf
[64] = { 0 };
7676 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7677 tmp_buf
[43] = 0; // cut it here
7679 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7681 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7683 else if (hash_mode
== 9400)
7685 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7687 office2007_t
*office2007
= &office2007s
[salt_pos
];
7689 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7690 SIGNATURE_OFFICE2007
,
7693 office2007
->keySize
,
7699 office2007
->encryptedVerifier
[0],
7700 office2007
->encryptedVerifier
[1],
7701 office2007
->encryptedVerifier
[2],
7702 office2007
->encryptedVerifier
[3],
7703 office2007
->encryptedVerifierHash
[0],
7704 office2007
->encryptedVerifierHash
[1],
7705 office2007
->encryptedVerifierHash
[2],
7706 office2007
->encryptedVerifierHash
[3],
7707 office2007
->encryptedVerifierHash
[4]);
7709 else if (hash_mode
== 9500)
7711 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7713 office2010_t
*office2010
= &office2010s
[salt_pos
];
7715 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,
7721 office2010
->encryptedVerifier
[0],
7722 office2010
->encryptedVerifier
[1],
7723 office2010
->encryptedVerifier
[2],
7724 office2010
->encryptedVerifier
[3],
7725 office2010
->encryptedVerifierHash
[0],
7726 office2010
->encryptedVerifierHash
[1],
7727 office2010
->encryptedVerifierHash
[2],
7728 office2010
->encryptedVerifierHash
[3],
7729 office2010
->encryptedVerifierHash
[4],
7730 office2010
->encryptedVerifierHash
[5],
7731 office2010
->encryptedVerifierHash
[6],
7732 office2010
->encryptedVerifierHash
[7]);
7734 else if (hash_mode
== 9600)
7736 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7738 office2013_t
*office2013
= &office2013s
[salt_pos
];
7740 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,
7746 office2013
->encryptedVerifier
[0],
7747 office2013
->encryptedVerifier
[1],
7748 office2013
->encryptedVerifier
[2],
7749 office2013
->encryptedVerifier
[3],
7750 office2013
->encryptedVerifierHash
[0],
7751 office2013
->encryptedVerifierHash
[1],
7752 office2013
->encryptedVerifierHash
[2],
7753 office2013
->encryptedVerifierHash
[3],
7754 office2013
->encryptedVerifierHash
[4],
7755 office2013
->encryptedVerifierHash
[5],
7756 office2013
->encryptedVerifierHash
[6],
7757 office2013
->encryptedVerifierHash
[7]);
7759 else if (hash_mode
== 9700)
7761 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7763 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7765 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7766 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7767 byte_swap_32 (salt
.salt_buf
[0]),
7768 byte_swap_32 (salt
.salt_buf
[1]),
7769 byte_swap_32 (salt
.salt_buf
[2]),
7770 byte_swap_32 (salt
.salt_buf
[3]),
7771 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7772 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7773 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7774 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7775 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7776 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7777 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7778 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7780 else if (hash_mode
== 9710)
7782 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7784 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7786 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7787 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7788 byte_swap_32 (salt
.salt_buf
[0]),
7789 byte_swap_32 (salt
.salt_buf
[1]),
7790 byte_swap_32 (salt
.salt_buf
[2]),
7791 byte_swap_32 (salt
.salt_buf
[3]),
7792 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7793 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7794 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7795 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7796 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7797 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7798 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7799 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7801 else if (hash_mode
== 9720)
7803 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7805 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7807 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7809 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7810 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7811 byte_swap_32 (salt
.salt_buf
[0]),
7812 byte_swap_32 (salt
.salt_buf
[1]),
7813 byte_swap_32 (salt
.salt_buf
[2]),
7814 byte_swap_32 (salt
.salt_buf
[3]),
7815 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7816 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7817 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7818 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7819 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7820 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7821 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7822 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7829 else if (hash_mode
== 9800)
7831 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7833 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7835 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7836 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7841 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7842 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7843 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7844 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7845 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7846 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7847 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7848 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7849 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7851 else if (hash_mode
== 9810)
7853 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7855 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7857 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7858 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7863 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7864 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7865 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7866 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7867 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7868 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7869 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7870 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7871 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7873 else if (hash_mode
== 9820)
7875 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7877 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7879 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7881 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7882 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7887 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7888 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7889 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7890 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7891 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7892 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7893 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7894 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7895 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7902 else if (hash_mode
== 10000)
7906 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7908 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7910 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7914 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7915 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7916 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7917 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7918 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7919 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7920 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7921 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7922 digest_buf
[8] = 0; // needed for base64_encode ()
7924 char tmp_buf
[64] = { 0 };
7926 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7930 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7932 else if (hash_mode
== 10100)
7934 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7939 byte_swap_32 (salt
.salt_buf
[0]),
7940 byte_swap_32 (salt
.salt_buf
[1]),
7941 byte_swap_32 (salt
.salt_buf
[2]),
7942 byte_swap_32 (salt
.salt_buf
[3]));
7944 else if (hash_mode
== 10200)
7946 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7948 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7952 char challenge
[100] = { 0 };
7954 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7958 char tmp_buf
[100] = { 0 };
7960 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7961 (char *) cram_md5
->user
,
7967 char response
[100] = { 0 };
7969 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7971 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7973 else if (hash_mode
== 10300)
7975 char tmp_buf
[100] = { 0 };
7977 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7978 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7980 uint tmp_len
= 20 + salt
.salt_len
;
7984 char base64_encoded
[100] = { 0 };
7986 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7988 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7990 else if (hash_mode
== 10400)
7992 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7994 pdf_t
*pdf
= &pdfs
[salt_pos
];
7996 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",
8004 byte_swap_32 (pdf
->id_buf
[0]),
8005 byte_swap_32 (pdf
->id_buf
[1]),
8006 byte_swap_32 (pdf
->id_buf
[2]),
8007 byte_swap_32 (pdf
->id_buf
[3]),
8009 byte_swap_32 (pdf
->u_buf
[0]),
8010 byte_swap_32 (pdf
->u_buf
[1]),
8011 byte_swap_32 (pdf
->u_buf
[2]),
8012 byte_swap_32 (pdf
->u_buf
[3]),
8013 byte_swap_32 (pdf
->u_buf
[4]),
8014 byte_swap_32 (pdf
->u_buf
[5]),
8015 byte_swap_32 (pdf
->u_buf
[6]),
8016 byte_swap_32 (pdf
->u_buf
[7]),
8018 byte_swap_32 (pdf
->o_buf
[0]),
8019 byte_swap_32 (pdf
->o_buf
[1]),
8020 byte_swap_32 (pdf
->o_buf
[2]),
8021 byte_swap_32 (pdf
->o_buf
[3]),
8022 byte_swap_32 (pdf
->o_buf
[4]),
8023 byte_swap_32 (pdf
->o_buf
[5]),
8024 byte_swap_32 (pdf
->o_buf
[6]),
8025 byte_swap_32 (pdf
->o_buf
[7])
8028 else if (hash_mode
== 10410)
8030 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8032 pdf_t
*pdf
= &pdfs
[salt_pos
];
8034 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",
8042 byte_swap_32 (pdf
->id_buf
[0]),
8043 byte_swap_32 (pdf
->id_buf
[1]),
8044 byte_swap_32 (pdf
->id_buf
[2]),
8045 byte_swap_32 (pdf
->id_buf
[3]),
8047 byte_swap_32 (pdf
->u_buf
[0]),
8048 byte_swap_32 (pdf
->u_buf
[1]),
8049 byte_swap_32 (pdf
->u_buf
[2]),
8050 byte_swap_32 (pdf
->u_buf
[3]),
8051 byte_swap_32 (pdf
->u_buf
[4]),
8052 byte_swap_32 (pdf
->u_buf
[5]),
8053 byte_swap_32 (pdf
->u_buf
[6]),
8054 byte_swap_32 (pdf
->u_buf
[7]),
8056 byte_swap_32 (pdf
->o_buf
[0]),
8057 byte_swap_32 (pdf
->o_buf
[1]),
8058 byte_swap_32 (pdf
->o_buf
[2]),
8059 byte_swap_32 (pdf
->o_buf
[3]),
8060 byte_swap_32 (pdf
->o_buf
[4]),
8061 byte_swap_32 (pdf
->o_buf
[5]),
8062 byte_swap_32 (pdf
->o_buf
[6]),
8063 byte_swap_32 (pdf
->o_buf
[7])
8066 else if (hash_mode
== 10420)
8068 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8070 pdf_t
*pdf
= &pdfs
[salt_pos
];
8072 u8
*rc4key
= (u8
*) pdf
->rc4key
;
8074 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",
8082 byte_swap_32 (pdf
->id_buf
[0]),
8083 byte_swap_32 (pdf
->id_buf
[1]),
8084 byte_swap_32 (pdf
->id_buf
[2]),
8085 byte_swap_32 (pdf
->id_buf
[3]),
8087 byte_swap_32 (pdf
->u_buf
[0]),
8088 byte_swap_32 (pdf
->u_buf
[1]),
8089 byte_swap_32 (pdf
->u_buf
[2]),
8090 byte_swap_32 (pdf
->u_buf
[3]),
8091 byte_swap_32 (pdf
->u_buf
[4]),
8092 byte_swap_32 (pdf
->u_buf
[5]),
8093 byte_swap_32 (pdf
->u_buf
[6]),
8094 byte_swap_32 (pdf
->u_buf
[7]),
8096 byte_swap_32 (pdf
->o_buf
[0]),
8097 byte_swap_32 (pdf
->o_buf
[1]),
8098 byte_swap_32 (pdf
->o_buf
[2]),
8099 byte_swap_32 (pdf
->o_buf
[3]),
8100 byte_swap_32 (pdf
->o_buf
[4]),
8101 byte_swap_32 (pdf
->o_buf
[5]),
8102 byte_swap_32 (pdf
->o_buf
[6]),
8103 byte_swap_32 (pdf
->o_buf
[7]),
8111 else if (hash_mode
== 10500)
8113 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8115 pdf_t
*pdf
= &pdfs
[salt_pos
];
8117 if (pdf
->id_len
== 32)
8119 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",
8127 byte_swap_32 (pdf
->id_buf
[0]),
8128 byte_swap_32 (pdf
->id_buf
[1]),
8129 byte_swap_32 (pdf
->id_buf
[2]),
8130 byte_swap_32 (pdf
->id_buf
[3]),
8131 byte_swap_32 (pdf
->id_buf
[4]),
8132 byte_swap_32 (pdf
->id_buf
[5]),
8133 byte_swap_32 (pdf
->id_buf
[6]),
8134 byte_swap_32 (pdf
->id_buf
[7]),
8136 byte_swap_32 (pdf
->u_buf
[0]),
8137 byte_swap_32 (pdf
->u_buf
[1]),
8138 byte_swap_32 (pdf
->u_buf
[2]),
8139 byte_swap_32 (pdf
->u_buf
[3]),
8140 byte_swap_32 (pdf
->u_buf
[4]),
8141 byte_swap_32 (pdf
->u_buf
[5]),
8142 byte_swap_32 (pdf
->u_buf
[6]),
8143 byte_swap_32 (pdf
->u_buf
[7]),
8145 byte_swap_32 (pdf
->o_buf
[0]),
8146 byte_swap_32 (pdf
->o_buf
[1]),
8147 byte_swap_32 (pdf
->o_buf
[2]),
8148 byte_swap_32 (pdf
->o_buf
[3]),
8149 byte_swap_32 (pdf
->o_buf
[4]),
8150 byte_swap_32 (pdf
->o_buf
[5]),
8151 byte_swap_32 (pdf
->o_buf
[6]),
8152 byte_swap_32 (pdf
->o_buf
[7])
8157 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",
8165 byte_swap_32 (pdf
->id_buf
[0]),
8166 byte_swap_32 (pdf
->id_buf
[1]),
8167 byte_swap_32 (pdf
->id_buf
[2]),
8168 byte_swap_32 (pdf
->id_buf
[3]),
8170 byte_swap_32 (pdf
->u_buf
[0]),
8171 byte_swap_32 (pdf
->u_buf
[1]),
8172 byte_swap_32 (pdf
->u_buf
[2]),
8173 byte_swap_32 (pdf
->u_buf
[3]),
8174 byte_swap_32 (pdf
->u_buf
[4]),
8175 byte_swap_32 (pdf
->u_buf
[5]),
8176 byte_swap_32 (pdf
->u_buf
[6]),
8177 byte_swap_32 (pdf
->u_buf
[7]),
8179 byte_swap_32 (pdf
->o_buf
[0]),
8180 byte_swap_32 (pdf
->o_buf
[1]),
8181 byte_swap_32 (pdf
->o_buf
[2]),
8182 byte_swap_32 (pdf
->o_buf
[3]),
8183 byte_swap_32 (pdf
->o_buf
[4]),
8184 byte_swap_32 (pdf
->o_buf
[5]),
8185 byte_swap_32 (pdf
->o_buf
[6]),
8186 byte_swap_32 (pdf
->o_buf
[7])
8190 else if (hash_mode
== 10600)
8192 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8194 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8195 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8197 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8199 else if (hash_mode
== 10700)
8201 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8203 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8204 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8206 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8208 else if (hash_mode
== 10900)
8210 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8212 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8213 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8215 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8217 else if (hash_mode
== 11100)
8219 u32 salt_challenge
= salt
.salt_buf
[0];
8221 salt_challenge
= byte_swap_32 (salt_challenge
);
8223 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8225 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8226 SIGNATURE_POSTGRESQL_AUTH
,
8234 else if (hash_mode
== 11200)
8236 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8237 SIGNATURE_MYSQL_AUTH
,
8238 (unsigned char *) salt
.salt_buf
,
8245 else if (hash_mode
== 11300)
8247 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8249 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8251 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8252 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8253 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8255 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8256 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8257 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8259 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8261 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8263 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8266 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8268 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8270 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8273 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8275 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8277 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8280 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8281 SIGNATURE_BITCOIN_WALLET
,
8285 (unsigned char *) salt
.salt_buf
,
8293 free (cry_master_buf
);
8295 free (public_key_buf
);
8297 else if (hash_mode
== 11400)
8299 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8301 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8302 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8304 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8306 else if (hash_mode
== 11600)
8308 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8310 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8312 const uint data_len
= seven_zip
->data_len
;
8314 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8316 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8318 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8320 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8323 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8324 SIGNATURE_SEVEN_ZIP
,
8328 (char *) seven_zip
->salt_buf
,
8330 seven_zip
->iv_buf
[0],
8331 seven_zip
->iv_buf
[1],
8332 seven_zip
->iv_buf
[2],
8333 seven_zip
->iv_buf
[3],
8335 seven_zip
->data_len
,
8336 seven_zip
->unpack_size
,
8341 else if (hash_mode
== 11700)
8343 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8353 else if (hash_mode
== 11800)
8355 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8373 else if (hash_mode
== 11900)
8375 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8377 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8378 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8380 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8382 else if (hash_mode
== 12000)
8384 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8386 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8387 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8389 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8391 else if (hash_mode
== 12100)
8393 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8395 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8396 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8398 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8400 else if (hash_mode
== 12200)
8402 uint
*ptr_digest
= digest_buf
;
8403 uint
*ptr_salt
= salt
.salt_buf
;
8405 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8412 else if (hash_mode
== 12300)
8414 uint
*ptr_digest
= digest_buf
;
8415 uint
*ptr_salt
= salt
.salt_buf
;
8417 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",
8418 ptr_digest
[ 0], ptr_digest
[ 1],
8419 ptr_digest
[ 2], ptr_digest
[ 3],
8420 ptr_digest
[ 4], ptr_digest
[ 5],
8421 ptr_digest
[ 6], ptr_digest
[ 7],
8422 ptr_digest
[ 8], ptr_digest
[ 9],
8423 ptr_digest
[10], ptr_digest
[11],
8424 ptr_digest
[12], ptr_digest
[13],
8425 ptr_digest
[14], ptr_digest
[15],
8431 else if (hash_mode
== 12400)
8433 // encode iteration count
8435 char salt_iter
[5] = { 0 };
8437 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8438 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8439 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8440 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8445 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8446 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8447 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8448 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8453 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8455 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8456 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8458 memcpy (tmp_buf
, digest_buf
, 8);
8460 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8464 // fill the resulting buffer
8466 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8468 else if (hash_mode
== 12500)
8470 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8472 byte_swap_32 (salt
.salt_buf
[0]),
8473 byte_swap_32 (salt
.salt_buf
[1]),
8479 else if (hash_mode
== 12600)
8481 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8482 digest_buf
[0] + salt
.salt_buf_pc
[0],
8483 digest_buf
[1] + salt
.salt_buf_pc
[1],
8484 digest_buf
[2] + salt
.salt_buf_pc
[2],
8485 digest_buf
[3] + salt
.salt_buf_pc
[3],
8486 digest_buf
[4] + salt
.salt_buf_pc
[4],
8487 digest_buf
[5] + salt
.salt_buf_pc
[5],
8488 digest_buf
[6] + salt
.salt_buf_pc
[6],
8489 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8491 else if (hash_mode
== 12700)
8493 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8495 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8496 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8498 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8500 else if (hash_mode
== 12800)
8502 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8504 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",
8517 byte_swap_32 (digest_buf
[0]),
8518 byte_swap_32 (digest_buf
[1]),
8519 byte_swap_32 (digest_buf
[2]),
8520 byte_swap_32 (digest_buf
[3]),
8521 byte_swap_32 (digest_buf
[4]),
8522 byte_swap_32 (digest_buf
[5]),
8523 byte_swap_32 (digest_buf
[6]),
8524 byte_swap_32 (digest_buf
[7])
8527 else if (hash_mode
== 12900)
8529 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",
8538 byte_swap_32 (digest_buf
[0]),
8539 byte_swap_32 (digest_buf
[1]),
8540 byte_swap_32 (digest_buf
[2]),
8541 byte_swap_32 (digest_buf
[3]),
8542 byte_swap_32 (digest_buf
[4]),
8543 byte_swap_32 (digest_buf
[5]),
8544 byte_swap_32 (digest_buf
[6]),
8545 byte_swap_32 (digest_buf
[7]),
8552 else if (hash_mode
== 13000)
8554 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8556 rar5_t
*rar5
= &rar5s
[salt_pos
];
8558 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8568 byte_swap_32 (digest_buf
[0]),
8569 byte_swap_32 (digest_buf
[1])
8572 else if (hash_mode
== 13100)
8574 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8576 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8578 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8579 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8581 char data
[2560 * 4 * 2] = { 0 };
8583 char *ptr_data
= data
;
8585 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8586 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8591 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8592 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8594 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8596 (char *) krb5tgs
->account_info
,
8600 else if (hash_mode
== 13200)
8602 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8616 else if (hash_mode
== 13300)
8618 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8619 SIGNATURE_AXCRYPT_SHA1
,
8625 else if (hash_mode
== 13400)
8627 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8629 keepass_t
*keepass
= &keepasss
[salt_pos
];
8631 u32 version
= (u32
) keepass
->version
;
8632 u32 rounds
= salt
.salt_iter
;
8633 u32 algorithm
= (u32
) keepass
->algorithm
;
8634 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8636 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8637 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8638 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8639 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8640 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8642 /* specific to version 1 */
8646 /* specific to version 2 */
8647 u32 expected_bytes_len
;
8648 u32
*ptr_expected_bytes
;
8650 u32 final_random_seed_len
;
8651 u32 transf_random_seed_len
;
8653 u32 contents_hash_len
;
8655 transf_random_seed_len
= 8;
8657 contents_hash_len
= 8;
8658 final_random_seed_len
= 8;
8661 final_random_seed_len
= 4;
8663 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8669 char *ptr_data
= out_buf
;
8671 ptr_data
+= strlen(out_buf
);
8676 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8677 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8682 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8683 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8688 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8689 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8696 contents_len
= (u32
) keepass
->contents_len
;
8697 ptr_contents
= (u32
*) keepass
->contents
;
8699 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8700 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8712 char ptr_contents_len
[10] = { 0 };
8714 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8716 sprintf (ptr_data
, "%d", contents_len
);
8718 ptr_data
+= strlen(ptr_contents_len
);
8723 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8724 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8726 else if (version
== 2)
8728 expected_bytes_len
= 8;
8729 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8731 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8732 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8737 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8738 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8752 sprintf (ptr_data
, "%d", keyfile_len
);
8759 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8760 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8763 else if (hash_mode
== 13500)
8765 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8767 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8769 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8771 char pstoken_tmp
[1024 + 1] = { 0 };
8773 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8775 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8777 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8780 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8788 else if (hash_mode
== 13600)
8790 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8792 zip2_t
*zip2
= &zip2s
[salt_pos
];
8794 const u32 salt_len
= zip2
->salt_len
;
8796 char salt_tmp
[32 + 1] = { 0 };
8798 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8800 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8802 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8805 const u32 data_len
= zip2
->data_len
;
8807 char data_tmp
[8192 + 1] = { 0 };
8809 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8811 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8813 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8816 const u32 auth_len
= zip2
->auth_len
;
8818 char auth_tmp
[20 + 1] = { 0 };
8820 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8822 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8824 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8827 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8828 SIGNATURE_ZIP2_START
,
8834 zip2
->compress_length
,
8837 SIGNATURE_ZIP2_STOP
);
8839 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8841 snprintf (out_buf
, len
-1, "%s", hashfile
);
8843 else if (hash_mode
== 13800)
8845 win8phone_t
*esalts
= (win8phone_t
*) data
.esalts_buf
;
8847 win8phone_t
*esalt
= &esalts
[salt_pos
];
8849 char buf
[256 + 1] = { 0 };
8851 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
8853 sprintf (buf
+ j
, "%08x", esalt
->salt_buf
[i
]);
8856 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%s",
8869 if (hash_type
== HASH_TYPE_MD4
)
8871 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8877 else if (hash_type
== HASH_TYPE_MD5
)
8879 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8885 else if (hash_type
== HASH_TYPE_SHA1
)
8887 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8894 else if (hash_type
== HASH_TYPE_SHA256
)
8896 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8906 else if (hash_type
== HASH_TYPE_SHA384
)
8908 uint
*ptr
= digest_buf
;
8910 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8918 else if (hash_type
== HASH_TYPE_SHA512
)
8920 uint
*ptr
= digest_buf
;
8922 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8932 else if (hash_type
== HASH_TYPE_LM
)
8934 snprintf (out_buf
, len
-1, "%08x%08x",
8938 else if (hash_type
== HASH_TYPE_ORACLEH
)
8940 snprintf (out_buf
, len
-1, "%08X%08X",
8944 else if (hash_type
== HASH_TYPE_BCRYPT
)
8946 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8947 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8949 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8951 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8953 else if (hash_type
== HASH_TYPE_KECCAK
)
8955 uint
*ptr
= digest_buf
;
8957 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",
8985 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8987 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8989 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8996 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8998 digest_buf
[ 0] = digest_buf
[ 0];
8999 digest_buf
[ 1] = digest_buf
[ 1];
9000 digest_buf
[ 2] = digest_buf
[ 2];
9001 digest_buf
[ 3] = digest_buf
[ 3];
9002 digest_buf
[ 4] = digest_buf
[ 4];
9003 digest_buf
[ 5] = digest_buf
[ 5];
9004 digest_buf
[ 6] = digest_buf
[ 6];
9005 digest_buf
[ 7] = digest_buf
[ 7];
9006 digest_buf
[ 8] = digest_buf
[ 8];
9007 digest_buf
[ 9] = digest_buf
[ 9];
9008 digest_buf
[10] = digest_buf
[10];
9009 digest_buf
[11] = digest_buf
[11];
9010 digest_buf
[12] = digest_buf
[12];
9011 digest_buf
[13] = digest_buf
[13];
9012 digest_buf
[14] = digest_buf
[14];
9013 digest_buf
[15] = digest_buf
[15];
9015 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
9033 else if (hash_type
== HASH_TYPE_GOST
)
9035 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
9045 else if (hash_type
== HASH_TYPE_MYSQL
)
9047 snprintf (out_buf
, len
-1, "%08x%08x",
9051 else if (hash_type
== HASH_TYPE_LOTUS5
)
9053 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
9059 else if (hash_type
== HASH_TYPE_LOTUS6
)
9061 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
9062 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
9063 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
9064 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
9066 char buf
[16] = { 0 };
9068 memcpy (buf
+ 0, salt
.salt_buf
, 5);
9069 memcpy (buf
+ 5, digest_buf
, 9);
9073 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
9075 tmp_buf
[18] = salt
.salt_buf_pc
[7];
9078 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
9080 else if (hash_type
== HASH_TYPE_LOTUS8
)
9082 char buf
[52] = { 0 };
9086 memcpy (buf
+ 0, salt
.salt_buf
, 16);
9092 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
9096 buf
[26] = salt
.salt_buf_pc
[0];
9097 buf
[27] = salt
.salt_buf_pc
[1];
9101 memcpy (buf
+ 28, digest_buf
, 8);
9103 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9107 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9109 else if (hash_type
== HASH_TYPE_CRC32
)
9111 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9115 if (salt_type
== SALT_TYPE_INTERN
)
9117 size_t pos
= strlen (out_buf
);
9119 out_buf
[pos
] = data
.separator
;
9121 char *ptr
= (char *) salt
.salt_buf
;
9123 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9125 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9129 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9131 memset (hccap
, 0, sizeof (hccap_t
));
9133 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9135 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9137 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9138 wpa_t
*wpa
= &wpas
[salt_pos
];
9140 hccap
->keyver
= wpa
->keyver
;
9142 hccap
->eapol_size
= wpa
->eapol_size
;
9144 if (wpa
->keyver
!= 1)
9146 uint eapol_tmp
[64] = { 0 };
9148 for (uint i
= 0; i
< 64; i
++)
9150 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9153 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9157 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9160 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9161 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9162 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9163 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9165 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9167 uint dgst_size
= data
.dgst_size
;
9169 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9171 if (wpa
->keyver
!= 1)
9173 uint digest_tmp
[4] = { 0 };
9175 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9176 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9177 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9178 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9180 memcpy (hccap
->keymic
, digest_tmp
, 16);
9184 memcpy (hccap
->keymic
, digest_ptr
, 16);
9188 void SuspendThreads ()
9190 if (data
.devices_status
!= STATUS_RUNNING
) return;
9192 hc_timer_set (&data
.timer_paused
);
9194 data
.devices_status
= STATUS_PAUSED
;
9196 log_info ("Paused");
9199 void ResumeThreads ()
9201 if (data
.devices_status
!= STATUS_PAUSED
) return;
9205 hc_timer_get (data
.timer_paused
, ms_paused
);
9207 data
.ms_paused
+= ms_paused
;
9209 data
.devices_status
= STATUS_RUNNING
;
9211 log_info ("Resumed");
9216 data
.devices_status
= STATUS_BYPASS
;
9218 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9221 void stop_at_checkpoint ()
9223 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9225 if (data
.devices_status
!= STATUS_RUNNING
) return;
9228 // this feature only makes sense if --restore-disable was not specified
9230 if (data
.restore_disable
== 1)
9232 log_info ("WARNING: This feature is disabled when --restore-disable is specified");
9237 // check if monitoring of Restore Point updates should be enabled or disabled
9239 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9241 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9243 // save the current restore point value
9245 data
.checkpoint_cur_words
= get_lowest_words_done ();
9247 log_info ("Checkpoint enabled: Will quit at next Restore Point update");
9251 data
.devices_status
= STATUS_RUNNING
;
9253 // reset the global value for checkpoint checks
9255 data
.checkpoint_cur_words
= 0;
9257 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9263 data
.devices_status
= STATUS_ABORTED
;
9268 data
.devices_status
= STATUS_QUIT
;
9271 void naive_replace (char *s
, const u8 key_char
, const u8 replace_char
)
9273 const size_t len
= strlen (s
);
9275 for (size_t in
= 0; in
< len
; in
++)
9281 s
[in
] = replace_char
;
9286 void naive_escape (char *s
, size_t s_max
, const u8 key_char
, const u8 escape_char
)
9288 char s_escaped
[1024] = { 0 };
9290 size_t s_escaped_max
= sizeof (s_escaped
);
9292 const size_t len
= strlen (s
);
9294 for (size_t in
= 0, out
= 0; in
< len
; in
++, out
++)
9300 s_escaped
[out
] = escape_char
;
9305 if (out
== s_escaped_max
- 2) break;
9310 strncpy (s
, s_escaped
, s_max
- 1);
9313 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9315 FILE *fp
= fopen (kernel_file
, "rb");
9321 memset (&st
, 0, sizeof (st
));
9323 stat (kernel_file
, &st
);
9325 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9327 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9329 if (num_read
!= (size_t) st
.st_size
)
9331 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9338 buf
[st
.st_size
] = 0;
9340 for (int i
= 0; i
< num_devices
; i
++)
9342 kernel_lengths
[i
] = (size_t) st
.st_size
;
9344 kernel_sources
[i
] = buf
;
9349 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9357 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9359 if (binary_size
> 0)
9361 FILE *fp
= fopen (dst
, "wb");
9364 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9375 restore_data_t
*init_restore (int argc
, char **argv
)
9377 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9379 if (data
.restore_disable
== 0)
9381 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9385 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9389 log_error ("ERROR: Cannot read %s", data
.eff_restore_file
);
9398 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9400 int pidbin_len
= -1;
9403 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9405 FILE *fd
= fopen (pidbin
, "rb");
9409 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9411 pidbin
[pidbin_len
] = 0;
9415 char *argv0_r
= strrchr (argv
[0], '/');
9417 char *pidbin_r
= strrchr (pidbin
, '/');
9419 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9421 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9423 if (strcmp (argv0_r
, pidbin_r
) == 0)
9425 log_error ("ERROR: Already an instance %s running on pid %d", pidbin
, rd
->pid
);
9432 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9434 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9436 int pidbin2_len
= -1;
9438 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9439 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9441 pidbin
[pidbin_len
] = 0;
9442 pidbin2
[pidbin2_len
] = 0;
9446 if (strcmp (pidbin
, pidbin2
) == 0)
9448 log_error ("ERROR: Already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9461 if (rd
->version_bin
< RESTORE_MIN
)
9463 log_error ("ERROR: Cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9470 memset (rd
, 0, sizeof (restore_data_t
));
9472 rd
->version_bin
= VERSION_BIN
;
9475 rd
->pid
= getpid ();
9477 rd
->pid
= GetCurrentProcessId ();
9480 if (getcwd (rd
->cwd
, 255) == NULL
)
9493 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9495 FILE *fp
= fopen (eff_restore_file
, "rb");
9499 log_error ("ERROR: Restore file '%s': %s", eff_restore_file
, strerror (errno
));
9504 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9506 log_error ("ERROR: Can't read %s", eff_restore_file
);
9511 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9513 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9515 for (uint i
= 0; i
< rd
->argc
; i
++)
9517 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9519 log_error ("ERROR: Can't read %s", eff_restore_file
);
9524 size_t len
= strlen (buf
);
9526 if (len
) buf
[len
- 1] = 0;
9528 rd
->argv
[i
] = mystrdup (buf
);
9535 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9537 if (chdir (rd
->cwd
))
9539 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9540 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9541 " https://github.com/philsmd/analyze_hc_restore\n"
9542 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9548 u64
get_lowest_words_done ()
9552 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9554 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9556 if (device_param
->skipped
) continue;
9558 const u64 words_done
= device_param
->words_done
;
9560 if (words_done
< words_cur
) words_cur
= words_done
;
9563 // It's possible that a device's workload isn't finished right after a restore-case.
9564 // In that case, this function would return 0 and overwrite the real restore point
9565 // There's also data.words_cur which is set to rd->words_cur but it changes while
9566 // the attack is running therefore we should stick to rd->words_cur.
9567 // Note that -s influences rd->words_cur we should keep a close look on that.
9569 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9574 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9576 u64 words_cur
= get_lowest_words_done ();
9578 rd
->words_cur
= words_cur
;
9580 FILE *fp
= fopen (new_restore_file
, "wb");
9584 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9589 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9591 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9596 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9598 for (uint i
= 0; i
< rd
->argc
; i
++)
9600 fprintf (fp
, "%s", rd
->argv
[i
]);
9606 fsync (fileno (fp
));
9611 void cycle_restore ()
9613 const char *eff_restore_file
= data
.eff_restore_file
;
9614 const char *new_restore_file
= data
.new_restore_file
;
9616 restore_data_t
*rd
= data
.rd
;
9618 write_restore (new_restore_file
, rd
);
9622 memset (&st
, 0, sizeof(st
));
9624 if (stat (eff_restore_file
, &st
) == 0)
9626 if (unlink (eff_restore_file
))
9628 log_info ("WARN: Unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9632 if (rename (new_restore_file
, eff_restore_file
))
9634 log_info ("WARN: Rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9638 void check_checkpoint ()
9640 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9642 u64 words_cur
= get_lowest_words_done ();
9644 if (words_cur
!= data
.checkpoint_cur_words
)
9654 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9658 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9660 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9662 myfree (alias
->device_name
);
9663 myfree (alias
->alias_name
);
9666 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9668 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9670 myfree (entry
->device_name
);
9673 myfree (tuning_db
->alias_buf
);
9674 myfree (tuning_db
->entry_buf
);
9679 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9681 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9683 int num_lines
= count_lines (fp
);
9685 // a bit over-allocated
9687 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9688 tuning_db
->alias_cnt
= 0;
9690 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9691 tuning_db
->entry_cnt
= 0;
9696 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9698 FILE *fp
= fopen (tuning_db_file
, "rb");
9702 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9707 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9713 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9717 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9719 if (line_buf
== NULL
) break;
9723 const int line_len
= in_superchop (line_buf
);
9725 if (line_len
== 0) continue;
9727 if (line_buf
[0] == '#') continue;
9731 char *token_ptr
[7] = { NULL
};
9735 char *next
= strtok (line_buf
, "\t ");
9737 token_ptr
[token_cnt
] = next
;
9741 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9743 token_ptr
[token_cnt
] = next
;
9750 char *device_name
= token_ptr
[0];
9751 char *alias_name
= token_ptr
[1];
9753 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9755 alias
->device_name
= mystrdup (device_name
);
9756 alias
->alias_name
= mystrdup (alias_name
);
9758 tuning_db
->alias_cnt
++;
9760 else if (token_cnt
== 6)
9762 if ((token_ptr
[1][0] != '0') &&
9763 (token_ptr
[1][0] != '1') &&
9764 (token_ptr
[1][0] != '3') &&
9765 (token_ptr
[1][0] != '*'))
9767 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9772 if ((token_ptr
[3][0] != '1') &&
9773 (token_ptr
[3][0] != '2') &&
9774 (token_ptr
[3][0] != '4') &&
9775 (token_ptr
[3][0] != '8') &&
9776 (token_ptr
[3][0] != 'N'))
9778 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9783 char *device_name
= token_ptr
[0];
9785 int attack_mode
= -1;
9787 int vector_width
= -1;
9788 int kernel_accel
= -1;
9789 int kernel_loops
= -1;
9791 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9792 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9793 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9795 if (token_ptr
[4][0] != 'A')
9797 kernel_accel
= atoi (token_ptr
[4]);
9799 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9801 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9811 if (token_ptr
[5][0] != 'A')
9813 kernel_loops
= atoi (token_ptr
[5]);
9815 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9817 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9827 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9829 entry
->device_name
= mystrdup (device_name
);
9830 entry
->attack_mode
= attack_mode
;
9831 entry
->hash_type
= hash_type
;
9832 entry
->vector_width
= vector_width
;
9833 entry
->kernel_accel
= kernel_accel
;
9834 entry
->kernel_loops
= kernel_loops
;
9836 tuning_db
->entry_cnt
++;
9840 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9850 // todo: print loaded 'cnt' message
9852 // sort the database
9854 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9855 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9860 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9862 static tuning_db_entry_t s
;
9864 // first we need to convert all spaces in the device_name to underscore
9866 char *device_name_nospace
= strdup (device_param
->device_name
);
9868 int device_name_length
= strlen (device_name_nospace
);
9872 for (i
= 0; i
< device_name_length
; i
++)
9874 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9877 // find out if there's an alias configured
9879 tuning_db_alias_t a
;
9881 a
.device_name
= device_name_nospace
;
9883 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
);
9885 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9887 // attack-mode 6 and 7 are attack-mode 1 basically
9889 if (attack_mode
== 6) attack_mode
= 1;
9890 if (attack_mode
== 7) attack_mode
= 1;
9892 // bsearch is not ideal but fast enough
9894 s
.device_name
= device_name_nospace
;
9895 s
.attack_mode
= attack_mode
;
9896 s
.hash_type
= hash_type
;
9898 tuning_db_entry_t
*entry
= NULL
;
9900 // this will produce all 2^3 combinations required
9902 for (i
= 0; i
< 8; i
++)
9904 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9905 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9906 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9908 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9910 if (entry
!= NULL
) break;
9912 // in non-wildcard mode do some additional checks:
9916 // in case we have an alias-name
9918 if (alias_name
!= NULL
)
9920 s
.device_name
= alias_name
;
9922 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9924 if (entry
!= NULL
) break;
9927 // or by device type
9929 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9931 s
.device_name
= "DEVICE_TYPE_CPU";
9933 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9935 s
.device_name
= "DEVICE_TYPE_GPU";
9937 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9939 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9942 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9944 if (entry
!= NULL
) break;
9948 // free converted device_name
9950 myfree (device_name_nospace
);
9959 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9961 u8 tmp
[256] = { 0 };
9963 if (salt_len
> sizeof (tmp
))
9968 memcpy (tmp
, in
, salt_len
);
9970 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9972 if ((salt_len
% 2) == 0)
9974 u32 new_salt_len
= salt_len
/ 2;
9976 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9981 tmp
[i
] = hex_convert (p1
) << 0;
9982 tmp
[i
] |= hex_convert (p0
) << 4;
9985 salt_len
= new_salt_len
;
9992 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9994 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9997 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9999 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
10003 u32
*tmp_uint
= (u32
*) tmp
;
10005 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
10006 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
10007 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
10008 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
10009 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
10010 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
10011 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
10012 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
10013 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
10014 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
10016 salt_len
= salt_len
* 2;
10024 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
10026 lowercase (tmp
, salt_len
);
10029 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
10031 uppercase (tmp
, salt_len
);
10034 u32 len
= salt_len
;
10036 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
10041 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
10046 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
10048 u32
*tmp_uint
= (uint
*) tmp
;
10052 if (len
% 4) max
++;
10054 for (u32 i
= 0; i
< max
; i
++)
10056 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
10059 // Important: we may need to increase the length of memcpy since
10060 // we don't want to "loose" some swapped bytes (could happen if
10061 // they do not perfectly fit in the 4-byte blocks)
10062 // Memcpy does always copy the bytes in the BE order, but since
10063 // we swapped them, some important bytes could be in positions
10064 // we normally skip with the original len
10066 if (len
% 4) len
+= 4 - (len
% 4);
10069 memcpy (out
, tmp
, len
);
10074 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10076 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
10078 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
10080 u32
*digest
= (u32
*) hash_buf
->digest
;
10082 salt_t
*salt
= hash_buf
->salt
;
10084 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
10086 char *iter_pos
= input_buf
+ 4;
10088 salt
->salt_iter
= 1 << atoi (iter_pos
);
10090 char *salt_pos
= strchr (iter_pos
, '$');
10092 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10096 uint salt_len
= 16;
10098 salt
->salt_len
= salt_len
;
10100 u8 tmp_buf
[100] = { 0 };
10102 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
10104 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10106 memcpy (salt_buf_ptr
, tmp_buf
, 16);
10108 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
10109 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
10110 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
10111 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
10113 char *hash_pos
= salt_pos
+ 22;
10115 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10117 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
10119 memcpy (digest
, tmp_buf
, 24);
10121 digest
[0] = byte_swap_32 (digest
[0]);
10122 digest
[1] = byte_swap_32 (digest
[1]);
10123 digest
[2] = byte_swap_32 (digest
[2]);
10124 digest
[3] = byte_swap_32 (digest
[3]);
10125 digest
[4] = byte_swap_32 (digest
[4]);
10126 digest
[5] = byte_swap_32 (digest
[5]);
10128 digest
[5] &= ~0xff; // its just 23 not 24 !
10130 return (PARSER_OK
);
10133 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10135 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10137 u32
*digest
= (u32
*) hash_buf
->digest
;
10139 u8 tmp_buf
[100] = { 0 };
10141 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10143 memcpy (digest
, tmp_buf
, 32);
10145 digest
[0] = byte_swap_32 (digest
[0]);
10146 digest
[1] = byte_swap_32 (digest
[1]);
10147 digest
[2] = byte_swap_32 (digest
[2]);
10148 digest
[3] = byte_swap_32 (digest
[3]);
10149 digest
[4] = byte_swap_32 (digest
[4]);
10150 digest
[5] = byte_swap_32 (digest
[5]);
10151 digest
[6] = byte_swap_32 (digest
[6]);
10152 digest
[7] = byte_swap_32 (digest
[7]);
10154 digest
[0] -= SHA256M_A
;
10155 digest
[1] -= SHA256M_B
;
10156 digest
[2] -= SHA256M_C
;
10157 digest
[3] -= SHA256M_D
;
10158 digest
[4] -= SHA256M_E
;
10159 digest
[5] -= SHA256M_F
;
10160 digest
[6] -= SHA256M_G
;
10161 digest
[7] -= SHA256M_H
;
10163 return (PARSER_OK
);
10166 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10168 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10170 u32
*digest
= (u32
*) hash_buf
->digest
;
10172 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10173 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10175 digest
[0] = byte_swap_32 (digest
[0]);
10176 digest
[1] = byte_swap_32 (digest
[1]);
10180 IP (digest
[0], digest
[1], tt
);
10182 digest
[0] = digest
[0];
10183 digest
[1] = digest
[1];
10187 return (PARSER_OK
);
10190 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10192 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10194 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10196 u32
*digest
= (u32
*) hash_buf
->digest
;
10198 salt_t
*salt
= hash_buf
->salt
;
10200 char *hash_pos
= input_buf
+ 10;
10202 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10203 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10204 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10205 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10206 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10208 digest
[0] -= SHA1M_A
;
10209 digest
[1] -= SHA1M_B
;
10210 digest
[2] -= SHA1M_C
;
10211 digest
[3] -= SHA1M_D
;
10212 digest
[4] -= SHA1M_E
;
10214 uint salt_len
= 10;
10216 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10218 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10220 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10222 salt
->salt_len
= salt_len
;
10224 return (PARSER_OK
);
10227 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10229 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10231 u32
*digest
= (u32
*) hash_buf
->digest
;
10233 salt_t
*salt
= hash_buf
->salt
;
10235 char *hash_pos
= input_buf
+ 8;
10237 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10238 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10239 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10240 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10241 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10243 digest
[0] -= SHA1M_A
;
10244 digest
[1] -= SHA1M_B
;
10245 digest
[2] -= SHA1M_C
;
10246 digest
[3] -= SHA1M_D
;
10247 digest
[4] -= SHA1M_E
;
10251 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10253 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10255 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10257 salt
->salt_len
= salt_len
;
10259 return (PARSER_OK
);
10262 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10264 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10266 u64
*digest
= (u64
*) hash_buf
->digest
;
10268 salt_t
*salt
= hash_buf
->salt
;
10270 char *hash_pos
= input_buf
+ 8;
10272 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10273 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10274 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10275 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10276 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10277 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10278 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10279 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10281 digest
[0] -= SHA512M_A
;
10282 digest
[1] -= SHA512M_B
;
10283 digest
[2] -= SHA512M_C
;
10284 digest
[3] -= SHA512M_D
;
10285 digest
[4] -= SHA512M_E
;
10286 digest
[5] -= SHA512M_F
;
10287 digest
[6] -= SHA512M_G
;
10288 digest
[7] -= SHA512M_H
;
10292 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10294 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10296 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10298 salt
->salt_len
= salt_len
;
10300 return (PARSER_OK
);
10303 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10305 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10307 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10311 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10314 u32
*digest
= (u32
*) hash_buf
->digest
;
10316 salt_t
*salt
= hash_buf
->salt
;
10318 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10319 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10320 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10321 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10323 digest
[0] = byte_swap_32 (digest
[0]);
10324 digest
[1] = byte_swap_32 (digest
[1]);
10325 digest
[2] = byte_swap_32 (digest
[2]);
10326 digest
[3] = byte_swap_32 (digest
[3]);
10328 digest
[0] -= MD5M_A
;
10329 digest
[1] -= MD5M_B
;
10330 digest
[2] -= MD5M_C
;
10331 digest
[3] -= MD5M_D
;
10333 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10335 uint salt_len
= input_len
- 32 - 1;
10337 char *salt_buf
= input_buf
+ 32 + 1;
10339 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10341 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10343 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10345 salt
->salt_len
= salt_len
;
10347 return (PARSER_OK
);
10350 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10352 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10354 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10358 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10363 char clean_input_buf
[32] = { 0 };
10365 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10366 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10368 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10372 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10378 clean_input_buf
[k
] = input_buf
[i
];
10386 u32
*digest
= (u32
*) hash_buf
->digest
;
10388 salt_t
*salt
= hash_buf
->salt
;
10390 u32 a
, b
, c
, d
, e
, f
;
10392 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10393 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10394 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10395 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10396 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10397 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10399 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10400 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10402 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10403 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10404 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10405 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10406 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10407 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10409 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10410 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10412 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10413 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10414 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10415 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10416 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10417 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10419 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10420 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10422 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10423 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10424 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10425 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10426 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10427 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10429 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10430 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10432 digest
[0] = byte_swap_32 (digest
[0]);
10433 digest
[1] = byte_swap_32 (digest
[1]);
10434 digest
[2] = byte_swap_32 (digest
[2]);
10435 digest
[3] = byte_swap_32 (digest
[3]);
10437 digest
[0] -= MD5M_A
;
10438 digest
[1] -= MD5M_B
;
10439 digest
[2] -= MD5M_C
;
10440 digest
[3] -= MD5M_D
;
10442 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10444 uint salt_len
= input_len
- 30 - 1;
10446 char *salt_buf
= input_buf
+ 30 + 1;
10448 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10450 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10452 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10453 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10455 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10457 salt
->salt_len
= salt_len
;
10459 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10461 salt
->salt_len
+= 22;
10463 return (PARSER_OK
);
10466 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10468 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10470 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10474 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10477 u32
*digest
= (u32
*) hash_buf
->digest
;
10479 salt_t
*salt
= hash_buf
->salt
;
10481 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10482 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10483 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10484 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10485 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10487 digest
[0] -= SHA1M_A
;
10488 digest
[1] -= SHA1M_B
;
10489 digest
[2] -= SHA1M_C
;
10490 digest
[3] -= SHA1M_D
;
10491 digest
[4] -= SHA1M_E
;
10493 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10495 uint salt_len
= input_len
- 40 - 1;
10497 char *salt_buf
= input_buf
+ 40 + 1;
10499 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10501 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10503 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10505 salt
->salt_len
= salt_len
;
10507 return (PARSER_OK
);
10510 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10512 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10514 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10518 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10521 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10523 char *iter_pos
= input_buf
+ 6;
10525 salt_t
*salt
= hash_buf
->salt
;
10527 uint iter
= atoi (iter_pos
);
10531 iter
= ROUNDS_DCC2
;
10534 salt
->salt_iter
= iter
- 1;
10536 char *salt_pos
= strchr (iter_pos
, '#');
10538 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10542 char *digest_pos
= strchr (salt_pos
, '#');
10544 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10548 uint salt_len
= digest_pos
- salt_pos
- 1;
10550 u32
*digest
= (u32
*) hash_buf
->digest
;
10552 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10553 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10554 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10555 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10557 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10559 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10561 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10563 salt
->salt_len
= salt_len
;
10565 return (PARSER_OK
);
10568 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10570 u32
*digest
= (u32
*) hash_buf
->digest
;
10572 salt_t
*salt
= hash_buf
->salt
;
10574 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10578 memcpy (&in
, input_buf
, input_len
);
10580 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10582 memcpy (digest
, in
.keymic
, 16);
10585 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10586 The phrase "Pairwise key expansion"
10587 Access Point Address (referred to as Authenticator Address AA)
10588 Supplicant Address (referred to as Supplicant Address SA)
10589 Access Point Nonce (referred to as Authenticator Anonce)
10590 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10593 uint salt_len
= strlen (in
.essid
);
10597 log_info ("WARNING: The ESSID length is too long, the hccap file may be invalid or corrupted");
10599 return (PARSER_SALT_LENGTH
);
10602 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10604 salt
->salt_len
= salt_len
;
10606 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10608 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10610 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10612 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10614 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10615 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10619 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10620 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10623 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10625 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10626 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10630 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10631 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10634 for (int i
= 0; i
< 25; i
++)
10636 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10639 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10640 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10641 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10642 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10644 wpa
->keyver
= in
.keyver
;
10646 if (wpa
->keyver
> 255)
10648 log_info ("ATTENTION!");
10649 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10650 log_info (" This could be due to a recent aircrack-ng bug.");
10651 log_info (" The key version was automatically reset to a reasonable value.");
10654 wpa
->keyver
&= 0xff;
10657 wpa
->eapol_size
= in
.eapol_size
;
10659 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10661 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10663 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10665 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10667 if (wpa
->keyver
== 1)
10673 digest
[0] = byte_swap_32 (digest
[0]);
10674 digest
[1] = byte_swap_32 (digest
[1]);
10675 digest
[2] = byte_swap_32 (digest
[2]);
10676 digest
[3] = byte_swap_32 (digest
[3]);
10678 for (int i
= 0; i
< 64; i
++)
10680 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10684 uint32_t *p0
= (uint32_t *) in
.essid
;
10688 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10689 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10691 salt
->salt_buf
[10] = c0
;
10692 salt
->salt_buf
[11] = c1
;
10694 return (PARSER_OK
);
10697 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10699 u32
*digest
= (u32
*) hash_buf
->digest
;
10701 salt_t
*salt
= hash_buf
->salt
;
10703 if (input_len
== 0)
10705 log_error ("Password Safe v2 container not specified");
10710 FILE *fp
= fopen (input_buf
, "rb");
10714 log_error ("%s: %s", input_buf
, strerror (errno
));
10721 memset (&buf
, 0, sizeof (psafe2_hdr
));
10723 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10727 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10729 salt
->salt_buf
[0] = buf
.random
[0];
10730 salt
->salt_buf
[1] = buf
.random
[1];
10732 salt
->salt_len
= 8;
10733 salt
->salt_iter
= 1000;
10735 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10736 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10737 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10738 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10739 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10741 return (PARSER_OK
);
10744 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10746 u32
*digest
= (u32
*) hash_buf
->digest
;
10748 salt_t
*salt
= hash_buf
->salt
;
10750 if (input_len
== 0)
10752 log_error (".psafe3 not specified");
10757 FILE *fp
= fopen (input_buf
, "rb");
10761 log_error ("%s: %s", input_buf
, strerror (errno
));
10768 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10772 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10774 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10776 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10778 salt
->salt_iter
= in
.iterations
+ 1;
10780 salt
->salt_buf
[0] = in
.salt_buf
[0];
10781 salt
->salt_buf
[1] = in
.salt_buf
[1];
10782 salt
->salt_buf
[2] = in
.salt_buf
[2];
10783 salt
->salt_buf
[3] = in
.salt_buf
[3];
10784 salt
->salt_buf
[4] = in
.salt_buf
[4];
10785 salt
->salt_buf
[5] = in
.salt_buf
[5];
10786 salt
->salt_buf
[6] = in
.salt_buf
[6];
10787 salt
->salt_buf
[7] = in
.salt_buf
[7];
10789 salt
->salt_len
= 32;
10791 digest
[0] = in
.hash_buf
[0];
10792 digest
[1] = in
.hash_buf
[1];
10793 digest
[2] = in
.hash_buf
[2];
10794 digest
[3] = in
.hash_buf
[3];
10795 digest
[4] = in
.hash_buf
[4];
10796 digest
[5] = in
.hash_buf
[5];
10797 digest
[6] = in
.hash_buf
[6];
10798 digest
[7] = in
.hash_buf
[7];
10800 digest
[0] = byte_swap_32 (digest
[0]);
10801 digest
[1] = byte_swap_32 (digest
[1]);
10802 digest
[2] = byte_swap_32 (digest
[2]);
10803 digest
[3] = byte_swap_32 (digest
[3]);
10804 digest
[4] = byte_swap_32 (digest
[4]);
10805 digest
[5] = byte_swap_32 (digest
[5]);
10806 digest
[6] = byte_swap_32 (digest
[6]);
10807 digest
[7] = byte_swap_32 (digest
[7]);
10809 return (PARSER_OK
);
10812 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10814 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10816 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10818 u32
*digest
= (u32
*) hash_buf
->digest
;
10820 salt_t
*salt
= hash_buf
->salt
;
10822 char *iter_pos
= input_buf
+ 3;
10824 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10826 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10828 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10830 salt
->salt_iter
= salt_iter
;
10832 char *salt_pos
= iter_pos
+ 1;
10836 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10838 salt
->salt_len
= salt_len
;
10840 char *hash_pos
= salt_pos
+ salt_len
;
10842 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10844 return (PARSER_OK
);
10847 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10849 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10851 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10853 u32
*digest
= (u32
*) hash_buf
->digest
;
10855 salt_t
*salt
= hash_buf
->salt
;
10857 char *salt_pos
= input_buf
+ 3;
10859 uint iterations_len
= 0;
10861 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10865 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10867 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10868 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10872 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10876 iterations_len
+= 8;
10880 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10883 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10885 char *hash_pos
= strchr (salt_pos
, '$');
10887 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10889 uint salt_len
= hash_pos
- salt_pos
;
10891 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10893 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10895 salt
->salt_len
= salt_len
;
10899 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10901 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10903 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10905 return (PARSER_OK
);
10908 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10910 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10912 u32
*digest
= (u32
*) hash_buf
->digest
;
10914 salt_t
*salt
= hash_buf
->salt
;
10916 char *salt_pos
= input_buf
+ 6;
10918 uint iterations_len
= 0;
10920 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10924 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10926 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10927 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10931 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10935 iterations_len
+= 8;
10939 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10942 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10944 char *hash_pos
= strchr (salt_pos
, '$');
10946 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10948 uint salt_len
= hash_pos
- salt_pos
;
10950 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10952 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10954 salt
->salt_len
= salt_len
;
10958 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10960 return (PARSER_OK
);
10963 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10965 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10967 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10969 u32
*digest
= (u32
*) hash_buf
->digest
;
10971 salt_t
*salt
= hash_buf
->salt
;
10973 char *salt_pos
= input_buf
+ 14;
10975 char *hash_pos
= strchr (salt_pos
, '*');
10977 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10981 uint salt_len
= hash_pos
- salt_pos
- 1;
10983 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10985 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10987 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10989 salt
->salt_len
= salt_len
;
10991 u8 tmp_buf
[100] = { 0 };
10993 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10995 memcpy (digest
, tmp_buf
, 20);
10997 digest
[0] = byte_swap_32 (digest
[0]);
10998 digest
[1] = byte_swap_32 (digest
[1]);
10999 digest
[2] = byte_swap_32 (digest
[2]);
11000 digest
[3] = byte_swap_32 (digest
[3]);
11001 digest
[4] = byte_swap_32 (digest
[4]);
11003 digest
[0] -= SHA1M_A
;
11004 digest
[1] -= SHA1M_B
;
11005 digest
[2] -= SHA1M_C
;
11006 digest
[3] -= SHA1M_D
;
11007 digest
[4] -= SHA1M_E
;
11009 return (PARSER_OK
);
11012 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11014 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
11016 unsigned char c12
= itoa64_to_int (input_buf
[12]);
11018 if (c12
& 3) return (PARSER_HASH_VALUE
);
11020 u32
*digest
= (u32
*) hash_buf
->digest
;
11022 salt_t
*salt
= hash_buf
->salt
;
11024 // for ascii_digest
11025 salt
->salt_sign
[0] = input_buf
[0];
11026 salt
->salt_sign
[1] = input_buf
[1];
11028 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
11029 | itoa64_to_int (input_buf
[1]) << 6;
11031 salt
->salt_len
= 2;
11033 u8 tmp_buf
[100] = { 0 };
11035 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
11037 memcpy (digest
, tmp_buf
, 8);
11041 IP (digest
[0], digest
[1], tt
);
11046 return (PARSER_OK
);
11049 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11051 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
11053 u32
*digest
= (u32
*) hash_buf
->digest
;
11055 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11056 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11057 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11058 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11060 digest
[0] = byte_swap_32 (digest
[0]);
11061 digest
[1] = byte_swap_32 (digest
[1]);
11062 digest
[2] = byte_swap_32 (digest
[2]);
11063 digest
[3] = byte_swap_32 (digest
[3]);
11065 digest
[0] -= MD4M_A
;
11066 digest
[1] -= MD4M_B
;
11067 digest
[2] -= MD4M_C
;
11068 digest
[3] -= MD4M_D
;
11070 return (PARSER_OK
);
11073 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11075 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11077 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
11081 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
11084 u32
*digest
= (u32
*) hash_buf
->digest
;
11086 salt_t
*salt
= hash_buf
->salt
;
11088 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11089 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11090 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11091 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11093 digest
[0] = byte_swap_32 (digest
[0]);
11094 digest
[1] = byte_swap_32 (digest
[1]);
11095 digest
[2] = byte_swap_32 (digest
[2]);
11096 digest
[3] = byte_swap_32 (digest
[3]);
11098 digest
[0] -= MD4M_A
;
11099 digest
[1] -= MD4M_B
;
11100 digest
[2] -= MD4M_C
;
11101 digest
[3] -= MD4M_D
;
11103 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11105 uint salt_len
= input_len
- 32 - 1;
11107 char *salt_buf
= input_buf
+ 32 + 1;
11109 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11111 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11113 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11115 salt
->salt_len
= salt_len
;
11117 return (PARSER_OK
);
11120 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11122 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
11124 u32
*digest
= (u32
*) hash_buf
->digest
;
11126 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11127 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11128 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11129 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11131 digest
[0] = byte_swap_32 (digest
[0]);
11132 digest
[1] = byte_swap_32 (digest
[1]);
11133 digest
[2] = byte_swap_32 (digest
[2]);
11134 digest
[3] = byte_swap_32 (digest
[3]);
11136 digest
[0] -= MD5M_A
;
11137 digest
[1] -= MD5M_B
;
11138 digest
[2] -= MD5M_C
;
11139 digest
[3] -= MD5M_D
;
11141 return (PARSER_OK
);
11144 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11146 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11148 u32
*digest
= (u32
*) hash_buf
->digest
;
11150 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11151 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11155 digest
[0] = byte_swap_32 (digest
[0]);
11156 digest
[1] = byte_swap_32 (digest
[1]);
11158 return (PARSER_OK
);
11161 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11163 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11165 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11169 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11172 u32
*digest
= (u32
*) hash_buf
->digest
;
11174 salt_t
*salt
= hash_buf
->salt
;
11176 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11177 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11178 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11179 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11181 digest
[0] = byte_swap_32 (digest
[0]);
11182 digest
[1] = byte_swap_32 (digest
[1]);
11183 digest
[2] = byte_swap_32 (digest
[2]);
11184 digest
[3] = byte_swap_32 (digest
[3]);
11186 digest
[0] -= MD5M_A
;
11187 digest
[1] -= MD5M_B
;
11188 digest
[2] -= MD5M_C
;
11189 digest
[3] -= MD5M_D
;
11191 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11193 uint salt_len
= input_len
- 32 - 1;
11195 char *salt_buf
= input_buf
+ 32 + 1;
11197 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11199 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11201 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11203 salt
->salt_len
= salt_len
;
11205 return (PARSER_OK
);
11208 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11210 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11212 u32
*digest
= (u32
*) hash_buf
->digest
;
11214 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11215 | itoa64_to_int (input_buf
[ 1]) << 6
11216 | itoa64_to_int (input_buf
[ 2]) << 12
11217 | itoa64_to_int (input_buf
[ 3]) << 18;
11218 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11219 | itoa64_to_int (input_buf
[ 5]) << 6
11220 | itoa64_to_int (input_buf
[ 6]) << 12
11221 | itoa64_to_int (input_buf
[ 7]) << 18;
11222 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11223 | itoa64_to_int (input_buf
[ 9]) << 6
11224 | itoa64_to_int (input_buf
[10]) << 12
11225 | itoa64_to_int (input_buf
[11]) << 18;
11226 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11227 | itoa64_to_int (input_buf
[13]) << 6
11228 | itoa64_to_int (input_buf
[14]) << 12
11229 | itoa64_to_int (input_buf
[15]) << 18;
11231 digest
[0] -= MD5M_A
;
11232 digest
[1] -= MD5M_B
;
11233 digest
[2] -= MD5M_C
;
11234 digest
[3] -= MD5M_D
;
11236 digest
[0] &= 0x00ffffff;
11237 digest
[1] &= 0x00ffffff;
11238 digest
[2] &= 0x00ffffff;
11239 digest
[3] &= 0x00ffffff;
11241 return (PARSER_OK
);
11244 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11246 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11248 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11252 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11255 u32
*digest
= (u32
*) hash_buf
->digest
;
11257 salt_t
*salt
= hash_buf
->salt
;
11259 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11260 | itoa64_to_int (input_buf
[ 1]) << 6
11261 | itoa64_to_int (input_buf
[ 2]) << 12
11262 | itoa64_to_int (input_buf
[ 3]) << 18;
11263 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11264 | itoa64_to_int (input_buf
[ 5]) << 6
11265 | itoa64_to_int (input_buf
[ 6]) << 12
11266 | itoa64_to_int (input_buf
[ 7]) << 18;
11267 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11268 | itoa64_to_int (input_buf
[ 9]) << 6
11269 | itoa64_to_int (input_buf
[10]) << 12
11270 | itoa64_to_int (input_buf
[11]) << 18;
11271 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11272 | itoa64_to_int (input_buf
[13]) << 6
11273 | itoa64_to_int (input_buf
[14]) << 12
11274 | itoa64_to_int (input_buf
[15]) << 18;
11276 digest
[0] -= MD5M_A
;
11277 digest
[1] -= MD5M_B
;
11278 digest
[2] -= MD5M_C
;
11279 digest
[3] -= MD5M_D
;
11281 digest
[0] &= 0x00ffffff;
11282 digest
[1] &= 0x00ffffff;
11283 digest
[2] &= 0x00ffffff;
11284 digest
[3] &= 0x00ffffff;
11286 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11288 uint salt_len
= input_len
- 16 - 1;
11290 char *salt_buf
= input_buf
+ 16 + 1;
11292 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11294 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11296 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11298 salt
->salt_len
= salt_len
;
11300 return (PARSER_OK
);
11303 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11305 key
[0] = (nthash
[0] >> 0);
11306 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11307 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11308 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11309 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11310 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11311 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11312 key
[7] = (nthash
[6] << 1);
11324 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11326 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11328 u32
*digest
= (u32
*) hash_buf
->digest
;
11330 salt_t
*salt
= hash_buf
->salt
;
11332 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11338 char *user_pos
= input_buf
;
11340 char *unused_pos
= strchr (user_pos
, ':');
11342 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11344 uint user_len
= unused_pos
- user_pos
;
11346 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11350 char *domain_pos
= strchr (unused_pos
, ':');
11352 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11354 uint unused_len
= domain_pos
- unused_pos
;
11356 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11360 char *srvchall_pos
= strchr (domain_pos
, ':');
11362 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11364 uint domain_len
= srvchall_pos
- domain_pos
;
11366 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11370 char *hash_pos
= strchr (srvchall_pos
, ':');
11372 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11374 uint srvchall_len
= hash_pos
- srvchall_pos
;
11376 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11380 char *clichall_pos
= strchr (hash_pos
, ':');
11382 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11384 uint hash_len
= clichall_pos
- hash_pos
;
11386 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11390 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11392 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11395 * store some data for later use
11398 netntlm
->user_len
= user_len
* 2;
11399 netntlm
->domain_len
= domain_len
* 2;
11400 netntlm
->srvchall_len
= srvchall_len
/ 2;
11401 netntlm
->clichall_len
= clichall_len
/ 2;
11403 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11404 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11407 * handle username and domainname
11410 for (uint i
= 0; i
< user_len
; i
++)
11412 *userdomain_ptr
++ = user_pos
[i
];
11413 *userdomain_ptr
++ = 0;
11416 for (uint i
= 0; i
< domain_len
; i
++)
11418 *userdomain_ptr
++ = domain_pos
[i
];
11419 *userdomain_ptr
++ = 0;
11423 * handle server challenge encoding
11426 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11428 const char p0
= srvchall_pos
[i
+ 0];
11429 const char p1
= srvchall_pos
[i
+ 1];
11431 *chall_ptr
++ = hex_convert (p1
) << 0
11432 | hex_convert (p0
) << 4;
11436 * handle client challenge encoding
11439 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11441 const char p0
= clichall_pos
[i
+ 0];
11442 const char p1
= clichall_pos
[i
+ 1];
11444 *chall_ptr
++ = hex_convert (p1
) << 0
11445 | hex_convert (p0
) << 4;
11452 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11454 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11456 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11458 salt
->salt_len
= salt_len
;
11460 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11461 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11462 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11463 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11465 digest
[0] = byte_swap_32 (digest
[0]);
11466 digest
[1] = byte_swap_32 (digest
[1]);
11467 digest
[2] = byte_swap_32 (digest
[2]);
11468 digest
[3] = byte_swap_32 (digest
[3]);
11470 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11472 uint digest_tmp
[2] = { 0 };
11474 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11475 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11477 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11478 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11480 /* special case 2: ESS */
11482 if (srvchall_len
== 48)
11484 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11486 uint w
[16] = { 0 };
11488 w
[ 0] = netntlm
->chall_buf
[6];
11489 w
[ 1] = netntlm
->chall_buf
[7];
11490 w
[ 2] = netntlm
->chall_buf
[0];
11491 w
[ 3] = netntlm
->chall_buf
[1];
11495 uint dgst
[4] = { 0 };
11504 salt
->salt_buf
[0] = dgst
[0];
11505 salt
->salt_buf
[1] = dgst
[1];
11509 /* precompute netntlmv1 exploit start */
11511 for (uint i
= 0; i
< 0x10000; i
++)
11513 uint key_md4
[2] = { i
, 0 };
11514 uint key_des
[2] = { 0, 0 };
11516 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11518 uint Kc
[16] = { 0 };
11519 uint Kd
[16] = { 0 };
11521 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11523 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11525 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11527 if (data3
[0] != digest_tmp
[0]) continue;
11528 if (data3
[1] != digest_tmp
[1]) continue;
11530 salt
->salt_buf
[2] = i
;
11532 salt
->salt_len
= 24;
11537 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11538 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11540 /* precompute netntlmv1 exploit stop */
11544 IP (digest
[0], digest
[1], tt
);
11545 IP (digest
[2], digest
[3], tt
);
11547 digest
[0] = rotr32 (digest
[0], 29);
11548 digest
[1] = rotr32 (digest
[1], 29);
11549 digest
[2] = rotr32 (digest
[2], 29);
11550 digest
[3] = rotr32 (digest
[3], 29);
11552 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11554 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11555 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11557 return (PARSER_OK
);
11560 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11562 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11564 u32
*digest
= (u32
*) hash_buf
->digest
;
11566 salt_t
*salt
= hash_buf
->salt
;
11568 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11574 char *user_pos
= input_buf
;
11576 char *unused_pos
= strchr (user_pos
, ':');
11578 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11580 uint user_len
= unused_pos
- user_pos
;
11582 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11586 char *domain_pos
= strchr (unused_pos
, ':');
11588 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11590 uint unused_len
= domain_pos
- unused_pos
;
11592 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11596 char *srvchall_pos
= strchr (domain_pos
, ':');
11598 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11600 uint domain_len
= srvchall_pos
- domain_pos
;
11602 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11606 char *hash_pos
= strchr (srvchall_pos
, ':');
11608 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11610 uint srvchall_len
= hash_pos
- srvchall_pos
;
11612 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11616 char *clichall_pos
= strchr (hash_pos
, ':');
11618 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11620 uint hash_len
= clichall_pos
- hash_pos
;
11622 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11626 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11628 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11630 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11633 * store some data for later use
11636 netntlm
->user_len
= user_len
* 2;
11637 netntlm
->domain_len
= domain_len
* 2;
11638 netntlm
->srvchall_len
= srvchall_len
/ 2;
11639 netntlm
->clichall_len
= clichall_len
/ 2;
11641 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11642 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11645 * handle username and domainname
11648 for (uint i
= 0; i
< user_len
; i
++)
11650 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11651 *userdomain_ptr
++ = 0;
11654 for (uint i
= 0; i
< domain_len
; i
++)
11656 *userdomain_ptr
++ = domain_pos
[i
];
11657 *userdomain_ptr
++ = 0;
11660 *userdomain_ptr
++ = 0x80;
11663 * handle server challenge encoding
11666 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11668 const char p0
= srvchall_pos
[i
+ 0];
11669 const char p1
= srvchall_pos
[i
+ 1];
11671 *chall_ptr
++ = hex_convert (p1
) << 0
11672 | hex_convert (p0
) << 4;
11676 * handle client challenge encoding
11679 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11681 const char p0
= clichall_pos
[i
+ 0];
11682 const char p1
= clichall_pos
[i
+ 1];
11684 *chall_ptr
++ = hex_convert (p1
) << 0
11685 | hex_convert (p0
) << 4;
11688 *chall_ptr
++ = 0x80;
11691 * handle hash itself
11694 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11695 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11696 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11697 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11699 digest
[0] = byte_swap_32 (digest
[0]);
11700 digest
[1] = byte_swap_32 (digest
[1]);
11701 digest
[2] = byte_swap_32 (digest
[2]);
11702 digest
[3] = byte_swap_32 (digest
[3]);
11705 * reuse challange data as salt_buf, its the buffer that is most likely unique
11708 salt
->salt_buf
[0] = 0;
11709 salt
->salt_buf
[1] = 0;
11710 salt
->salt_buf
[2] = 0;
11711 salt
->salt_buf
[3] = 0;
11712 salt
->salt_buf
[4] = 0;
11713 salt
->salt_buf
[5] = 0;
11714 salt
->salt_buf
[6] = 0;
11715 salt
->salt_buf
[7] = 0;
11719 uptr
= (uint
*) netntlm
->userdomain_buf
;
11721 for (uint i
= 0; i
< 16; i
+= 16)
11723 md5_64 (uptr
, salt
->salt_buf
);
11726 uptr
= (uint
*) netntlm
->chall_buf
;
11728 for (uint i
= 0; i
< 256; i
+= 16)
11730 md5_64 (uptr
, salt
->salt_buf
);
11733 salt
->salt_len
= 16;
11735 return (PARSER_OK
);
11738 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11740 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11742 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11746 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11749 u32
*digest
= (u32
*) hash_buf
->digest
;
11751 salt_t
*salt
= hash_buf
->salt
;
11753 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11754 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11755 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11756 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11758 digest
[0] = byte_swap_32 (digest
[0]);
11759 digest
[1] = byte_swap_32 (digest
[1]);
11760 digest
[2] = byte_swap_32 (digest
[2]);
11761 digest
[3] = byte_swap_32 (digest
[3]);
11763 digest
[0] -= MD5M_A
;
11764 digest
[1] -= MD5M_B
;
11765 digest
[2] -= MD5M_C
;
11766 digest
[3] -= MD5M_D
;
11768 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11770 uint salt_len
= input_len
- 32 - 1;
11772 char *salt_buf
= input_buf
+ 32 + 1;
11774 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11776 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11778 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11780 salt
->salt_len
= salt_len
;
11782 return (PARSER_OK
);
11785 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11787 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11789 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11793 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11796 u32
*digest
= (u32
*) hash_buf
->digest
;
11798 salt_t
*salt
= hash_buf
->salt
;
11800 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11801 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11802 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11803 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11805 digest
[0] = byte_swap_32 (digest
[0]);
11806 digest
[1] = byte_swap_32 (digest
[1]);
11807 digest
[2] = byte_swap_32 (digest
[2]);
11808 digest
[3] = byte_swap_32 (digest
[3]);
11810 digest
[0] -= MD5M_A
;
11811 digest
[1] -= MD5M_B
;
11812 digest
[2] -= MD5M_C
;
11813 digest
[3] -= MD5M_D
;
11815 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11817 uint salt_len
= input_len
- 32 - 1;
11819 char *salt_buf
= input_buf
+ 32 + 1;
11821 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11823 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11825 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11827 salt
->salt_len
= salt_len
;
11829 return (PARSER_OK
);
11832 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11834 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11836 u32
*digest
= (u32
*) hash_buf
->digest
;
11838 salt_t
*salt
= hash_buf
->salt
;
11840 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11841 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11842 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11843 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11845 digest
[0] = byte_swap_32 (digest
[0]);
11846 digest
[1] = byte_swap_32 (digest
[1]);
11847 digest
[2] = byte_swap_32 (digest
[2]);
11848 digest
[3] = byte_swap_32 (digest
[3]);
11850 digest
[0] -= MD5M_A
;
11851 digest
[1] -= MD5M_B
;
11852 digest
[2] -= MD5M_C
;
11853 digest
[3] -= MD5M_D
;
11856 * This is a virtual salt. While the algorithm is basically not salted
11857 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11858 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11861 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11863 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11865 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11867 salt
->salt_len
= salt_len
;
11869 return (PARSER_OK
);
11872 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11874 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11876 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11880 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11883 u32
*digest
= (u32
*) hash_buf
->digest
;
11885 salt_t
*salt
= hash_buf
->salt
;
11887 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11888 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11889 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11890 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11892 digest
[0] = byte_swap_32 (digest
[0]);
11893 digest
[1] = byte_swap_32 (digest
[1]);
11894 digest
[2] = byte_swap_32 (digest
[2]);
11895 digest
[3] = byte_swap_32 (digest
[3]);
11897 digest
[0] -= MD5M_A
;
11898 digest
[1] -= MD5M_B
;
11899 digest
[2] -= MD5M_C
;
11900 digest
[3] -= MD5M_D
;
11902 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11904 uint salt_len
= input_len
- 32 - 1;
11906 char *salt_buf
= input_buf
+ 32 + 1;
11908 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11910 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11912 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11914 salt
->salt_len
= salt_len
;
11916 return (PARSER_OK
);
11919 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11921 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11923 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11927 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11930 u32
*digest
= (u32
*) hash_buf
->digest
;
11932 salt_t
*salt
= hash_buf
->salt
;
11934 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11935 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11936 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11937 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11939 digest
[0] = byte_swap_32 (digest
[0]);
11940 digest
[1] = byte_swap_32 (digest
[1]);
11941 digest
[2] = byte_swap_32 (digest
[2]);
11942 digest
[3] = byte_swap_32 (digest
[3]);
11944 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11946 uint salt_len
= input_len
- 32 - 1;
11948 char *salt_buf
= input_buf
+ 32 + 1;
11950 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11952 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11954 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11956 salt
->salt_len
= salt_len
;
11958 return (PARSER_OK
);
11961 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11963 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11965 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11969 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11972 u32
*digest
= (u32
*) hash_buf
->digest
;
11974 salt_t
*salt
= hash_buf
->salt
;
11976 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11977 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11978 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11979 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11981 digest
[0] = byte_swap_32 (digest
[0]);
11982 digest
[1] = byte_swap_32 (digest
[1]);
11983 digest
[2] = byte_swap_32 (digest
[2]);
11984 digest
[3] = byte_swap_32 (digest
[3]);
11986 digest
[0] -= MD4M_A
;
11987 digest
[1] -= MD4M_B
;
11988 digest
[2] -= MD4M_C
;
11989 digest
[3] -= MD4M_D
;
11991 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11993 uint salt_len
= input_len
- 32 - 1;
11995 char *salt_buf
= input_buf
+ 32 + 1;
11997 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11999 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12001 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12003 salt
->salt_len
= salt_len
;
12005 return (PARSER_OK
);
12008 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12010 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12012 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
12016 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
12019 u32
*digest
= (u32
*) hash_buf
->digest
;
12021 salt_t
*salt
= hash_buf
->salt
;
12023 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12024 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12025 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12026 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12028 digest
[0] = byte_swap_32 (digest
[0]);
12029 digest
[1] = byte_swap_32 (digest
[1]);
12030 digest
[2] = byte_swap_32 (digest
[2]);
12031 digest
[3] = byte_swap_32 (digest
[3]);
12033 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12035 uint salt_len
= input_len
- 32 - 1;
12037 char *salt_buf
= input_buf
+ 32 + 1;
12039 uint salt_pc_block
[16] = { 0 };
12041 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
12043 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
12045 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12047 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
12049 salt_pc_block
[14] = salt_len
* 8;
12051 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
12053 md5_64 (salt_pc_block
, salt_pc_digest
);
12055 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
12056 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
12057 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
12058 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
12060 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
12062 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
12064 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
12066 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
12067 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
12068 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
12069 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
12071 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
12073 return (PARSER_OK
);
12076 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12078 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
12080 u32
*digest
= (u32
*) hash_buf
->digest
;
12082 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12083 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12084 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12085 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12086 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12088 digest
[0] -= SHA1M_A
;
12089 digest
[1] -= SHA1M_B
;
12090 digest
[2] -= SHA1M_C
;
12091 digest
[3] -= SHA1M_D
;
12092 digest
[4] -= SHA1M_E
;
12094 return (PARSER_OK
);
12097 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12099 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
12101 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
12103 u32
*digest
= (u32
*) hash_buf
->digest
;
12107 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12108 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12109 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12110 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12113 return (PARSER_OK
);
12116 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12118 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12120 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12124 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12127 u32
*digest
= (u32
*) hash_buf
->digest
;
12129 salt_t
*salt
= hash_buf
->salt
;
12131 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12132 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12133 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12134 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12135 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12137 digest
[0] -= SHA1M_A
;
12138 digest
[1] -= SHA1M_B
;
12139 digest
[2] -= SHA1M_C
;
12140 digest
[3] -= SHA1M_D
;
12141 digest
[4] -= SHA1M_E
;
12143 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12145 uint salt_len
= input_len
- 40 - 1;
12147 char *salt_buf
= input_buf
+ 40 + 1;
12149 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12151 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12153 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12155 salt
->salt_len
= salt_len
;
12157 return (PARSER_OK
);
12160 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12162 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12164 u32
*digest
= (u32
*) hash_buf
->digest
;
12166 salt_t
*salt
= hash_buf
->salt
;
12168 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12170 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12171 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12172 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12173 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12174 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12176 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12178 uint salt_len
= input_len
- 40 - 1;
12180 char *salt_buf
= input_buf
+ 40 + 1;
12182 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12184 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12186 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12188 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12191 pstoken
->salt_len
= salt_len
/ 2;
12193 /* some fake salt for the sorting mechanisms */
12195 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12196 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12197 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12198 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12199 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12200 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12201 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12202 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12204 salt
->salt_len
= 32;
12206 /* we need to check if we can precompute some of the data --
12207 this is possible since the scheme is badly designed */
12209 pstoken
->pc_digest
[0] = SHA1M_A
;
12210 pstoken
->pc_digest
[1] = SHA1M_B
;
12211 pstoken
->pc_digest
[2] = SHA1M_C
;
12212 pstoken
->pc_digest
[3] = SHA1M_D
;
12213 pstoken
->pc_digest
[4] = SHA1M_E
;
12215 pstoken
->pc_offset
= 0;
12217 for (int i
= 0; i
< (int) pstoken
->salt_len
- 63; i
+= 64)
12221 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12222 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12223 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12224 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12225 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12226 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12227 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12228 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12229 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12230 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12231 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12232 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12233 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12234 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12235 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12236 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12238 sha1_64 (w
, pstoken
->pc_digest
);
12240 pstoken
->pc_offset
+= 16;
12243 return (PARSER_OK
);
12246 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12248 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12250 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12252 u32
*digest
= (u32
*) hash_buf
->digest
;
12254 u8 tmp_buf
[100] = { 0 };
12256 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12258 memcpy (digest
, tmp_buf
, 20);
12260 digest
[0] = byte_swap_32 (digest
[0]);
12261 digest
[1] = byte_swap_32 (digest
[1]);
12262 digest
[2] = byte_swap_32 (digest
[2]);
12263 digest
[3] = byte_swap_32 (digest
[3]);
12264 digest
[4] = byte_swap_32 (digest
[4]);
12266 digest
[0] -= SHA1M_A
;
12267 digest
[1] -= SHA1M_B
;
12268 digest
[2] -= SHA1M_C
;
12269 digest
[3] -= SHA1M_D
;
12270 digest
[4] -= SHA1M_E
;
12272 return (PARSER_OK
);
12275 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12277 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12279 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12281 u32
*digest
= (u32
*) hash_buf
->digest
;
12283 salt_t
*salt
= hash_buf
->salt
;
12285 u8 tmp_buf
[100] = { 0 };
12287 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12289 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12291 memcpy (digest
, tmp_buf
, 20);
12293 int salt_len
= tmp_len
- 20;
12295 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12297 salt
->salt_len
= salt_len
;
12299 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12301 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12303 char *ptr
= (char *) salt
->salt_buf
;
12305 ptr
[salt
->salt_len
] = 0x80;
12308 digest
[0] = byte_swap_32 (digest
[0]);
12309 digest
[1] = byte_swap_32 (digest
[1]);
12310 digest
[2] = byte_swap_32 (digest
[2]);
12311 digest
[3] = byte_swap_32 (digest
[3]);
12312 digest
[4] = byte_swap_32 (digest
[4]);
12314 digest
[0] -= SHA1M_A
;
12315 digest
[1] -= SHA1M_B
;
12316 digest
[2] -= SHA1M_C
;
12317 digest
[3] -= SHA1M_D
;
12318 digest
[4] -= SHA1M_E
;
12320 return (PARSER_OK
);
12323 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12325 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12327 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12329 u32
*digest
= (u32
*) hash_buf
->digest
;
12331 salt_t
*salt
= hash_buf
->salt
;
12333 char *salt_buf
= input_buf
+ 6;
12337 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12339 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12341 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12343 salt
->salt_len
= salt_len
;
12345 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12347 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12348 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12349 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12350 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12351 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12353 digest
[0] -= SHA1M_A
;
12354 digest
[1] -= SHA1M_B
;
12355 digest
[2] -= SHA1M_C
;
12356 digest
[3] -= SHA1M_D
;
12357 digest
[4] -= SHA1M_E
;
12359 return (PARSER_OK
);
12362 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12364 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12366 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12368 u32
*digest
= (u32
*) hash_buf
->digest
;
12370 salt_t
*salt
= hash_buf
->salt
;
12372 char *salt_buf
= input_buf
+ 6;
12376 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12378 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12380 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12382 salt
->salt_len
= salt_len
;
12384 char *hash_pos
= input_buf
+ 6 + 8;
12386 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12387 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12388 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12389 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12390 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12392 digest
[0] -= SHA1M_A
;
12393 digest
[1] -= SHA1M_B
;
12394 digest
[2] -= SHA1M_C
;
12395 digest
[3] -= SHA1M_D
;
12396 digest
[4] -= SHA1M_E
;
12398 return (PARSER_OK
);
12401 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12403 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12405 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12407 u64
*digest
= (u64
*) hash_buf
->digest
;
12409 salt_t
*salt
= hash_buf
->salt
;
12411 char *salt_buf
= input_buf
+ 6;
12415 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12417 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12419 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12421 salt
->salt_len
= salt_len
;
12423 char *hash_pos
= input_buf
+ 6 + 8;
12425 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12426 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12427 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12428 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12429 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12430 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12431 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12432 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12434 digest
[0] -= SHA512M_A
;
12435 digest
[1] -= SHA512M_B
;
12436 digest
[2] -= SHA512M_C
;
12437 digest
[3] -= SHA512M_D
;
12438 digest
[4] -= SHA512M_E
;
12439 digest
[5] -= SHA512M_F
;
12440 digest
[6] -= SHA512M_G
;
12441 digest
[7] -= SHA512M_H
;
12443 return (PARSER_OK
);
12446 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12448 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12450 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12454 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12457 u32
*digest
= (u32
*) hash_buf
->digest
;
12459 salt_t
*salt
= hash_buf
->salt
;
12461 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12462 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12466 digest
[0] = byte_swap_32 (digest
[0]);
12467 digest
[1] = byte_swap_32 (digest
[1]);
12469 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12471 uint salt_len
= input_len
- 16 - 1;
12473 char *salt_buf
= input_buf
+ 16 + 1;
12475 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12477 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12479 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12481 salt
->salt_len
= salt_len
;
12483 return (PARSER_OK
);
12486 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12488 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12490 u32
*digest
= (u32
*) hash_buf
->digest
;
12492 salt_t
*salt
= hash_buf
->salt
;
12494 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12495 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12496 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12497 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12498 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12500 digest
[0] -= SHA1M_A
;
12501 digest
[1] -= SHA1M_B
;
12502 digest
[2] -= SHA1M_C
;
12503 digest
[3] -= SHA1M_D
;
12504 digest
[4] -= SHA1M_E
;
12506 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12508 uint salt_len
= input_len
- 40 - 1;
12510 char *salt_buf
= input_buf
+ 40 + 1;
12512 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12514 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12516 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12518 salt
->salt_len
= salt_len
;
12520 return (PARSER_OK
);
12523 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12525 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12527 u32
*digest
= (u32
*) hash_buf
->digest
;
12529 salt_t
*salt
= hash_buf
->salt
;
12531 char *hash_pos
= input_buf
;
12533 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12534 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12535 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12536 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12537 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12538 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12539 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12540 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12541 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12542 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12543 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12544 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12545 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12546 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12547 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12548 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12550 char *salt_pos
= input_buf
+ 128;
12552 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12553 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12554 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12555 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12557 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12558 salt
->salt_len
= 16;
12560 return (PARSER_OK
);
12563 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12565 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12567 u32
*digest
= (u32
*) hash_buf
->digest
;
12569 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12570 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12571 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12572 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12573 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12574 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12575 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12576 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12578 digest
[0] -= SHA256M_A
;
12579 digest
[1] -= SHA256M_B
;
12580 digest
[2] -= SHA256M_C
;
12581 digest
[3] -= SHA256M_D
;
12582 digest
[4] -= SHA256M_E
;
12583 digest
[5] -= SHA256M_F
;
12584 digest
[6] -= SHA256M_G
;
12585 digest
[7] -= SHA256M_H
;
12587 return (PARSER_OK
);
12590 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12592 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12594 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12598 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12601 u32
*digest
= (u32
*) hash_buf
->digest
;
12603 salt_t
*salt
= hash_buf
->salt
;
12605 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12606 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12607 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12608 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12609 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12610 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12611 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12612 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12614 digest
[0] -= SHA256M_A
;
12615 digest
[1] -= SHA256M_B
;
12616 digest
[2] -= SHA256M_C
;
12617 digest
[3] -= SHA256M_D
;
12618 digest
[4] -= SHA256M_E
;
12619 digest
[5] -= SHA256M_F
;
12620 digest
[6] -= SHA256M_G
;
12621 digest
[7] -= SHA256M_H
;
12623 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12625 uint salt_len
= input_len
- 64 - 1;
12627 char *salt_buf
= input_buf
+ 64 + 1;
12629 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12631 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12633 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12635 salt
->salt_len
= salt_len
;
12637 return (PARSER_OK
);
12640 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12642 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12644 u64
*digest
= (u64
*) hash_buf
->digest
;
12646 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12647 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12648 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12649 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12650 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12651 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12655 digest
[0] -= SHA384M_A
;
12656 digest
[1] -= SHA384M_B
;
12657 digest
[2] -= SHA384M_C
;
12658 digest
[3] -= SHA384M_D
;
12659 digest
[4] -= SHA384M_E
;
12660 digest
[5] -= SHA384M_F
;
12664 return (PARSER_OK
);
12667 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12669 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12671 u64
*digest
= (u64
*) hash_buf
->digest
;
12673 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12674 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12675 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12676 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12677 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12678 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12679 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12680 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12682 digest
[0] -= SHA512M_A
;
12683 digest
[1] -= SHA512M_B
;
12684 digest
[2] -= SHA512M_C
;
12685 digest
[3] -= SHA512M_D
;
12686 digest
[4] -= SHA512M_E
;
12687 digest
[5] -= SHA512M_F
;
12688 digest
[6] -= SHA512M_G
;
12689 digest
[7] -= SHA512M_H
;
12691 return (PARSER_OK
);
12694 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12696 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12698 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12702 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12705 u64
*digest
= (u64
*) hash_buf
->digest
;
12707 salt_t
*salt
= hash_buf
->salt
;
12709 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12710 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12711 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12712 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12713 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12714 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12715 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12716 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12718 digest
[0] -= SHA512M_A
;
12719 digest
[1] -= SHA512M_B
;
12720 digest
[2] -= SHA512M_C
;
12721 digest
[3] -= SHA512M_D
;
12722 digest
[4] -= SHA512M_E
;
12723 digest
[5] -= SHA512M_F
;
12724 digest
[6] -= SHA512M_G
;
12725 digest
[7] -= SHA512M_H
;
12727 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12729 uint salt_len
= input_len
- 128 - 1;
12731 char *salt_buf
= input_buf
+ 128 + 1;
12733 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12735 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12737 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12739 salt
->salt_len
= salt_len
;
12741 return (PARSER_OK
);
12744 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12746 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12748 u64
*digest
= (u64
*) hash_buf
->digest
;
12750 salt_t
*salt
= hash_buf
->salt
;
12752 char *salt_pos
= input_buf
+ 3;
12754 uint iterations_len
= 0;
12756 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12760 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12762 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12763 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12767 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12771 iterations_len
+= 8;
12775 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12778 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12780 char *hash_pos
= strchr (salt_pos
, '$');
12782 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12784 uint salt_len
= hash_pos
- salt_pos
;
12786 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12788 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12790 salt
->salt_len
= salt_len
;
12794 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12796 return (PARSER_OK
);
12799 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12801 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12803 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12805 u64
*digest
= (u64
*) hash_buf
->digest
;
12807 salt_t
*salt
= hash_buf
->salt
;
12809 uint keccak_mdlen
= input_len
/ 2;
12811 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12813 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12815 digest
[i
] = byte_swap_64 (digest
[i
]);
12818 salt
->keccak_mdlen
= keccak_mdlen
;
12820 return (PARSER_OK
);
12823 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12825 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12827 u32
*digest
= (u32
*) hash_buf
->digest
;
12829 salt_t
*salt
= hash_buf
->salt
;
12831 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12834 * Parse that strange long line
12839 size_t in_len
[9] = { 0 };
12841 in_off
[0] = strtok (input_buf
, ":");
12843 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12845 in_len
[0] = strlen (in_off
[0]);
12849 for (i
= 1; i
< 9; i
++)
12851 in_off
[i
] = strtok (NULL
, ":");
12853 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12855 in_len
[i
] = strlen (in_off
[i
]);
12858 char *ptr
= (char *) ikepsk
->msg_buf
;
12860 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12861 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12862 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12863 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12864 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12865 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12869 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12871 ptr
= (char *) ikepsk
->nr_buf
;
12873 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12874 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12878 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12881 * Store to database
12886 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12887 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12888 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12889 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12891 digest
[0] = byte_swap_32 (digest
[0]);
12892 digest
[1] = byte_swap_32 (digest
[1]);
12893 digest
[2] = byte_swap_32 (digest
[2]);
12894 digest
[3] = byte_swap_32 (digest
[3]);
12896 salt
->salt_len
= 32;
12898 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12899 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12900 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12901 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12902 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12903 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12904 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12905 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12907 return (PARSER_OK
);
12910 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12912 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12914 u32
*digest
= (u32
*) hash_buf
->digest
;
12916 salt_t
*salt
= hash_buf
->salt
;
12918 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12921 * Parse that strange long line
12926 size_t in_len
[9] = { 0 };
12928 in_off
[0] = strtok (input_buf
, ":");
12930 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12932 in_len
[0] = strlen (in_off
[0]);
12936 for (i
= 1; i
< 9; i
++)
12938 in_off
[i
] = strtok (NULL
, ":");
12940 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12942 in_len
[i
] = strlen (in_off
[i
]);
12945 char *ptr
= (char *) ikepsk
->msg_buf
;
12947 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12948 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12949 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12950 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12951 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12952 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12956 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12958 ptr
= (char *) ikepsk
->nr_buf
;
12960 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12961 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12965 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12968 * Store to database
12973 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12974 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12975 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12976 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12977 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12979 salt
->salt_len
= 32;
12981 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12982 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12983 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12984 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12985 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12986 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12987 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12988 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12990 return (PARSER_OK
);
12993 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12995 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12997 u32
*digest
= (u32
*) hash_buf
->digest
;
12999 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13000 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13001 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13002 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13003 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13005 digest
[0] = byte_swap_32 (digest
[0]);
13006 digest
[1] = byte_swap_32 (digest
[1]);
13007 digest
[2] = byte_swap_32 (digest
[2]);
13008 digest
[3] = byte_swap_32 (digest
[3]);
13009 digest
[4] = byte_swap_32 (digest
[4]);
13011 return (PARSER_OK
);
13014 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13016 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
13018 u32
*digest
= (u32
*) hash_buf
->digest
;
13020 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13021 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13022 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
13023 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
13024 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
13025 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
13026 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
13027 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
13028 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
13029 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
13030 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
13031 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
13032 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
13033 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
13034 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
13035 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
13037 return (PARSER_OK
);
13040 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13042 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
13044 u32
*digest
= (u32
*) hash_buf
->digest
;
13046 salt_t
*salt
= hash_buf
->salt
;
13048 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13049 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13050 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13051 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13052 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13054 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13056 uint salt_len
= input_len
- 40 - 1;
13058 char *salt_buf
= input_buf
+ 40 + 1;
13060 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13062 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13064 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13066 salt
->salt_len
= salt_len
;
13068 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
13070 return (PARSER_OK
);
13073 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13075 u32
*digest
= (u32
*) hash_buf
->digest
;
13077 salt_t
*salt
= hash_buf
->salt
;
13079 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13081 if (input_len
== 0)
13083 log_error ("TrueCrypt container not specified");
13088 FILE *fp
= fopen (input_buf
, "rb");
13092 log_error ("%s: %s", input_buf
, strerror (errno
));
13097 char buf
[512] = { 0 };
13099 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13103 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13105 memcpy (tc
->salt_buf
, buf
, 64);
13107 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13109 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13111 salt
->salt_len
= 4;
13113 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
13115 tc
->signature
= 0x45555254; // "TRUE"
13117 digest
[0] = tc
->data_buf
[0];
13119 return (PARSER_OK
);
13122 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13124 u32
*digest
= (u32
*) hash_buf
->digest
;
13126 salt_t
*salt
= hash_buf
->salt
;
13128 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13130 if (input_len
== 0)
13132 log_error ("TrueCrypt container not specified");
13137 FILE *fp
= fopen (input_buf
, "rb");
13141 log_error ("%s: %s", input_buf
, strerror (errno
));
13146 char buf
[512] = { 0 };
13148 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13152 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13154 memcpy (tc
->salt_buf
, buf
, 64);
13156 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13158 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13160 salt
->salt_len
= 4;
13162 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13164 tc
->signature
= 0x45555254; // "TRUE"
13166 digest
[0] = tc
->data_buf
[0];
13168 return (PARSER_OK
);
13171 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13173 u32
*digest
= (u32
*) hash_buf
->digest
;
13175 salt_t
*salt
= hash_buf
->salt
;
13177 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13179 if (input_len
== 0)
13181 log_error ("VeraCrypt container not specified");
13186 FILE *fp
= fopen (input_buf
, "rb");
13190 log_error ("%s: %s", input_buf
, strerror (errno
));
13195 char buf
[512] = { 0 };
13197 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13201 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13203 memcpy (tc
->salt_buf
, buf
, 64);
13205 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13207 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13209 salt
->salt_len
= 4;
13211 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13213 tc
->signature
= 0x41524556; // "VERA"
13215 digest
[0] = tc
->data_buf
[0];
13217 return (PARSER_OK
);
13220 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13222 u32
*digest
= (u32
*) hash_buf
->digest
;
13224 salt_t
*salt
= hash_buf
->salt
;
13226 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13228 if (input_len
== 0)
13230 log_error ("VeraCrypt container not specified");
13235 FILE *fp
= fopen (input_buf
, "rb");
13239 log_error ("%s: %s", input_buf
, strerror (errno
));
13244 char buf
[512] = { 0 };
13246 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13250 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13252 memcpy (tc
->salt_buf
, buf
, 64);
13254 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13256 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13258 salt
->salt_len
= 4;
13260 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13262 tc
->signature
= 0x41524556; // "VERA"
13264 digest
[0] = tc
->data_buf
[0];
13266 return (PARSER_OK
);
13269 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13271 u32
*digest
= (u32
*) hash_buf
->digest
;
13273 salt_t
*salt
= hash_buf
->salt
;
13275 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13277 if (input_len
== 0)
13279 log_error ("VeraCrypt container not specified");
13284 FILE *fp
= fopen (input_buf
, "rb");
13288 log_error ("%s: %s", input_buf
, strerror (errno
));
13293 char buf
[512] = { 0 };
13295 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13299 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13301 memcpy (tc
->salt_buf
, buf
, 64);
13303 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13305 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13307 salt
->salt_len
= 4;
13309 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13311 tc
->signature
= 0x41524556; // "VERA"
13313 digest
[0] = tc
->data_buf
[0];
13315 return (PARSER_OK
);
13318 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13320 u32
*digest
= (u32
*) hash_buf
->digest
;
13322 salt_t
*salt
= hash_buf
->salt
;
13324 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13326 if (input_len
== 0)
13328 log_error ("VeraCrypt container not specified");
13333 FILE *fp
= fopen (input_buf
, "rb");
13337 log_error ("%s: %s", input_buf
, strerror (errno
));
13342 char buf
[512] = { 0 };
13344 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13348 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13350 memcpy (tc
->salt_buf
, buf
, 64);
13352 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13354 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13356 salt
->salt_len
= 4;
13358 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13360 tc
->signature
= 0x41524556; // "VERA"
13362 digest
[0] = tc
->data_buf
[0];
13364 return (PARSER_OK
);
13367 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13369 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13371 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13373 u32
*digest
= (u32
*) hash_buf
->digest
;
13375 salt_t
*salt
= hash_buf
->salt
;
13377 char *salt_pos
= input_buf
+ 6;
13379 char *hash_pos
= strchr (salt_pos
, '$');
13381 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13383 uint salt_len
= hash_pos
- salt_pos
;
13385 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13387 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13389 salt
->salt_len
= salt_len
;
13391 salt
->salt_iter
= 1000;
13395 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13397 return (PARSER_OK
);
13400 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13402 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13404 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13406 u32
*digest
= (u32
*) hash_buf
->digest
;
13408 salt_t
*salt
= hash_buf
->salt
;
13410 char *iter_pos
= input_buf
+ 7;
13412 char *salt_pos
= strchr (iter_pos
, '$');
13414 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13418 char *hash_pos
= strchr (salt_pos
, '$');
13420 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13422 uint salt_len
= hash_pos
- salt_pos
;
13424 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13426 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13428 salt
->salt_len
= salt_len
;
13430 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13432 salt
->salt_sign
[0] = atoi (salt_iter
);
13434 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13438 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13440 digest
[0] = byte_swap_32 (digest
[0]);
13441 digest
[1] = byte_swap_32 (digest
[1]);
13442 digest
[2] = byte_swap_32 (digest
[2]);
13443 digest
[3] = byte_swap_32 (digest
[3]);
13444 digest
[4] = byte_swap_32 (digest
[4]);
13446 return (PARSER_OK
);
13449 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13451 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13453 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13455 u32
*digest
= (u32
*) hash_buf
->digest
;
13457 salt_t
*salt
= hash_buf
->salt
;
13459 char *iter_pos
= input_buf
+ 9;
13461 char *salt_pos
= strchr (iter_pos
, '$');
13463 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13467 char *hash_pos
= strchr (salt_pos
, '$');
13469 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13471 uint salt_len
= hash_pos
- salt_pos
;
13473 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13475 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13477 salt
->salt_len
= salt_len
;
13479 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13481 salt
->salt_sign
[0] = atoi (salt_iter
);
13483 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13487 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13489 digest
[0] = byte_swap_32 (digest
[0]);
13490 digest
[1] = byte_swap_32 (digest
[1]);
13491 digest
[2] = byte_swap_32 (digest
[2]);
13492 digest
[3] = byte_swap_32 (digest
[3]);
13493 digest
[4] = byte_swap_32 (digest
[4]);
13494 digest
[5] = byte_swap_32 (digest
[5]);
13495 digest
[6] = byte_swap_32 (digest
[6]);
13496 digest
[7] = byte_swap_32 (digest
[7]);
13498 return (PARSER_OK
);
13501 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13503 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13505 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13507 u64
*digest
= (u64
*) hash_buf
->digest
;
13509 salt_t
*salt
= hash_buf
->salt
;
13511 char *iter_pos
= input_buf
+ 9;
13513 char *salt_pos
= strchr (iter_pos
, '$');
13515 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13519 char *hash_pos
= strchr (salt_pos
, '$');
13521 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13523 uint salt_len
= hash_pos
- salt_pos
;
13525 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13527 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13529 salt
->salt_len
= salt_len
;
13531 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13533 salt
->salt_sign
[0] = atoi (salt_iter
);
13535 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13539 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13541 digest
[0] = byte_swap_64 (digest
[0]);
13542 digest
[1] = byte_swap_64 (digest
[1]);
13543 digest
[2] = byte_swap_64 (digest
[2]);
13544 digest
[3] = byte_swap_64 (digest
[3]);
13545 digest
[4] = byte_swap_64 (digest
[4]);
13546 digest
[5] = byte_swap_64 (digest
[5]);
13547 digest
[6] = byte_swap_64 (digest
[6]);
13548 digest
[7] = byte_swap_64 (digest
[7]);
13550 return (PARSER_OK
);
13553 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13555 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13557 u32
*digest
= (u32
*) hash_buf
->digest
;
13559 salt_t
*salt
= hash_buf
->salt
;
13561 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13567 char *iterations_pos
= input_buf
;
13569 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13571 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13573 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13575 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13579 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13581 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13583 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13585 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13587 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13589 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13594 * pbkdf2 iterations
13597 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13600 * handle salt encoding
13603 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13605 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13607 const char p0
= saltbuf_pos
[i
+ 0];
13608 const char p1
= saltbuf_pos
[i
+ 1];
13610 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13611 | hex_convert (p0
) << 4;
13614 salt
->salt_len
= saltbuf_len
/ 2;
13617 * handle cipher encoding
13620 uint
*tmp
= (uint
*) mymalloc (32);
13622 char *cipherbuf_ptr
= (char *) tmp
;
13624 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13626 const char p0
= cipherbuf_pos
[i
+ 0];
13627 const char p1
= cipherbuf_pos
[i
+ 1];
13629 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13630 | hex_convert (p0
) << 4;
13633 // iv is stored at salt_buf 4 (length 16)
13634 // data is stored at salt_buf 8 (length 16)
13636 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13637 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13638 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13639 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13641 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13642 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13643 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13644 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13648 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13650 const char p0
= cipherbuf_pos
[j
+ 0];
13651 const char p1
= cipherbuf_pos
[j
+ 1];
13653 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13654 | hex_convert (p0
) << 4;
13661 digest
[0] = 0x10101010;
13662 digest
[1] = 0x10101010;
13663 digest
[2] = 0x10101010;
13664 digest
[3] = 0x10101010;
13666 return (PARSER_OK
);
13669 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13671 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13673 u32
*digest
= (u32
*) hash_buf
->digest
;
13675 salt_t
*salt
= hash_buf
->salt
;
13677 char *hashbuf_pos
= input_buf
;
13679 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13681 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13683 uint hash_len
= iterations_pos
- hashbuf_pos
;
13685 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13689 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13691 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13693 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13697 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13699 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13701 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13703 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13705 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13707 salt
->salt_len
= salt_len
;
13709 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13711 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13712 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13713 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13714 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13716 return (PARSER_OK
);
13719 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13721 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13723 u32
*digest
= (u32
*) hash_buf
->digest
;
13725 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13726 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13727 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13728 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13729 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13730 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13731 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13732 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13734 digest
[0] = byte_swap_32 (digest
[0]);
13735 digest
[1] = byte_swap_32 (digest
[1]);
13736 digest
[2] = byte_swap_32 (digest
[2]);
13737 digest
[3] = byte_swap_32 (digest
[3]);
13738 digest
[4] = byte_swap_32 (digest
[4]);
13739 digest
[5] = byte_swap_32 (digest
[5]);
13740 digest
[6] = byte_swap_32 (digest
[6]);
13741 digest
[7] = byte_swap_32 (digest
[7]);
13743 return (PARSER_OK
);
13746 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13748 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13750 u32
*digest
= (u32
*) hash_buf
->digest
;
13752 salt_t
*salt
= hash_buf
->salt
;
13754 char *salt_pos
= input_buf
+ 3;
13756 uint iterations_len
= 0;
13758 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13762 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13764 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13765 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13769 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13773 iterations_len
+= 8;
13777 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13780 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13782 char *hash_pos
= strchr (salt_pos
, '$');
13784 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13786 uint salt_len
= hash_pos
- salt_pos
;
13788 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13790 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13792 salt
->salt_len
= salt_len
;
13796 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13798 return (PARSER_OK
);
13801 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13803 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13805 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13807 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13809 u64
*digest
= (u64
*) hash_buf
->digest
;
13811 salt_t
*salt
= hash_buf
->salt
;
13813 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13815 char *iter_pos
= input_buf
+ 4;
13817 char *salt_pos
= strchr (iter_pos
, '$');
13819 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13823 char *hash_pos
= strchr (salt_pos
, '$');
13825 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13827 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13831 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13832 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13833 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13834 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13835 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13836 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13837 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13838 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13840 uint salt_len
= hash_pos
- salt_pos
- 1;
13842 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13844 salt
->salt_len
= salt_len
/ 2;
13846 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13847 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13848 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13849 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13850 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13851 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13852 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13853 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13855 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13856 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13857 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13858 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13859 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13860 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13861 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13862 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13863 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13864 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13866 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13868 salt
->salt_iter
= atoi (iter_pos
) - 1;
13870 return (PARSER_OK
);
13873 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13875 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13877 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13879 u32
*digest
= (u32
*) hash_buf
->digest
;
13881 salt_t
*salt
= hash_buf
->salt
;
13883 char *salt_pos
= input_buf
+ 14;
13885 char *hash_pos
= strchr (salt_pos
, '*');
13887 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13891 uint salt_len
= hash_pos
- salt_pos
- 1;
13893 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13895 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13897 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13899 salt
->salt_len
= salt_len
;
13901 u8 tmp_buf
[100] = { 0 };
13903 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13905 memcpy (digest
, tmp_buf
, 32);
13907 digest
[0] = byte_swap_32 (digest
[0]);
13908 digest
[1] = byte_swap_32 (digest
[1]);
13909 digest
[2] = byte_swap_32 (digest
[2]);
13910 digest
[3] = byte_swap_32 (digest
[3]);
13911 digest
[4] = byte_swap_32 (digest
[4]);
13912 digest
[5] = byte_swap_32 (digest
[5]);
13913 digest
[6] = byte_swap_32 (digest
[6]);
13914 digest
[7] = byte_swap_32 (digest
[7]);
13916 digest
[0] -= SHA256M_A
;
13917 digest
[1] -= SHA256M_B
;
13918 digest
[2] -= SHA256M_C
;
13919 digest
[3] -= SHA256M_D
;
13920 digest
[4] -= SHA256M_E
;
13921 digest
[5] -= SHA256M_F
;
13922 digest
[6] -= SHA256M_G
;
13923 digest
[7] -= SHA256M_H
;
13925 return (PARSER_OK
);
13928 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13930 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13932 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13934 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13936 u64
*digest
= (u64
*) hash_buf
->digest
;
13938 salt_t
*salt
= hash_buf
->salt
;
13940 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13942 char *iter_pos
= input_buf
+ 19;
13944 char *salt_pos
= strchr (iter_pos
, '.');
13946 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13950 char *hash_pos
= strchr (salt_pos
, '.');
13952 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13954 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13958 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13959 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13960 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13961 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13962 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13963 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13964 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13965 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13967 uint salt_len
= hash_pos
- salt_pos
- 1;
13971 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13975 for (i
= 0; i
< salt_len
; i
++)
13977 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13980 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13981 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13983 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13985 salt
->salt_len
= salt_len
;
13987 salt
->salt_iter
= atoi (iter_pos
) - 1;
13989 return (PARSER_OK
);
13992 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13994 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13996 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13998 u64
*digest
= (u64
*) hash_buf
->digest
;
14000 salt_t
*salt
= hash_buf
->salt
;
14002 u8 tmp_buf
[120] = { 0 };
14004 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
14006 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
14008 memcpy (digest
, tmp_buf
, 64);
14010 digest
[0] = byte_swap_64 (digest
[0]);
14011 digest
[1] = byte_swap_64 (digest
[1]);
14012 digest
[2] = byte_swap_64 (digest
[2]);
14013 digest
[3] = byte_swap_64 (digest
[3]);
14014 digest
[4] = byte_swap_64 (digest
[4]);
14015 digest
[5] = byte_swap_64 (digest
[5]);
14016 digest
[6] = byte_swap_64 (digest
[6]);
14017 digest
[7] = byte_swap_64 (digest
[7]);
14019 digest
[0] -= SHA512M_A
;
14020 digest
[1] -= SHA512M_B
;
14021 digest
[2] -= SHA512M_C
;
14022 digest
[3] -= SHA512M_D
;
14023 digest
[4] -= SHA512M_E
;
14024 digest
[5] -= SHA512M_F
;
14025 digest
[6] -= SHA512M_G
;
14026 digest
[7] -= SHA512M_H
;
14028 int salt_len
= tmp_len
- 64;
14030 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
14032 salt
->salt_len
= salt_len
;
14034 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
14036 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
14038 char *ptr
= (char *) salt
->salt_buf
;
14040 ptr
[salt
->salt_len
] = 0x80;
14043 return (PARSER_OK
);
14046 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14048 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14050 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
14054 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
14057 u32
*digest
= (u32
*) hash_buf
->digest
;
14059 salt_t
*salt
= hash_buf
->salt
;
14061 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14062 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14063 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14064 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14066 digest
[0] = byte_swap_32 (digest
[0]);
14067 digest
[1] = byte_swap_32 (digest
[1]);
14068 digest
[2] = byte_swap_32 (digest
[2]);
14069 digest
[3] = byte_swap_32 (digest
[3]);
14071 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14073 uint salt_len
= input_len
- 32 - 1;
14075 char *salt_buf
= input_buf
+ 32 + 1;
14077 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14079 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14081 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14083 salt
->salt_len
= salt_len
;
14085 return (PARSER_OK
);
14088 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14090 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14092 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
14096 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
14099 u32
*digest
= (u32
*) hash_buf
->digest
;
14101 salt_t
*salt
= hash_buf
->salt
;
14103 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14104 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14105 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14106 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14107 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14109 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14111 uint salt_len
= input_len
- 40 - 1;
14113 char *salt_buf
= input_buf
+ 40 + 1;
14115 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14117 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14119 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14121 salt
->salt_len
= salt_len
;
14123 return (PARSER_OK
);
14126 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14128 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14130 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14134 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14137 u32
*digest
= (u32
*) hash_buf
->digest
;
14139 salt_t
*salt
= hash_buf
->salt
;
14141 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14142 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14143 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14144 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14145 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14146 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14147 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14148 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14150 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14152 uint salt_len
= input_len
- 64 - 1;
14154 char *salt_buf
= input_buf
+ 64 + 1;
14156 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14158 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14160 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14162 salt
->salt_len
= salt_len
;
14164 return (PARSER_OK
);
14167 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14169 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14171 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14175 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14178 u64
*digest
= (u64
*) hash_buf
->digest
;
14180 salt_t
*salt
= hash_buf
->salt
;
14182 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14183 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14184 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14185 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14186 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14187 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14188 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14189 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14191 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14193 uint salt_len
= input_len
- 128 - 1;
14195 char *salt_buf
= input_buf
+ 128 + 1;
14197 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14199 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14201 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14203 salt
->salt_len
= salt_len
;
14205 return (PARSER_OK
);
14208 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14210 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14212 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14214 u32
*digest
= (u32
*) hash_buf
->digest
;
14216 salt_t
*salt
= hash_buf
->salt
;
14218 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14224 char *user_pos
= input_buf
+ 10 + 1;
14226 char *realm_pos
= strchr (user_pos
, '$');
14228 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14230 uint user_len
= realm_pos
- user_pos
;
14232 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14236 char *salt_pos
= strchr (realm_pos
, '$');
14238 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14240 uint realm_len
= salt_pos
- realm_pos
;
14242 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14246 char *data_pos
= strchr (salt_pos
, '$');
14248 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14250 uint salt_len
= data_pos
- salt_pos
;
14252 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14256 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14258 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14264 memcpy (krb5pa
->user
, user_pos
, user_len
);
14265 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14266 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14268 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14270 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14272 const char p0
= data_pos
[i
+ 0];
14273 const char p1
= data_pos
[i
+ 1];
14275 *timestamp_ptr
++ = hex_convert (p1
) << 0
14276 | hex_convert (p0
) << 4;
14279 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14281 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14283 const char p0
= data_pos
[i
+ 0];
14284 const char p1
= data_pos
[i
+ 1];
14286 *checksum_ptr
++ = hex_convert (p1
) << 0
14287 | hex_convert (p0
) << 4;
14291 * copy some data to generic buffers to make sorting happy
14294 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14295 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14296 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14297 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14298 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14299 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14300 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14301 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14302 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14304 salt
->salt_len
= 36;
14306 digest
[0] = krb5pa
->checksum
[0];
14307 digest
[1] = krb5pa
->checksum
[1];
14308 digest
[2] = krb5pa
->checksum
[2];
14309 digest
[3] = krb5pa
->checksum
[3];
14311 return (PARSER_OK
);
14314 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14316 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14318 u32
*digest
= (u32
*) hash_buf
->digest
;
14320 salt_t
*salt
= hash_buf
->salt
;
14326 char *salt_pos
= input_buf
;
14328 char *hash_pos
= strchr (salt_pos
, '$');
14330 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14332 uint salt_len
= hash_pos
- salt_pos
;
14334 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14338 uint hash_len
= input_len
- 1 - salt_len
;
14340 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14348 for (uint i
= 0; i
< salt_len
; i
++)
14350 if (salt_pos
[i
] == ' ') continue;
14355 // SAP user names cannot be longer than 12 characters
14356 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14358 // SAP user name cannot start with ! or ?
14359 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14365 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14367 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14369 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14371 salt
->salt_len
= salt_len
;
14373 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14374 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14378 digest
[0] = byte_swap_32 (digest
[0]);
14379 digest
[1] = byte_swap_32 (digest
[1]);
14381 return (PARSER_OK
);
14384 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14386 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14388 u32
*digest
= (u32
*) hash_buf
->digest
;
14390 salt_t
*salt
= hash_buf
->salt
;
14396 char *salt_pos
= input_buf
;
14398 char *hash_pos
= strchr (salt_pos
, '$');
14400 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14402 uint salt_len
= hash_pos
- salt_pos
;
14404 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14408 uint hash_len
= input_len
- 1 - salt_len
;
14410 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14418 for (uint i
= 0; i
< salt_len
; i
++)
14420 if (salt_pos
[i
] == ' ') continue;
14425 // SAP user names cannot be longer than 12 characters
14426 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14427 // so far nobody complained so we stay with this because it helps in optimization
14428 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14430 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14432 // SAP user name cannot start with ! or ?
14433 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14439 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14441 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14443 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14445 salt
->salt_len
= salt_len
;
14447 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14448 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14449 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14450 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14451 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14453 return (PARSER_OK
);
14456 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14458 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14460 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14462 u64
*digest
= (u64
*) hash_buf
->digest
;
14464 salt_t
*salt
= hash_buf
->salt
;
14466 char *iter_pos
= input_buf
+ 3;
14468 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14470 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14472 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14474 salt
->salt_iter
= salt_iter
;
14476 char *salt_pos
= iter_pos
+ 1;
14480 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14482 salt
->salt_len
= salt_len
;
14484 char *hash_pos
= salt_pos
+ salt_len
;
14486 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14490 char *tmp
= (char *) salt
->salt_buf_pc
;
14492 tmp
[0] = hash_pos
[42];
14496 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14497 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14498 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14499 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14505 return (PARSER_OK
);
14508 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14510 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14512 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14514 u32
*digest
= (u32
*) hash_buf
->digest
;
14516 salt_t
*salt
= hash_buf
->salt
;
14518 char *salt_buf
= input_buf
+ 6;
14520 uint salt_len
= 16;
14522 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14524 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14526 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14528 salt
->salt_len
= salt_len
;
14530 char *hash_pos
= input_buf
+ 6 + 16;
14532 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14533 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14534 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14535 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14536 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14537 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14538 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14539 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14541 return (PARSER_OK
);
14544 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14546 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14548 u32
*digest
= (u32
*) hash_buf
->digest
;
14550 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14551 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14555 return (PARSER_OK
);
14558 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14560 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14562 u32
*digest
= (u32
*) hash_buf
->digest
;
14564 salt_t
*salt
= hash_buf
->salt
;
14566 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14568 char *saltbuf_pos
= input_buf
;
14570 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14572 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14574 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14576 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14577 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14579 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14583 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14585 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14587 char *salt_ptr
= (char *) saltbuf_pos
;
14588 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14593 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14595 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14598 rakp_ptr
[j
] = 0x80;
14600 rakp
->salt_len
= j
;
14602 for (i
= 0; i
< 64; i
++)
14604 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14607 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14608 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14609 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14610 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14611 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14612 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14613 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14614 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14616 salt
->salt_len
= 32; // muss min. 32 haben
14618 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14619 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14620 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14621 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14622 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14624 return (PARSER_OK
);
14627 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14629 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14631 u32
*digest
= (u32
*) hash_buf
->digest
;
14633 salt_t
*salt
= hash_buf
->salt
;
14635 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14637 char *salt_pos
= input_buf
+ 1;
14639 memcpy (salt
->salt_buf
, salt_pos
, 8);
14641 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14642 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14644 salt
->salt_len
= 8;
14646 char *hash_pos
= salt_pos
+ 8;
14648 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14649 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14650 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14651 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14652 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14654 digest
[0] -= SHA1M_A
;
14655 digest
[1] -= SHA1M_B
;
14656 digest
[2] -= SHA1M_C
;
14657 digest
[3] -= SHA1M_D
;
14658 digest
[4] -= SHA1M_E
;
14660 return (PARSER_OK
);
14663 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14665 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14667 u32
*digest
= (u32
*) hash_buf
->digest
;
14669 salt_t
*salt
= hash_buf
->salt
;
14671 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14672 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14673 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14674 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14676 digest
[0] = byte_swap_32 (digest
[0]);
14677 digest
[1] = byte_swap_32 (digest
[1]);
14678 digest
[2] = byte_swap_32 (digest
[2]);
14679 digest
[3] = byte_swap_32 (digest
[3]);
14681 digest
[0] -= MD5M_A
;
14682 digest
[1] -= MD5M_B
;
14683 digest
[2] -= MD5M_C
;
14684 digest
[3] -= MD5M_D
;
14686 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14688 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14690 u32
*salt_buf
= salt
->salt_buf
;
14692 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14693 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14694 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14695 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14697 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14698 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14699 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14700 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14702 salt
->salt_len
= 16 + 1;
14704 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14706 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14708 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14710 return (PARSER_OK
);
14713 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14715 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14717 u32
*digest
= (u32
*) hash_buf
->digest
;
14719 salt_t
*salt
= hash_buf
->salt
;
14721 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14727 char *hashbuf_pos
= input_buf
;
14729 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14731 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14733 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14735 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14739 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14741 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14743 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14745 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14749 char *databuf_pos
= strchr (iteration_pos
, ':');
14751 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14753 const uint iteration_len
= databuf_pos
- iteration_pos
;
14755 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14756 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14758 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14760 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14761 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14767 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14768 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14769 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14770 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14771 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14772 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14773 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14774 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14778 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14780 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14782 const char p0
= saltbuf_pos
[i
+ 0];
14783 const char p1
= saltbuf_pos
[i
+ 1];
14785 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14786 | hex_convert (p0
) << 4;
14789 salt
->salt_buf
[4] = 0x01000000;
14790 salt
->salt_buf
[5] = 0x80;
14792 salt
->salt_len
= saltbuf_len
/ 2;
14796 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14800 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14802 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14804 const char p0
= databuf_pos
[i
+ 0];
14805 const char p1
= databuf_pos
[i
+ 1];
14807 *databuf_ptr
++ = hex_convert (p1
) << 0
14808 | hex_convert (p0
) << 4;
14811 *databuf_ptr
++ = 0x80;
14813 for (uint i
= 0; i
< 512; i
++)
14815 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14818 cloudkey
->data_len
= databuf_len
/ 2;
14820 return (PARSER_OK
);
14823 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14825 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14827 u32
*digest
= (u32
*) hash_buf
->digest
;
14829 salt_t
*salt
= hash_buf
->salt
;
14835 char *hashbuf_pos
= input_buf
;
14837 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14839 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14841 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14843 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14847 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14849 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14851 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14853 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14855 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14859 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14861 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14863 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14865 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14867 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14871 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14873 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14874 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14876 // ok, the plan for this algorithm is the following:
14877 // we have 2 salts here, the domain-name and a random salt
14878 // while both are used in the initial transformation,
14879 // only the random salt is used in the following iterations
14880 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14881 // and one that includes only the real salt (stored into salt_buf[]).
14882 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14884 u8 tmp_buf
[100] = { 0 };
14886 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14888 memcpy (digest
, tmp_buf
, 20);
14890 digest
[0] = byte_swap_32 (digest
[0]);
14891 digest
[1] = byte_swap_32 (digest
[1]);
14892 digest
[2] = byte_swap_32 (digest
[2]);
14893 digest
[3] = byte_swap_32 (digest
[3]);
14894 digest
[4] = byte_swap_32 (digest
[4]);
14898 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14900 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14902 char *len_ptr
= NULL
;
14904 for (uint i
= 0; i
< domainbuf_len
; i
++)
14906 if (salt_buf_pc_ptr
[i
] == '.')
14908 len_ptr
= &salt_buf_pc_ptr
[i
];
14918 salt
->salt_buf_pc
[7] = domainbuf_len
;
14922 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14924 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14926 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14928 salt
->salt_len
= salt_len
;
14932 salt
->salt_iter
= atoi (iteration_pos
);
14934 return (PARSER_OK
);
14937 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14939 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14941 u32
*digest
= (u32
*) hash_buf
->digest
;
14943 salt_t
*salt
= hash_buf
->salt
;
14945 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14946 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14947 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14948 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14949 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14951 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14953 uint salt_len
= input_len
- 40 - 1;
14955 char *salt_buf
= input_buf
+ 40 + 1;
14957 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14959 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14961 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14963 salt
->salt_len
= salt_len
;
14965 return (PARSER_OK
);
14968 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14970 const u8 ascii_to_ebcdic
[] =
14972 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14973 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14974 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14975 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14976 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14977 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14978 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14979 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14980 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14981 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14982 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14983 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14984 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14985 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14986 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14987 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14990 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14992 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14994 u32
*digest
= (u32
*) hash_buf
->digest
;
14996 salt_t
*salt
= hash_buf
->salt
;
14998 char *salt_pos
= input_buf
+ 6 + 1;
15000 char *digest_pos
= strchr (salt_pos
, '*');
15002 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15004 uint salt_len
= digest_pos
- salt_pos
;
15006 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
15008 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
15010 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
15014 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15015 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
15017 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
15019 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15021 salt
->salt_len
= salt_len
;
15023 for (uint i
= 0; i
< salt_len
; i
++)
15025 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
15027 for (uint i
= salt_len
; i
< 8; i
++)
15029 salt_buf_pc_ptr
[i
] = 0x40;
15034 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
15036 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
15037 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
15039 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
15040 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
15042 digest
[0] = byte_swap_32 (digest
[0]);
15043 digest
[1] = byte_swap_32 (digest
[1]);
15045 IP (digest
[0], digest
[1], tt
);
15047 digest
[0] = rotr32 (digest
[0], 29);
15048 digest
[1] = rotr32 (digest
[1], 29);
15052 return (PARSER_OK
);
15055 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15057 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
15059 u32
*digest
= (u32
*) hash_buf
->digest
;
15061 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15062 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15063 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15064 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15066 digest
[0] = byte_swap_32 (digest
[0]);
15067 digest
[1] = byte_swap_32 (digest
[1]);
15068 digest
[2] = byte_swap_32 (digest
[2]);
15069 digest
[3] = byte_swap_32 (digest
[3]);
15071 return (PARSER_OK
);
15074 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15076 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
15078 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15080 u32
*digest
= (u32
*) hash_buf
->digest
;
15082 salt_t
*salt
= hash_buf
->salt
;
15084 u8 tmp_buf
[120] = { 0 };
15086 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15088 tmp_buf
[3] += -4; // dont ask!
15090 memcpy (salt
->salt_buf
, tmp_buf
, 5);
15092 salt
->salt_len
= 5;
15094 memcpy (digest
, tmp_buf
+ 5, 9);
15096 // yes, only 9 byte are needed to crack, but 10 to display
15098 salt
->salt_buf_pc
[7] = input_buf
[20];
15100 return (PARSER_OK
);
15103 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15105 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
15107 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15109 u32
*digest
= (u32
*) hash_buf
->digest
;
15111 salt_t
*salt
= hash_buf
->salt
;
15113 u8 tmp_buf
[120] = { 0 };
15115 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15117 tmp_buf
[3] += -4; // dont ask!
15121 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15123 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)
15127 char tmp_iter_buf
[11] = { 0 };
15129 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15131 tmp_iter_buf
[10] = 0;
15133 salt
->salt_iter
= atoi (tmp_iter_buf
);
15135 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15137 return (PARSER_SALT_ITERATION
);
15140 salt
->salt_iter
--; // first round in init
15142 // 2 additional bytes for display only
15144 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15145 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15149 memcpy (digest
, tmp_buf
+ 28, 8);
15151 digest
[0] = byte_swap_32 (digest
[0]);
15152 digest
[1] = byte_swap_32 (digest
[1]);
15156 return (PARSER_OK
);
15159 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15161 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15163 u32
*digest
= (u32
*) hash_buf
->digest
;
15165 salt_t
*salt
= hash_buf
->salt
;
15167 char *salt_buf_pos
= input_buf
;
15169 char *hash_buf_pos
= salt_buf_pos
+ 6;
15171 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15172 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15173 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15174 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15175 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15176 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15177 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15178 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15180 digest
[0] -= SHA256M_A
;
15181 digest
[1] -= SHA256M_B
;
15182 digest
[2] -= SHA256M_C
;
15183 digest
[3] -= SHA256M_D
;
15184 digest
[4] -= SHA256M_E
;
15185 digest
[5] -= SHA256M_F
;
15186 digest
[6] -= SHA256M_G
;
15187 digest
[7] -= SHA256M_H
;
15189 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15191 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15193 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15195 salt
->salt_len
= salt_len
;
15197 return (PARSER_OK
);
15200 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15202 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15204 u32
*digest
= (u32
*) hash_buf
->digest
;
15206 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15208 salt_t
*salt
= hash_buf
->salt
;
15210 char *salt_buf
= input_buf
+ 6;
15212 char *digest_buf
= strchr (salt_buf
, '$');
15214 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15216 uint salt_len
= digest_buf
- salt_buf
;
15218 digest_buf
++; // skip the '$' symbol
15220 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15222 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15224 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15226 salt
->salt_len
= salt_len
;
15228 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15229 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15230 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15231 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15233 digest
[0] = byte_swap_32 (digest
[0]);
15234 digest
[1] = byte_swap_32 (digest
[1]);
15235 digest
[2] = byte_swap_32 (digest
[2]);
15236 digest
[3] = byte_swap_32 (digest
[3]);
15238 digest
[0] -= MD5M_A
;
15239 digest
[1] -= MD5M_B
;
15240 digest
[2] -= MD5M_C
;
15241 digest
[3] -= MD5M_D
;
15243 return (PARSER_OK
);
15246 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15248 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15250 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15252 u32
*digest
= (u32
*) hash_buf
->digest
;
15254 salt_t
*salt
= hash_buf
->salt
;
15256 char *salt_buf
= input_buf
+ 3;
15258 char *digest_buf
= strchr (salt_buf
, '$');
15260 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15262 uint salt_len
= digest_buf
- salt_buf
;
15264 digest_buf
++; // skip the '$' symbol
15266 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15268 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15270 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15272 salt_buf_ptr
[salt_len
] = 0x2d;
15274 salt
->salt_len
= salt_len
+ 1;
15276 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15277 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15278 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15279 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15281 digest
[0] = byte_swap_32 (digest
[0]);
15282 digest
[1] = byte_swap_32 (digest
[1]);
15283 digest
[2] = byte_swap_32 (digest
[2]);
15284 digest
[3] = byte_swap_32 (digest
[3]);
15286 digest
[0] -= MD5M_A
;
15287 digest
[1] -= MD5M_B
;
15288 digest
[2] -= MD5M_C
;
15289 digest
[3] -= MD5M_D
;
15291 return (PARSER_OK
);
15294 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15296 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15298 u32
*digest
= (u32
*) hash_buf
->digest
;
15300 salt_t
*salt
= hash_buf
->salt
;
15302 u8 tmp_buf
[100] = { 0 };
15304 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15306 memcpy (digest
, tmp_buf
, 20);
15308 digest
[0] = byte_swap_32 (digest
[0]);
15309 digest
[1] = byte_swap_32 (digest
[1]);
15310 digest
[2] = byte_swap_32 (digest
[2]);
15311 digest
[3] = byte_swap_32 (digest
[3]);
15312 digest
[4] = byte_swap_32 (digest
[4]);
15314 digest
[0] -= SHA1M_A
;
15315 digest
[1] -= SHA1M_B
;
15316 digest
[2] -= SHA1M_C
;
15317 digest
[3] -= SHA1M_D
;
15318 digest
[4] -= SHA1M_E
;
15320 salt
->salt_buf
[0] = 0x80;
15322 salt
->salt_len
= 0;
15324 return (PARSER_OK
);
15327 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15329 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15331 u32
*digest
= (u32
*) hash_buf
->digest
;
15333 salt_t
*salt
= hash_buf
->salt
;
15335 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15336 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15337 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15338 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15340 digest
[0] = byte_swap_32 (digest
[0]);
15341 digest
[1] = byte_swap_32 (digest
[1]);
15342 digest
[2] = byte_swap_32 (digest
[2]);
15343 digest
[3] = byte_swap_32 (digest
[3]);
15345 digest
[0] -= MD5M_A
;
15346 digest
[1] -= MD5M_B
;
15347 digest
[2] -= MD5M_C
;
15348 digest
[3] -= MD5M_D
;
15350 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15352 uint salt_len
= input_len
- 32 - 1;
15354 char *salt_buf
= input_buf
+ 32 + 1;
15356 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15358 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15360 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15363 * add static "salt" part
15366 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15370 salt
->salt_len
= salt_len
;
15372 return (PARSER_OK
);
15375 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15377 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15379 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15381 u32
*digest
= (u32
*) hash_buf
->digest
;
15383 salt_t
*salt
= hash_buf
->salt
;
15385 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15391 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15393 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15395 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15397 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15399 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15403 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15405 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15407 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15409 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15413 char *keybuf_pos
= strchr (keylen_pos
, '$');
15415 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15417 uint keylen_len
= keybuf_pos
- keylen_pos
;
15419 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15423 char *databuf_pos
= strchr (keybuf_pos
, '$');
15425 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15427 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15429 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15433 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15435 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15441 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15442 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15443 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15444 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15446 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15447 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15448 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15449 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15451 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15452 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15453 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15454 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15456 salt
->salt_len
= 16;
15457 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15459 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15461 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15464 return (PARSER_OK
);
15467 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15469 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15471 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15473 u32
*digest
= (u32
*) hash_buf
->digest
;
15475 salt_t
*salt
= hash_buf
->salt
;
15481 // first is the N salt parameter
15483 char *N_pos
= input_buf
+ 6;
15485 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15489 salt
->scrypt_N
= atoi (N_pos
);
15493 char *r_pos
= strchr (N_pos
, ':');
15495 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15499 salt
->scrypt_r
= atoi (r_pos
);
15503 char *p_pos
= strchr (r_pos
, ':');
15505 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15509 salt
->scrypt_p
= atoi (p_pos
);
15513 char *saltbuf_pos
= strchr (p_pos
, ':');
15515 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15519 char *hash_pos
= strchr (saltbuf_pos
, ':');
15521 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15527 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15529 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15531 u8 tmp_buf
[33] = { 0 };
15533 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15535 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15537 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15539 salt
->salt_len
= tmp_len
;
15540 salt
->salt_iter
= 1;
15542 // digest - base64 decode
15544 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15546 tmp_len
= input_len
- (hash_pos
- input_buf
);
15548 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15550 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15552 memcpy (digest
, tmp_buf
, 32);
15554 return (PARSER_OK
);
15557 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15559 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15561 u32
*digest
= (u32
*) hash_buf
->digest
;
15563 salt_t
*salt
= hash_buf
->salt
;
15569 char decrypted
[76] = { 0 }; // iv + hash
15571 juniper_decrypt_hash (input_buf
, decrypted
);
15573 char *md5crypt_hash
= decrypted
+ 12;
15575 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15577 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15579 char *salt_pos
= md5crypt_hash
+ 3;
15581 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15583 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15585 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15589 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15591 return (PARSER_OK
);
15594 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15596 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15598 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15600 u32
*digest
= (u32
*) hash_buf
->digest
;
15602 salt_t
*salt
= hash_buf
->salt
;
15604 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15610 // first is *raw* salt
15612 char *salt_pos
= input_buf
+ 3;
15614 char *hash_pos
= strchr (salt_pos
, '$');
15616 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15618 uint salt_len
= hash_pos
- salt_pos
;
15620 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15624 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15626 memcpy (salt_buf_ptr
, salt_pos
, 14);
15628 salt_buf_ptr
[17] = 0x01;
15629 salt_buf_ptr
[18] = 0x80;
15631 // add some stuff to normal salt to make sorted happy
15633 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15634 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15635 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15636 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15638 salt
->salt_len
= salt_len
;
15639 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15641 // base64 decode hash
15643 u8 tmp_buf
[100] = { 0 };
15645 uint hash_len
= input_len
- 3 - salt_len
- 1;
15647 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15649 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15651 memcpy (digest
, tmp_buf
, 32);
15653 digest
[0] = byte_swap_32 (digest
[0]);
15654 digest
[1] = byte_swap_32 (digest
[1]);
15655 digest
[2] = byte_swap_32 (digest
[2]);
15656 digest
[3] = byte_swap_32 (digest
[3]);
15657 digest
[4] = byte_swap_32 (digest
[4]);
15658 digest
[5] = byte_swap_32 (digest
[5]);
15659 digest
[6] = byte_swap_32 (digest
[6]);
15660 digest
[7] = byte_swap_32 (digest
[7]);
15662 return (PARSER_OK
);
15665 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15667 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15669 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15671 u32
*digest
= (u32
*) hash_buf
->digest
;
15673 salt_t
*salt
= hash_buf
->salt
;
15679 // first is *raw* salt
15681 char *salt_pos
= input_buf
+ 3;
15683 char *hash_pos
= strchr (salt_pos
, '$');
15685 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15687 uint salt_len
= hash_pos
- salt_pos
;
15689 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15691 salt
->salt_len
= salt_len
;
15694 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15696 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15697 salt_buf_ptr
[salt_len
] = 0;
15699 // base64 decode hash
15701 u8 tmp_buf
[100] = { 0 };
15703 uint hash_len
= input_len
- 3 - salt_len
- 1;
15705 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15707 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15709 memcpy (digest
, tmp_buf
, 32);
15712 salt
->scrypt_N
= 16384;
15713 salt
->scrypt_r
= 1;
15714 salt
->scrypt_p
= 1;
15715 salt
->salt_iter
= 1;
15717 return (PARSER_OK
);
15720 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15722 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15724 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15726 u32
*digest
= (u32
*) hash_buf
->digest
;
15728 salt_t
*salt
= hash_buf
->salt
;
15730 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15736 char *version_pos
= input_buf
+ 8 + 1;
15738 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15740 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15742 u32 version_len
= verifierHashSize_pos
- version_pos
;
15744 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15746 verifierHashSize_pos
++;
15748 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15750 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15752 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15754 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15758 char *saltSize_pos
= strchr (keySize_pos
, '*');
15760 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15762 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15764 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15768 char *osalt_pos
= strchr (saltSize_pos
, '*');
15770 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15772 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15774 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15778 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15780 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15782 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15784 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15786 encryptedVerifier_pos
++;
15788 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15790 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15792 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15794 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15796 encryptedVerifierHash_pos
++;
15798 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;
15800 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15802 const uint version
= atoi (version_pos
);
15804 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15806 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15808 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15810 const uint keySize
= atoi (keySize_pos
);
15812 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15814 office2007
->keySize
= keySize
;
15816 const uint saltSize
= atoi (saltSize_pos
);
15818 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15824 salt
->salt_len
= 16;
15825 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15827 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15828 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15829 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15830 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15836 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15837 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15838 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15839 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15841 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15842 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15843 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15844 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15845 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15851 digest
[0] = office2007
->encryptedVerifierHash
[0];
15852 digest
[1] = office2007
->encryptedVerifierHash
[1];
15853 digest
[2] = office2007
->encryptedVerifierHash
[2];
15854 digest
[3] = office2007
->encryptedVerifierHash
[3];
15856 return (PARSER_OK
);
15859 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15861 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15863 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15865 u32
*digest
= (u32
*) hash_buf
->digest
;
15867 salt_t
*salt
= hash_buf
->salt
;
15869 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15875 char *version_pos
= input_buf
+ 8 + 1;
15877 char *spinCount_pos
= strchr (version_pos
, '*');
15879 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15881 u32 version_len
= spinCount_pos
- version_pos
;
15883 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15887 char *keySize_pos
= strchr (spinCount_pos
, '*');
15889 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15891 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15893 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15897 char *saltSize_pos
= strchr (keySize_pos
, '*');
15899 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15901 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15903 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15907 char *osalt_pos
= strchr (saltSize_pos
, '*');
15909 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15911 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15913 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15917 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15919 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15921 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15923 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15925 encryptedVerifier_pos
++;
15927 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15929 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15931 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15933 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15935 encryptedVerifierHash_pos
++;
15937 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;
15939 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15941 const uint version
= atoi (version_pos
);
15943 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15945 const uint spinCount
= atoi (spinCount_pos
);
15947 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15949 const uint keySize
= atoi (keySize_pos
);
15951 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15953 const uint saltSize
= atoi (saltSize_pos
);
15955 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15961 salt
->salt_len
= 16;
15962 salt
->salt_iter
= spinCount
;
15964 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15965 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15966 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15967 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15973 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15974 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15975 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15976 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15978 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15979 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15980 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15981 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15982 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15983 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15984 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15985 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15991 digest
[0] = office2010
->encryptedVerifierHash
[0];
15992 digest
[1] = office2010
->encryptedVerifierHash
[1];
15993 digest
[2] = office2010
->encryptedVerifierHash
[2];
15994 digest
[3] = office2010
->encryptedVerifierHash
[3];
15996 return (PARSER_OK
);
15999 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16001 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
16003 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
16005 u32
*digest
= (u32
*) hash_buf
->digest
;
16007 salt_t
*salt
= hash_buf
->salt
;
16009 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
16015 char *version_pos
= input_buf
+ 8 + 1;
16017 char *spinCount_pos
= strchr (version_pos
, '*');
16019 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16021 u32 version_len
= spinCount_pos
- version_pos
;
16023 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
16027 char *keySize_pos
= strchr (spinCount_pos
, '*');
16029 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16031 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
16033 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
16037 char *saltSize_pos
= strchr (keySize_pos
, '*');
16039 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16041 u32 keySize_len
= saltSize_pos
- keySize_pos
;
16043 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
16047 char *osalt_pos
= strchr (saltSize_pos
, '*');
16049 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16051 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
16053 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
16057 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16059 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16061 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16063 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16065 encryptedVerifier_pos
++;
16067 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16069 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16071 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16073 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16075 encryptedVerifierHash_pos
++;
16077 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;
16079 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
16081 const uint version
= atoi (version_pos
);
16083 if (version
!= 2013) return (PARSER_SALT_VALUE
);
16085 const uint spinCount
= atoi (spinCount_pos
);
16087 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
16089 const uint keySize
= atoi (keySize_pos
);
16091 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
16093 const uint saltSize
= atoi (saltSize_pos
);
16095 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
16101 salt
->salt_len
= 16;
16102 salt
->salt_iter
= spinCount
;
16104 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16105 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16106 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16107 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16113 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16114 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16115 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16116 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16118 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16119 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16120 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16121 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16122 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16123 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16124 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16125 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16131 digest
[0] = office2013
->encryptedVerifierHash
[0];
16132 digest
[1] = office2013
->encryptedVerifierHash
[1];
16133 digest
[2] = office2013
->encryptedVerifierHash
[2];
16134 digest
[3] = office2013
->encryptedVerifierHash
[3];
16136 return (PARSER_OK
);
16139 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16141 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16143 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16145 u32
*digest
= (u32
*) hash_buf
->digest
;
16147 salt_t
*salt
= hash_buf
->salt
;
16149 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16155 char *version_pos
= input_buf
+ 11;
16157 char *osalt_pos
= strchr (version_pos
, '*');
16159 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16161 u32 version_len
= osalt_pos
- version_pos
;
16163 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16167 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16169 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16171 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16173 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16175 encryptedVerifier_pos
++;
16177 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16179 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16181 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16183 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16185 encryptedVerifierHash_pos
++;
16187 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16189 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16191 const uint version
= *version_pos
- 0x30;
16193 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16199 oldoffice01
->version
= version
;
16201 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16202 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16203 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16204 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16206 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16207 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16208 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16209 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16211 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16212 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16213 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16214 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16216 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16217 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16218 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16219 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16225 salt
->salt_len
= 16;
16227 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16228 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16229 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16230 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16232 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16233 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16234 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16235 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16237 // this is a workaround as office produces multiple documents with the same salt
16239 salt
->salt_len
+= 32;
16241 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16242 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16243 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16244 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16245 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16246 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16247 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16248 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16254 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16255 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16256 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16257 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16259 return (PARSER_OK
);
16262 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16264 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16267 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16269 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16271 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16273 u32
*digest
= (u32
*) hash_buf
->digest
;
16275 salt_t
*salt
= hash_buf
->salt
;
16277 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16283 char *version_pos
= input_buf
+ 11;
16285 char *osalt_pos
= strchr (version_pos
, '*');
16287 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16289 u32 version_len
= osalt_pos
- version_pos
;
16291 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16295 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16297 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16299 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16301 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16303 encryptedVerifier_pos
++;
16305 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16307 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16309 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16311 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16313 encryptedVerifierHash_pos
++;
16315 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16317 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16319 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16321 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16325 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16327 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16329 const uint version
= *version_pos
- 0x30;
16331 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16337 oldoffice01
->version
= version
;
16339 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16340 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16341 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16342 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16344 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16345 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16346 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16347 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16349 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16350 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16351 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16352 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16354 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16355 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16356 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16357 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16359 oldoffice01
->rc4key
[1] = 0;
16360 oldoffice01
->rc4key
[0] = 0;
16362 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16363 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16364 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16365 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16366 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16367 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16368 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16369 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16370 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16371 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16373 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16374 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16380 salt
->salt_len
= 16;
16382 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16383 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16384 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16385 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16387 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16388 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16389 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16390 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16392 // this is a workaround as office produces multiple documents with the same salt
16394 salt
->salt_len
+= 32;
16396 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16397 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16398 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16399 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16400 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16401 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16402 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16403 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16409 digest
[0] = oldoffice01
->rc4key
[0];
16410 digest
[1] = oldoffice01
->rc4key
[1];
16414 return (PARSER_OK
);
16417 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16419 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16421 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16423 u32
*digest
= (u32
*) hash_buf
->digest
;
16425 salt_t
*salt
= hash_buf
->salt
;
16427 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16433 char *version_pos
= input_buf
+ 11;
16435 char *osalt_pos
= strchr (version_pos
, '*');
16437 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16439 u32 version_len
= osalt_pos
- version_pos
;
16441 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16445 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16447 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16449 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16451 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16453 encryptedVerifier_pos
++;
16455 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16457 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16459 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16461 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16463 encryptedVerifierHash_pos
++;
16465 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16467 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16469 const uint version
= *version_pos
- 0x30;
16471 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16477 oldoffice34
->version
= version
;
16479 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16480 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16481 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16482 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16484 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16485 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16486 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16487 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16489 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16490 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16491 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16492 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16493 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16495 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16496 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16497 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16498 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16499 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16505 salt
->salt_len
= 16;
16507 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16508 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16509 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16510 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16512 // this is a workaround as office produces multiple documents with the same salt
16514 salt
->salt_len
+= 32;
16516 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16517 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16518 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16519 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16520 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16521 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16522 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16523 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16529 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16530 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16531 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16532 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16534 return (PARSER_OK
);
16537 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16539 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16541 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16544 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16546 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16548 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16550 u32
*digest
= (u32
*) hash_buf
->digest
;
16552 salt_t
*salt
= hash_buf
->salt
;
16554 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16560 char *version_pos
= input_buf
+ 11;
16562 char *osalt_pos
= strchr (version_pos
, '*');
16564 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16566 u32 version_len
= osalt_pos
- version_pos
;
16568 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16572 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16574 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16576 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16578 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16580 encryptedVerifier_pos
++;
16582 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16584 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16586 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16588 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16590 encryptedVerifierHash_pos
++;
16592 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16594 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16596 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16598 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16602 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16604 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16606 const uint version
= *version_pos
- 0x30;
16608 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16614 oldoffice34
->version
= version
;
16616 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16617 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16618 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16619 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16621 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16622 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16623 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16624 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16626 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16627 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16628 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16629 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16630 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16632 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16633 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16634 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16635 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16636 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16638 oldoffice34
->rc4key
[1] = 0;
16639 oldoffice34
->rc4key
[0] = 0;
16641 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16642 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16643 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16644 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16645 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16646 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16647 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16648 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16649 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16650 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16652 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16653 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16659 salt
->salt_len
= 16;
16661 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16662 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16663 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16664 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16666 // this is a workaround as office produces multiple documents with the same salt
16668 salt
->salt_len
+= 32;
16670 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16671 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16672 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16673 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16674 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16675 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16676 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16677 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16683 digest
[0] = oldoffice34
->rc4key
[0];
16684 digest
[1] = oldoffice34
->rc4key
[1];
16688 return (PARSER_OK
);
16691 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16693 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16695 u32
*digest
= (u32
*) hash_buf
->digest
;
16697 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16698 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16699 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16700 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16702 digest
[0] = byte_swap_32 (digest
[0]);
16703 digest
[1] = byte_swap_32 (digest
[1]);
16704 digest
[2] = byte_swap_32 (digest
[2]);
16705 digest
[3] = byte_swap_32 (digest
[3]);
16707 return (PARSER_OK
);
16710 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16712 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16714 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16716 u32
*digest
= (u32
*) hash_buf
->digest
;
16718 salt_t
*salt
= hash_buf
->salt
;
16720 char *signature_pos
= input_buf
;
16722 char *salt_pos
= strchr (signature_pos
, '$');
16724 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16726 u32 signature_len
= salt_pos
- signature_pos
;
16728 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16732 char *hash_pos
= strchr (salt_pos
, '$');
16734 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16736 u32 salt_len
= hash_pos
- salt_pos
;
16738 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16742 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16744 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16746 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16747 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16748 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16749 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16750 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16752 digest
[0] -= SHA1M_A
;
16753 digest
[1] -= SHA1M_B
;
16754 digest
[2] -= SHA1M_C
;
16755 digest
[3] -= SHA1M_D
;
16756 digest
[4] -= SHA1M_E
;
16758 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16760 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16762 salt
->salt_len
= salt_len
;
16764 return (PARSER_OK
);
16767 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16769 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16771 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16773 u32
*digest
= (u32
*) hash_buf
->digest
;
16775 salt_t
*salt
= hash_buf
->salt
;
16777 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16783 char *iter_pos
= input_buf
+ 14;
16785 const int iter
= atoi (iter_pos
);
16787 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16789 salt
->salt_iter
= iter
- 1;
16791 char *salt_pos
= strchr (iter_pos
, '$');
16793 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16797 char *hash_pos
= strchr (salt_pos
, '$');
16799 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16801 const uint salt_len
= hash_pos
- salt_pos
;
16805 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16807 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16809 salt
->salt_len
= salt_len
;
16811 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16812 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16814 // add some stuff to normal salt to make sorted happy
16816 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16817 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16818 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16819 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16820 salt
->salt_buf
[4] = salt
->salt_iter
;
16822 // base64 decode hash
16824 u8 tmp_buf
[100] = { 0 };
16826 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16828 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16830 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16832 memcpy (digest
, tmp_buf
, 32);
16834 digest
[0] = byte_swap_32 (digest
[0]);
16835 digest
[1] = byte_swap_32 (digest
[1]);
16836 digest
[2] = byte_swap_32 (digest
[2]);
16837 digest
[3] = byte_swap_32 (digest
[3]);
16838 digest
[4] = byte_swap_32 (digest
[4]);
16839 digest
[5] = byte_swap_32 (digest
[5]);
16840 digest
[6] = byte_swap_32 (digest
[6]);
16841 digest
[7] = byte_swap_32 (digest
[7]);
16843 return (PARSER_OK
);
16846 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16848 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16850 u32
*digest
= (u32
*) hash_buf
->digest
;
16852 salt_t
*salt
= hash_buf
->salt
;
16854 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16855 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16859 digest
[0] = byte_swap_32 (digest
[0]);
16860 digest
[1] = byte_swap_32 (digest
[1]);
16862 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16863 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16864 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16866 char iter_c
= input_buf
[17];
16867 char iter_d
= input_buf
[19];
16869 // atm only defaults, let's see if there's more request
16870 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16871 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16873 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16875 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16876 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16877 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16878 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16880 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16881 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16882 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16883 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16885 salt
->salt_len
= 16;
16887 return (PARSER_OK
);
16890 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16892 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16894 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16896 u32
*digest
= (u32
*) hash_buf
->digest
;
16898 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16900 salt_t
*salt
= hash_buf
->salt
;
16902 char *salt_pos
= input_buf
+ 10;
16904 char *hash_pos
= strchr (salt_pos
, '$');
16906 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16908 uint salt_len
= hash_pos
- salt_pos
;
16912 uint hash_len
= input_len
- 10 - salt_len
- 1;
16914 // base64 decode salt
16916 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16918 u8 tmp_buf
[100] = { 0 };
16920 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16922 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16924 tmp_buf
[salt_len
] = 0x80;
16926 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16928 salt
->salt_len
= salt_len
;
16930 // base64 decode hash
16932 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16934 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16936 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16938 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16940 uint user_len
= hash_len
- 32;
16942 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16944 user_len
--; // skip the trailing space
16946 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16947 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16948 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16949 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16951 digest
[0] = byte_swap_32 (digest
[0]);
16952 digest
[1] = byte_swap_32 (digest
[1]);
16953 digest
[2] = byte_swap_32 (digest
[2]);
16954 digest
[3] = byte_swap_32 (digest
[3]);
16956 // store username for host only (output hash if cracked)
16958 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16959 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16961 return (PARSER_OK
);
16964 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16966 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16968 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16970 u32
*digest
= (u32
*) hash_buf
->digest
;
16972 salt_t
*salt
= hash_buf
->salt
;
16974 char *iter_pos
= input_buf
+ 10;
16976 u32 iter
= atoi (iter_pos
);
16980 return (PARSER_SALT_ITERATION
);
16983 iter
--; // first iteration is special
16985 salt
->salt_iter
= iter
;
16987 char *base64_pos
= strchr (iter_pos
, '}');
16989 if (base64_pos
== NULL
)
16991 return (PARSER_SIGNATURE_UNMATCHED
);
16996 // base64 decode salt
16998 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
17000 u8 tmp_buf
[100] = { 0 };
17002 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
17004 if (decoded_len
< 24)
17006 return (PARSER_SALT_LENGTH
);
17011 uint salt_len
= decoded_len
- 20;
17013 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
17014 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
17016 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
17018 salt
->salt_len
= salt_len
;
17022 u32
*digest_ptr
= (u32
*) tmp_buf
;
17024 digest
[0] = byte_swap_32 (digest_ptr
[0]);
17025 digest
[1] = byte_swap_32 (digest_ptr
[1]);
17026 digest
[2] = byte_swap_32 (digest_ptr
[2]);
17027 digest
[3] = byte_swap_32 (digest_ptr
[3]);
17028 digest
[4] = byte_swap_32 (digest_ptr
[4]);
17030 return (PARSER_OK
);
17033 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17035 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
17037 u32
*digest
= (u32
*) hash_buf
->digest
;
17039 salt_t
*salt
= hash_buf
->salt
;
17041 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17042 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17043 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17044 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17045 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
17047 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17049 uint salt_len
= input_len
- 40 - 1;
17051 char *salt_buf
= input_buf
+ 40 + 1;
17053 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17055 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17057 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
17059 salt
->salt_len
= salt_len
;
17061 return (PARSER_OK
);
17064 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17066 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
17068 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17070 u32
*digest
= (u32
*) hash_buf
->digest
;
17072 salt_t
*salt
= hash_buf
->salt
;
17074 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17080 char *V_pos
= input_buf
+ 5;
17082 char *R_pos
= strchr (V_pos
, '*');
17084 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17086 u32 V_len
= R_pos
- V_pos
;
17090 char *bits_pos
= strchr (R_pos
, '*');
17092 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17094 u32 R_len
= bits_pos
- R_pos
;
17098 char *P_pos
= strchr (bits_pos
, '*');
17100 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17102 u32 bits_len
= P_pos
- bits_pos
;
17106 char *enc_md_pos
= strchr (P_pos
, '*');
17108 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17110 u32 P_len
= enc_md_pos
- P_pos
;
17114 char *id_len_pos
= strchr (enc_md_pos
, '*');
17116 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17118 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17122 char *id_buf_pos
= strchr (id_len_pos
, '*');
17124 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17126 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17130 char *u_len_pos
= strchr (id_buf_pos
, '*');
17132 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17134 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17136 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17140 char *u_buf_pos
= strchr (u_len_pos
, '*');
17142 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17144 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17148 char *o_len_pos
= strchr (u_buf_pos
, '*');
17150 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17152 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17154 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17158 char *o_buf_pos
= strchr (o_len_pos
, '*');
17160 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17162 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17166 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;
17168 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17172 const int V
= atoi (V_pos
);
17173 const int R
= atoi (R_pos
);
17174 const int P
= atoi (P_pos
);
17176 if (V
!= 1) return (PARSER_SALT_VALUE
);
17177 if (R
!= 2) return (PARSER_SALT_VALUE
);
17179 const int enc_md
= atoi (enc_md_pos
);
17181 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17183 const int id_len
= atoi (id_len_pos
);
17184 const int u_len
= atoi (u_len_pos
);
17185 const int o_len
= atoi (o_len_pos
);
17187 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17188 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17189 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17191 const int bits
= atoi (bits_pos
);
17193 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17195 // copy data to esalt
17201 pdf
->enc_md
= enc_md
;
17203 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17204 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17205 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17206 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17207 pdf
->id_len
= id_len
;
17209 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17210 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17211 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17212 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17213 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17214 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17215 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17216 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17217 pdf
->u_len
= u_len
;
17219 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17220 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17221 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17222 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17223 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17224 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17225 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17226 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17227 pdf
->o_len
= o_len
;
17229 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17230 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17231 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17232 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17234 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17235 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17236 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17237 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17238 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17239 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17240 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17241 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17243 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17244 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17245 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17246 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17247 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17248 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17249 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17250 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17252 // we use ID for salt, maybe needs to change, we will see...
17254 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17255 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17256 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17257 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17258 salt
->salt_len
= pdf
->id_len
;
17260 digest
[0] = pdf
->u_buf
[0];
17261 digest
[1] = pdf
->u_buf
[1];
17262 digest
[2] = pdf
->u_buf
[2];
17263 digest
[3] = pdf
->u_buf
[3];
17265 return (PARSER_OK
);
17268 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17270 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17273 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17275 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17277 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17279 u32
*digest
= (u32
*) hash_buf
->digest
;
17281 salt_t
*salt
= hash_buf
->salt
;
17283 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17289 char *V_pos
= input_buf
+ 5;
17291 char *R_pos
= strchr (V_pos
, '*');
17293 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17295 u32 V_len
= R_pos
- V_pos
;
17299 char *bits_pos
= strchr (R_pos
, '*');
17301 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17303 u32 R_len
= bits_pos
- R_pos
;
17307 char *P_pos
= strchr (bits_pos
, '*');
17309 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17311 u32 bits_len
= P_pos
- bits_pos
;
17315 char *enc_md_pos
= strchr (P_pos
, '*');
17317 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17319 u32 P_len
= enc_md_pos
- P_pos
;
17323 char *id_len_pos
= strchr (enc_md_pos
, '*');
17325 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17327 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17331 char *id_buf_pos
= strchr (id_len_pos
, '*');
17333 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17335 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17339 char *u_len_pos
= strchr (id_buf_pos
, '*');
17341 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17343 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17345 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17349 char *u_buf_pos
= strchr (u_len_pos
, '*');
17351 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17353 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17357 char *o_len_pos
= strchr (u_buf_pos
, '*');
17359 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17361 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17363 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17367 char *o_buf_pos
= strchr (o_len_pos
, '*');
17369 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17371 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17375 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17377 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17379 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17381 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17385 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;
17387 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17391 const int V
= atoi (V_pos
);
17392 const int R
= atoi (R_pos
);
17393 const int P
= atoi (P_pos
);
17395 if (V
!= 1) return (PARSER_SALT_VALUE
);
17396 if (R
!= 2) return (PARSER_SALT_VALUE
);
17398 const int enc_md
= atoi (enc_md_pos
);
17400 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17402 const int id_len
= atoi (id_len_pos
);
17403 const int u_len
= atoi (u_len_pos
);
17404 const int o_len
= atoi (o_len_pos
);
17406 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17407 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17408 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17410 const int bits
= atoi (bits_pos
);
17412 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17414 // copy data to esalt
17420 pdf
->enc_md
= enc_md
;
17422 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17423 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17424 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17425 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17426 pdf
->id_len
= id_len
;
17428 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17429 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17430 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17431 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17432 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17433 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17434 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17435 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17436 pdf
->u_len
= u_len
;
17438 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17439 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17440 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17441 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17442 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17443 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17444 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17445 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17446 pdf
->o_len
= o_len
;
17448 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17449 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17450 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17451 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17453 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17454 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17455 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17456 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17457 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17458 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17459 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17460 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17462 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17463 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17464 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17465 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17466 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17467 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17468 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17469 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17471 pdf
->rc4key
[1] = 0;
17472 pdf
->rc4key
[0] = 0;
17474 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17475 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17476 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17477 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17478 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17479 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17480 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17481 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17482 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17483 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17485 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17486 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17488 // we use ID for salt, maybe needs to change, we will see...
17490 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17491 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17492 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17493 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17494 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17495 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17496 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17497 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17498 salt
->salt_len
= pdf
->id_len
+ 16;
17500 digest
[0] = pdf
->rc4key
[0];
17501 digest
[1] = pdf
->rc4key
[1];
17505 return (PARSER_OK
);
17508 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17510 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17512 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17514 u32
*digest
= (u32
*) hash_buf
->digest
;
17516 salt_t
*salt
= hash_buf
->salt
;
17518 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17524 char *V_pos
= input_buf
+ 5;
17526 char *R_pos
= strchr (V_pos
, '*');
17528 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17530 u32 V_len
= R_pos
- V_pos
;
17534 char *bits_pos
= strchr (R_pos
, '*');
17536 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17538 u32 R_len
= bits_pos
- R_pos
;
17542 char *P_pos
= strchr (bits_pos
, '*');
17544 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17546 u32 bits_len
= P_pos
- bits_pos
;
17550 char *enc_md_pos
= strchr (P_pos
, '*');
17552 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17554 u32 P_len
= enc_md_pos
- P_pos
;
17558 char *id_len_pos
= strchr (enc_md_pos
, '*');
17560 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17562 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17566 char *id_buf_pos
= strchr (id_len_pos
, '*');
17568 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17570 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17574 char *u_len_pos
= strchr (id_buf_pos
, '*');
17576 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17578 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17580 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17584 char *u_buf_pos
= strchr (u_len_pos
, '*');
17586 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17588 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17592 char *o_len_pos
= strchr (u_buf_pos
, '*');
17594 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17596 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17598 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17602 char *o_buf_pos
= strchr (o_len_pos
, '*');
17604 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17606 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17610 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;
17612 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17616 const int V
= atoi (V_pos
);
17617 const int R
= atoi (R_pos
);
17618 const int P
= atoi (P_pos
);
17622 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17623 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17625 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17627 const int id_len
= atoi (id_len_pos
);
17628 const int u_len
= atoi (u_len_pos
);
17629 const int o_len
= atoi (o_len_pos
);
17631 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17633 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17634 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17636 const int bits
= atoi (bits_pos
);
17638 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17644 enc_md
= atoi (enc_md_pos
);
17647 // copy data to esalt
17653 pdf
->enc_md
= enc_md
;
17655 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17656 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17657 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17658 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17662 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17663 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17664 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17665 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17668 pdf
->id_len
= id_len
;
17670 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17671 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17672 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17673 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17674 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17675 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17676 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17677 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17678 pdf
->u_len
= u_len
;
17680 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17681 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17682 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17683 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17684 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17685 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17686 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17687 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17688 pdf
->o_len
= o_len
;
17690 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17691 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17692 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17693 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17697 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17698 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17699 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17700 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17703 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17704 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17705 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17706 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17707 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17708 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17709 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17710 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17712 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17713 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17714 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17715 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17716 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17717 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17718 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17719 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17721 // precompute rc4 data for later use
17737 uint salt_pc_block
[32] = { 0 };
17739 char *salt_pc_ptr
= (char *) salt_pc_block
;
17741 memcpy (salt_pc_ptr
, padding
, 32);
17742 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17744 uint salt_pc_digest
[4] = { 0 };
17746 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17748 pdf
->rc4data
[0] = salt_pc_digest
[0];
17749 pdf
->rc4data
[1] = salt_pc_digest
[1];
17751 // we use ID for salt, maybe needs to change, we will see...
17753 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17754 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17755 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17756 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17757 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17758 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17759 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17760 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17761 salt
->salt_len
= pdf
->id_len
+ 16;
17763 salt
->salt_iter
= ROUNDS_PDF14
;
17765 digest
[0] = pdf
->u_buf
[0];
17766 digest
[1] = pdf
->u_buf
[1];
17770 return (PARSER_OK
);
17773 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17775 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17777 if (ret
!= PARSER_OK
)
17782 u32
*digest
= (u32
*) hash_buf
->digest
;
17784 salt_t
*salt
= hash_buf
->salt
;
17786 digest
[0] -= SHA256M_A
;
17787 digest
[1] -= SHA256M_B
;
17788 digest
[2] -= SHA256M_C
;
17789 digest
[3] -= SHA256M_D
;
17790 digest
[4] -= SHA256M_E
;
17791 digest
[5] -= SHA256M_F
;
17792 digest
[6] -= SHA256M_G
;
17793 digest
[7] -= SHA256M_H
;
17795 salt
->salt_buf
[2] = 0x80;
17797 return (PARSER_OK
);
17800 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17802 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17804 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17806 u32
*digest
= (u32
*) hash_buf
->digest
;
17808 salt_t
*salt
= hash_buf
->salt
;
17810 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17816 char *V_pos
= input_buf
+ 5;
17818 char *R_pos
= strchr (V_pos
, '*');
17820 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17822 u32 V_len
= R_pos
- V_pos
;
17826 char *bits_pos
= strchr (R_pos
, '*');
17828 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17830 u32 R_len
= bits_pos
- R_pos
;
17834 char *P_pos
= strchr (bits_pos
, '*');
17836 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17838 u32 bits_len
= P_pos
- bits_pos
;
17842 char *enc_md_pos
= strchr (P_pos
, '*');
17844 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17846 u32 P_len
= enc_md_pos
- P_pos
;
17850 char *id_len_pos
= strchr (enc_md_pos
, '*');
17852 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17854 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17858 char *id_buf_pos
= strchr (id_len_pos
, '*');
17860 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17862 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17866 char *u_len_pos
= strchr (id_buf_pos
, '*');
17868 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17870 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17874 char *u_buf_pos
= strchr (u_len_pos
, '*');
17876 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17878 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17882 char *o_len_pos
= strchr (u_buf_pos
, '*');
17884 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17886 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17890 char *o_buf_pos
= strchr (o_len_pos
, '*');
17892 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17894 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17898 char *last
= strchr (o_buf_pos
, '*');
17900 if (last
== NULL
) last
= input_buf
+ input_len
;
17902 u32 o_buf_len
= last
- o_buf_pos
;
17906 const int V
= atoi (V_pos
);
17907 const int R
= atoi (R_pos
);
17911 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17912 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17914 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17916 const int bits
= atoi (bits_pos
);
17918 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17920 int enc_md
= atoi (enc_md_pos
);
17922 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17924 const uint id_len
= atoi (id_len_pos
);
17925 const uint u_len
= atoi (u_len_pos
);
17926 const uint o_len
= atoi (o_len_pos
);
17928 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17929 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17930 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17931 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17932 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17933 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17934 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17935 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17937 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17938 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17939 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17941 // copy data to esalt
17943 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17945 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17947 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17950 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17951 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17953 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17954 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17956 salt
->salt_len
= 8;
17957 salt
->salt_iter
= ROUNDS_PDF17L8
;
17959 digest
[0] = pdf
->u_buf
[0];
17960 digest
[1] = pdf
->u_buf
[1];
17961 digest
[2] = pdf
->u_buf
[2];
17962 digest
[3] = pdf
->u_buf
[3];
17963 digest
[4] = pdf
->u_buf
[4];
17964 digest
[5] = pdf
->u_buf
[5];
17965 digest
[6] = pdf
->u_buf
[6];
17966 digest
[7] = pdf
->u_buf
[7];
17968 return (PARSER_OK
);
17971 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17973 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17975 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17977 u32
*digest
= (u32
*) hash_buf
->digest
;
17979 salt_t
*salt
= hash_buf
->salt
;
17981 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17989 char *iter_pos
= input_buf
+ 7;
17991 u32 iter
= atoi (iter_pos
);
17993 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17994 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17996 // first is *raw* salt
17998 char *salt_pos
= strchr (iter_pos
, ':');
18000 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18004 char *hash_pos
= strchr (salt_pos
, ':');
18006 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18008 u32 salt_len
= hash_pos
- salt_pos
;
18010 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18014 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18016 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18020 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
18022 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18024 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18026 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18027 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18029 salt
->salt_len
= salt_len
;
18030 salt
->salt_iter
= iter
- 1;
18034 u8 tmp_buf
[100] = { 0 };
18036 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18038 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18040 memcpy (digest
, tmp_buf
, 16);
18042 digest
[0] = byte_swap_32 (digest
[0]);
18043 digest
[1] = byte_swap_32 (digest
[1]);
18044 digest
[2] = byte_swap_32 (digest
[2]);
18045 digest
[3] = byte_swap_32 (digest
[3]);
18047 // add some stuff to normal salt to make sorted happy
18049 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
18050 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
18051 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
18052 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
18053 salt
->salt_buf
[4] = salt
->salt_iter
;
18055 return (PARSER_OK
);
18058 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18060 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
18062 u32
*digest
= (u32
*) hash_buf
->digest
;
18064 salt_t
*salt
= hash_buf
->salt
;
18066 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18067 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18068 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18069 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18071 digest
[0] = byte_swap_32 (digest
[0]);
18072 digest
[1] = byte_swap_32 (digest
[1]);
18073 digest
[2] = byte_swap_32 (digest
[2]);
18074 digest
[3] = byte_swap_32 (digest
[3]);
18076 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18078 uint salt_len
= input_len
- 32 - 1;
18080 char *salt_buf
= input_buf
+ 32 + 1;
18082 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18084 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18086 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18088 salt
->salt_len
= salt_len
;
18090 return (PARSER_OK
);
18093 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18095 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
18097 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18099 u32
*digest
= (u32
*) hash_buf
->digest
;
18101 salt_t
*salt
= hash_buf
->salt
;
18103 char *user_pos
= input_buf
+ 10;
18105 char *salt_pos
= strchr (user_pos
, '*');
18107 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18111 char *hash_pos
= strchr (salt_pos
, '*');
18115 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18117 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18119 uint user_len
= salt_pos
- user_pos
- 1;
18121 uint salt_len
= hash_pos
- salt_pos
- 1;
18123 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18129 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18130 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18131 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18132 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18134 digest
[0] = byte_swap_32 (digest
[0]);
18135 digest
[1] = byte_swap_32 (digest
[1]);
18136 digest
[2] = byte_swap_32 (digest
[2]);
18137 digest
[3] = byte_swap_32 (digest
[3]);
18139 digest
[0] -= MD5M_A
;
18140 digest
[1] -= MD5M_B
;
18141 digest
[2] -= MD5M_C
;
18142 digest
[3] -= MD5M_D
;
18148 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18150 // first 4 bytes are the "challenge"
18152 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18153 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18154 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18155 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18157 // append the user name
18159 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18161 salt
->salt_len
= 4 + user_len
;
18163 return (PARSER_OK
);
18166 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18168 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18170 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18172 u32
*digest
= (u32
*) hash_buf
->digest
;
18174 salt_t
*salt
= hash_buf
->salt
;
18176 char *salt_pos
= input_buf
+ 9;
18178 char *hash_pos
= strchr (salt_pos
, '*');
18180 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18184 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18186 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18188 uint salt_len
= hash_pos
- salt_pos
- 1;
18190 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18196 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18197 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18198 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18199 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18200 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18206 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18208 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18210 salt
->salt_len
= salt_len
;
18212 return (PARSER_OK
);
18215 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18217 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18219 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18221 u32
*digest
= (u32
*) hash_buf
->digest
;
18223 salt_t
*salt
= hash_buf
->salt
;
18225 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18231 char *cry_master_len_pos
= input_buf
+ 9;
18233 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18235 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18237 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18239 cry_master_buf_pos
++;
18241 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18243 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18245 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18247 cry_salt_len_pos
++;
18249 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18251 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18253 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18255 cry_salt_buf_pos
++;
18257 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18259 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18261 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18265 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18267 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18269 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18273 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18275 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18277 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18281 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18283 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18285 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18287 public_key_len_pos
++;
18289 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18291 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18293 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18295 public_key_buf_pos
++;
18297 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;
18299 const uint cry_master_len
= atoi (cry_master_len_pos
);
18300 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18301 const uint ckey_len
= atoi (ckey_len_pos
);
18302 const uint public_key_len
= atoi (public_key_len_pos
);
18304 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18305 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18306 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18307 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18309 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18311 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18313 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18316 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18318 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18320 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18323 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18325 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18327 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18330 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18331 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18332 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18335 * store digest (should be unique enought, hopefully)
18338 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18339 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18340 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18341 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18347 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18349 const uint cry_rounds
= atoi (cry_rounds_pos
);
18351 salt
->salt_iter
= cry_rounds
- 1;
18353 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18355 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18357 salt
->salt_len
= salt_len
;
18359 return (PARSER_OK
);
18362 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18364 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18366 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18368 u32
*digest
= (u32
*) hash_buf
->digest
;
18370 salt_t
*salt
= hash_buf
->salt
;
18372 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18374 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18376 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18378 memcpy (temp_input_buf
, input_buf
, input_len
);
18382 char *URI_server_pos
= temp_input_buf
+ 6;
18384 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18386 if (URI_client_pos
== NULL
)
18388 myfree (temp_input_buf
);
18390 return (PARSER_SEPARATOR_UNMATCHED
);
18393 URI_client_pos
[0] = 0;
18396 uint URI_server_len
= strlen (URI_server_pos
);
18398 if (URI_server_len
> 512)
18400 myfree (temp_input_buf
);
18402 return (PARSER_SALT_LENGTH
);
18407 char *user_pos
= strchr (URI_client_pos
, '*');
18409 if (user_pos
== NULL
)
18411 myfree (temp_input_buf
);
18413 return (PARSER_SEPARATOR_UNMATCHED
);
18419 uint URI_client_len
= strlen (URI_client_pos
);
18421 if (URI_client_len
> 512)
18423 myfree (temp_input_buf
);
18425 return (PARSER_SALT_LENGTH
);
18430 char *realm_pos
= strchr (user_pos
, '*');
18432 if (realm_pos
== NULL
)
18434 myfree (temp_input_buf
);
18436 return (PARSER_SEPARATOR_UNMATCHED
);
18442 uint user_len
= strlen (user_pos
);
18444 if (user_len
> 116)
18446 myfree (temp_input_buf
);
18448 return (PARSER_SALT_LENGTH
);
18453 char *method_pos
= strchr (realm_pos
, '*');
18455 if (method_pos
== NULL
)
18457 myfree (temp_input_buf
);
18459 return (PARSER_SEPARATOR_UNMATCHED
);
18465 uint realm_len
= strlen (realm_pos
);
18467 if (realm_len
> 116)
18469 myfree (temp_input_buf
);
18471 return (PARSER_SALT_LENGTH
);
18476 char *URI_prefix_pos
= strchr (method_pos
, '*');
18478 if (URI_prefix_pos
== NULL
)
18480 myfree (temp_input_buf
);
18482 return (PARSER_SEPARATOR_UNMATCHED
);
18485 URI_prefix_pos
[0] = 0;
18488 uint method_len
= strlen (method_pos
);
18490 if (method_len
> 246)
18492 myfree (temp_input_buf
);
18494 return (PARSER_SALT_LENGTH
);
18499 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18501 if (URI_resource_pos
== NULL
)
18503 myfree (temp_input_buf
);
18505 return (PARSER_SEPARATOR_UNMATCHED
);
18508 URI_resource_pos
[0] = 0;
18509 URI_resource_pos
++;
18511 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18513 if (URI_prefix_len
> 245)
18515 myfree (temp_input_buf
);
18517 return (PARSER_SALT_LENGTH
);
18522 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18524 if (URI_suffix_pos
== NULL
)
18526 myfree (temp_input_buf
);
18528 return (PARSER_SEPARATOR_UNMATCHED
);
18531 URI_suffix_pos
[0] = 0;
18534 uint URI_resource_len
= strlen (URI_resource_pos
);
18536 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18538 myfree (temp_input_buf
);
18540 return (PARSER_SALT_LENGTH
);
18545 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18547 if (nonce_pos
== NULL
)
18549 myfree (temp_input_buf
);
18551 return (PARSER_SEPARATOR_UNMATCHED
);
18557 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18559 if (URI_suffix_len
> 245)
18561 myfree (temp_input_buf
);
18563 return (PARSER_SALT_LENGTH
);
18568 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18570 if (nonce_client_pos
== NULL
)
18572 myfree (temp_input_buf
);
18574 return (PARSER_SEPARATOR_UNMATCHED
);
18577 nonce_client_pos
[0] = 0;
18578 nonce_client_pos
++;
18580 uint nonce_len
= strlen (nonce_pos
);
18582 if (nonce_len
< 1 || nonce_len
> 50)
18584 myfree (temp_input_buf
);
18586 return (PARSER_SALT_LENGTH
);
18591 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18593 if (nonce_count_pos
== NULL
)
18595 myfree (temp_input_buf
);
18597 return (PARSER_SEPARATOR_UNMATCHED
);
18600 nonce_count_pos
[0] = 0;
18603 uint nonce_client_len
= strlen (nonce_client_pos
);
18605 if (nonce_client_len
> 50)
18607 myfree (temp_input_buf
);
18609 return (PARSER_SALT_LENGTH
);
18614 char *qop_pos
= strchr (nonce_count_pos
, '*');
18616 if (qop_pos
== NULL
)
18618 myfree (temp_input_buf
);
18620 return (PARSER_SEPARATOR_UNMATCHED
);
18626 uint nonce_count_len
= strlen (nonce_count_pos
);
18628 if (nonce_count_len
> 50)
18630 myfree (temp_input_buf
);
18632 return (PARSER_SALT_LENGTH
);
18637 char *directive_pos
= strchr (qop_pos
, '*');
18639 if (directive_pos
== NULL
)
18641 myfree (temp_input_buf
);
18643 return (PARSER_SEPARATOR_UNMATCHED
);
18646 directive_pos
[0] = 0;
18649 uint qop_len
= strlen (qop_pos
);
18653 myfree (temp_input_buf
);
18655 return (PARSER_SALT_LENGTH
);
18660 char *digest_pos
= strchr (directive_pos
, '*');
18662 if (digest_pos
== NULL
)
18664 myfree (temp_input_buf
);
18666 return (PARSER_SEPARATOR_UNMATCHED
);
18672 uint directive_len
= strlen (directive_pos
);
18674 if (directive_len
!= 3)
18676 myfree (temp_input_buf
);
18678 return (PARSER_SALT_LENGTH
);
18681 if (memcmp (directive_pos
, "MD5", 3))
18683 log_info ("ERROR: Only the MD5 directive is currently supported\n");
18685 myfree (temp_input_buf
);
18687 return (PARSER_SIP_AUTH_DIRECTIVE
);
18691 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18696 uint md5_max_len
= 4 * 64;
18698 uint md5_remaining_len
= md5_max_len
;
18700 uint tmp_md5_buf
[64] = { 0 };
18702 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18704 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18706 md5_len
+= method_len
+ 1;
18707 tmp_md5_ptr
+= method_len
+ 1;
18709 if (URI_prefix_len
> 0)
18711 md5_remaining_len
= md5_max_len
- md5_len
;
18713 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18715 md5_len
+= URI_prefix_len
+ 1;
18716 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18719 md5_remaining_len
= md5_max_len
- md5_len
;
18721 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18723 md5_len
+= URI_resource_len
;
18724 tmp_md5_ptr
+= URI_resource_len
;
18726 if (URI_suffix_len
> 0)
18728 md5_remaining_len
= md5_max_len
- md5_len
;
18730 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18732 md5_len
+= 1 + URI_suffix_len
;
18735 uint tmp_digest
[4] = { 0 };
18737 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18739 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18740 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18741 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18742 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18748 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18750 uint esalt_len
= 0;
18752 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18754 // there are 2 possibilities for the esalt:
18756 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18758 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18760 if (esalt_len
> max_esalt_len
)
18762 myfree (temp_input_buf
);
18764 return (PARSER_SALT_LENGTH
);
18767 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18779 esalt_len
= 1 + nonce_len
+ 1 + 32;
18781 if (esalt_len
> max_esalt_len
)
18783 myfree (temp_input_buf
);
18785 return (PARSER_SALT_LENGTH
);
18788 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18796 // add 0x80 to esalt
18798 esalt_buf_ptr
[esalt_len
] = 0x80;
18800 sip
->esalt_len
= esalt_len
;
18806 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18808 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18810 uint max_salt_len
= 119;
18812 if (salt_len
> max_salt_len
)
18814 myfree (temp_input_buf
);
18816 return (PARSER_SALT_LENGTH
);
18819 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18821 sip
->salt_len
= salt_len
;
18824 * fake salt (for sorting)
18827 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18831 uint fake_salt_len
= salt_len
;
18833 if (fake_salt_len
> max_salt_len
)
18835 fake_salt_len
= max_salt_len
;
18838 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18840 salt
->salt_len
= fake_salt_len
;
18846 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18847 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18848 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18849 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18851 digest
[0] = byte_swap_32 (digest
[0]);
18852 digest
[1] = byte_swap_32 (digest
[1]);
18853 digest
[2] = byte_swap_32 (digest
[2]);
18854 digest
[3] = byte_swap_32 (digest
[3]);
18856 myfree (temp_input_buf
);
18858 return (PARSER_OK
);
18861 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18863 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18865 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18867 u32
*digest
= (u32
*) hash_buf
->digest
;
18869 salt_t
*salt
= hash_buf
->salt
;
18873 char *digest_pos
= input_buf
;
18875 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18882 char *salt_buf
= input_buf
+ 8 + 1;
18886 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18888 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18890 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18892 salt
->salt_len
= salt_len
;
18894 return (PARSER_OK
);
18897 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18899 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18901 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18903 u32
*digest
= (u32
*) hash_buf
->digest
;
18905 salt_t
*salt
= hash_buf
->salt
;
18907 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18913 char *p_buf_pos
= input_buf
+ 4;
18915 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18917 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18919 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18921 NumCyclesPower_pos
++;
18923 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18925 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18927 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18931 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18933 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18935 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18939 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18941 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18943 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18947 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18949 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18951 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18955 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18957 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18959 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18963 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18965 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18967 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18971 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18973 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18975 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18979 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18981 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18983 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18987 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;
18989 const uint iter
= atoi (NumCyclesPower_pos
);
18990 const uint crc
= atoi (crc_buf_pos
);
18991 const uint p_buf
= atoi (p_buf_pos
);
18992 const uint salt_len
= atoi (salt_len_pos
);
18993 const uint iv_len
= atoi (iv_len_pos
);
18994 const uint unpack_size
= atoi (unpack_size_pos
);
18995 const uint data_len
= atoi (data_len_pos
);
19001 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
19002 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
19004 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
19006 if (data_len
> 384) return (PARSER_SALT_VALUE
);
19008 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
19014 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
19015 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
19016 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
19017 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
19019 seven_zip
->iv_len
= iv_len
;
19021 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
19023 seven_zip
->salt_len
= 0;
19025 seven_zip
->crc
= crc
;
19027 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
19029 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
19031 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
19034 seven_zip
->data_len
= data_len
;
19036 seven_zip
->unpack_size
= unpack_size
;
19040 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
19041 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
19042 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
19043 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
19045 salt
->salt_len
= 16;
19047 salt
->salt_sign
[0] = iter
;
19049 salt
->salt_iter
= 1 << iter
;
19060 return (PARSER_OK
);
19063 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19065 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
19067 u32
*digest
= (u32
*) hash_buf
->digest
;
19069 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19070 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19071 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19072 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19073 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19074 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19075 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19076 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19078 digest
[0] = byte_swap_32 (digest
[0]);
19079 digest
[1] = byte_swap_32 (digest
[1]);
19080 digest
[2] = byte_swap_32 (digest
[2]);
19081 digest
[3] = byte_swap_32 (digest
[3]);
19082 digest
[4] = byte_swap_32 (digest
[4]);
19083 digest
[5] = byte_swap_32 (digest
[5]);
19084 digest
[6] = byte_swap_32 (digest
[6]);
19085 digest
[7] = byte_swap_32 (digest
[7]);
19087 return (PARSER_OK
);
19090 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19092 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
19094 u32
*digest
= (u32
*) hash_buf
->digest
;
19096 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19097 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19098 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
19099 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
19100 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
19101 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
19102 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
19103 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
19104 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
19105 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
19106 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
19107 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
19108 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
19109 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
19110 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
19111 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
19113 digest
[ 0] = byte_swap_32 (digest
[ 0]);
19114 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19115 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19116 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19117 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19118 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19119 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19120 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19121 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19122 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19123 digest
[10] = byte_swap_32 (digest
[10]);
19124 digest
[11] = byte_swap_32 (digest
[11]);
19125 digest
[12] = byte_swap_32 (digest
[12]);
19126 digest
[13] = byte_swap_32 (digest
[13]);
19127 digest
[14] = byte_swap_32 (digest
[14]);
19128 digest
[15] = byte_swap_32 (digest
[15]);
19130 return (PARSER_OK
);
19133 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19135 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19137 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19139 u32
*digest
= (u32
*) hash_buf
->digest
;
19141 salt_t
*salt
= hash_buf
->salt
;
19143 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19151 char *iter_pos
= input_buf
+ 4;
19153 u32 iter
= atoi (iter_pos
);
19155 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19156 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19158 // first is *raw* salt
19160 char *salt_pos
= strchr (iter_pos
, ':');
19162 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19166 char *hash_pos
= strchr (salt_pos
, ':');
19168 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19170 u32 salt_len
= hash_pos
- salt_pos
;
19172 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19176 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19178 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19182 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19184 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19186 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19188 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19189 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19191 salt
->salt_len
= salt_len
;
19192 salt
->salt_iter
= iter
- 1;
19196 u8 tmp_buf
[100] = { 0 };
19198 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19200 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19202 memcpy (digest
, tmp_buf
, 16);
19204 // add some stuff to normal salt to make sorted happy
19206 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19207 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19208 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19209 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19210 salt
->salt_buf
[4] = salt
->salt_iter
;
19212 return (PARSER_OK
);
19215 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19217 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19219 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19221 u32
*digest
= (u32
*) hash_buf
->digest
;
19223 salt_t
*salt
= hash_buf
->salt
;
19225 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19233 char *iter_pos
= input_buf
+ 5;
19235 u32 iter
= atoi (iter_pos
);
19237 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19238 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19240 // first is *raw* salt
19242 char *salt_pos
= strchr (iter_pos
, ':');
19244 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19248 char *hash_pos
= strchr (salt_pos
, ':');
19250 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19252 u32 salt_len
= hash_pos
- salt_pos
;
19254 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19258 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19260 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19264 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19266 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19268 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19270 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19271 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19273 salt
->salt_len
= salt_len
;
19274 salt
->salt_iter
= iter
- 1;
19278 u8 tmp_buf
[100] = { 0 };
19280 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19282 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19284 memcpy (digest
, tmp_buf
, 16);
19286 digest
[0] = byte_swap_32 (digest
[0]);
19287 digest
[1] = byte_swap_32 (digest
[1]);
19288 digest
[2] = byte_swap_32 (digest
[2]);
19289 digest
[3] = byte_swap_32 (digest
[3]);
19291 // add some stuff to normal salt to make sorted happy
19293 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19294 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19295 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19296 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19297 salt
->salt_buf
[4] = salt
->salt_iter
;
19299 return (PARSER_OK
);
19302 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19304 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19306 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19308 u64
*digest
= (u64
*) hash_buf
->digest
;
19310 salt_t
*salt
= hash_buf
->salt
;
19312 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19320 char *iter_pos
= input_buf
+ 7;
19322 u32 iter
= atoi (iter_pos
);
19324 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19325 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19327 // first is *raw* salt
19329 char *salt_pos
= strchr (iter_pos
, ':');
19331 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19335 char *hash_pos
= strchr (salt_pos
, ':');
19337 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19339 u32 salt_len
= hash_pos
- salt_pos
;
19341 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19345 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19347 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19351 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19353 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19355 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19357 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19358 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19360 salt
->salt_len
= salt_len
;
19361 salt
->salt_iter
= iter
- 1;
19365 u8 tmp_buf
[100] = { 0 };
19367 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19369 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19371 memcpy (digest
, tmp_buf
, 64);
19373 digest
[0] = byte_swap_64 (digest
[0]);
19374 digest
[1] = byte_swap_64 (digest
[1]);
19375 digest
[2] = byte_swap_64 (digest
[2]);
19376 digest
[3] = byte_swap_64 (digest
[3]);
19377 digest
[4] = byte_swap_64 (digest
[4]);
19378 digest
[5] = byte_swap_64 (digest
[5]);
19379 digest
[6] = byte_swap_64 (digest
[6]);
19380 digest
[7] = byte_swap_64 (digest
[7]);
19382 // add some stuff to normal salt to make sorted happy
19384 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19385 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19386 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19387 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19388 salt
->salt_buf
[4] = salt
->salt_iter
;
19390 return (PARSER_OK
);
19393 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19395 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19397 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19399 uint
*digest
= (uint
*) hash_buf
->digest
;
19401 salt_t
*salt
= hash_buf
->salt
;
19407 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19409 char *hash_pos
= strchr (salt_pos
, '$');
19411 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19413 u32 salt_len
= hash_pos
- salt_pos
;
19415 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19419 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19421 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19425 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19426 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19444 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19445 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19447 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19448 salt
->salt_len
= 8;
19450 return (PARSER_OK
);
19453 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19455 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19457 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19459 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19461 if (c19
& 3) return (PARSER_HASH_VALUE
);
19463 salt_t
*salt
= hash_buf
->salt
;
19465 u32
*digest
= (u32
*) hash_buf
->digest
;
19469 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19470 | itoa64_to_int (input_buf
[2]) << 6
19471 | itoa64_to_int (input_buf
[3]) << 12
19472 | itoa64_to_int (input_buf
[4]) << 18;
19476 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19477 | itoa64_to_int (input_buf
[6]) << 6
19478 | itoa64_to_int (input_buf
[7]) << 12
19479 | itoa64_to_int (input_buf
[8]) << 18;
19481 salt
->salt_len
= 4;
19483 u8 tmp_buf
[100] = { 0 };
19485 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19487 memcpy (digest
, tmp_buf
, 8);
19491 IP (digest
[0], digest
[1], tt
);
19493 digest
[0] = rotr32 (digest
[0], 31);
19494 digest
[1] = rotr32 (digest
[1], 31);
19498 return (PARSER_OK
);
19501 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19503 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19505 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19507 u32
*digest
= (u32
*) hash_buf
->digest
;
19509 salt_t
*salt
= hash_buf
->salt
;
19515 char *type_pos
= input_buf
+ 6 + 1;
19517 char *salt_pos
= strchr (type_pos
, '*');
19519 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19521 u32 type_len
= salt_pos
- type_pos
;
19523 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19527 char *crypted_pos
= strchr (salt_pos
, '*');
19529 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19531 u32 salt_len
= crypted_pos
- salt_pos
;
19533 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19537 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19539 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19545 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19546 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19548 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19549 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19551 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19552 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19553 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19554 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19556 salt
->salt_len
= 24;
19557 salt
->salt_iter
= ROUNDS_RAR3
;
19559 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19560 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19562 digest
[0] = 0xc43d7b00;
19563 digest
[1] = 0x40070000;
19567 return (PARSER_OK
);
19570 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19572 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19574 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19576 u32
*digest
= (u32
*) hash_buf
->digest
;
19578 salt_t
*salt
= hash_buf
->salt
;
19580 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19586 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19588 char *param1_pos
= strchr (param0_pos
, '$');
19590 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19592 u32 param0_len
= param1_pos
- param0_pos
;
19596 char *param2_pos
= strchr (param1_pos
, '$');
19598 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19600 u32 param1_len
= param2_pos
- param1_pos
;
19604 char *param3_pos
= strchr (param2_pos
, '$');
19606 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19608 u32 param2_len
= param3_pos
- param2_pos
;
19612 char *param4_pos
= strchr (param3_pos
, '$');
19614 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19616 u32 param3_len
= param4_pos
- param3_pos
;
19620 char *param5_pos
= strchr (param4_pos
, '$');
19622 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19624 u32 param4_len
= param5_pos
- param4_pos
;
19628 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19630 char *salt_buf
= param1_pos
;
19631 char *iv
= param3_pos
;
19632 char *pswcheck
= param5_pos
;
19634 const uint salt_len
= atoi (param0_pos
);
19635 const uint iterations
= atoi (param2_pos
);
19636 const uint pswcheck_len
= atoi (param4_pos
);
19642 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19643 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19644 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19646 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19647 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19648 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19654 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19655 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19656 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19657 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19659 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19660 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19661 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19662 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19664 salt
->salt_len
= 16;
19666 salt
->salt_sign
[0] = iterations
;
19668 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19674 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19675 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19679 return (PARSER_OK
);
19682 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19684 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19686 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19688 u32
*digest
= (u32
*) hash_buf
->digest
;
19690 salt_t
*salt
= hash_buf
->salt
;
19692 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19699 char *account_pos
= input_buf
+ 11 + 1;
19705 if (account_pos
[0] == '*')
19709 data_pos
= strchr (account_pos
, '*');
19714 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19716 uint account_len
= data_pos
- account_pos
+ 1;
19718 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19723 data_len
= input_len
- 11 - 1 - account_len
- 2;
19725 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19729 /* assume $krb5tgs$23$checksum$edata2 */
19730 data_pos
= account_pos
;
19732 memcpy (krb5tgs
->account_info
, "**", 3);
19734 data_len
= input_len
- 11 - 1 - 1;
19737 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19739 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19741 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19743 const char p0
= data_pos
[i
+ 0];
19744 const char p1
= data_pos
[i
+ 1];
19746 *checksum_ptr
++ = hex_convert (p1
) << 0
19747 | hex_convert (p0
) << 4;
19750 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19752 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19755 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19757 const char p0
= data_pos
[i
+ 0];
19758 const char p1
= data_pos
[i
+ 1];
19759 *edata_ptr
++ = hex_convert (p1
) << 0
19760 | hex_convert (p0
) << 4;
19763 /* this is needed for hmac_md5 */
19764 *edata_ptr
++ = 0x80;
19766 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19767 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19768 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19769 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19771 salt
->salt_len
= 32;
19773 digest
[0] = krb5tgs
->checksum
[0];
19774 digest
[1] = krb5tgs
->checksum
[1];
19775 digest
[2] = krb5tgs
->checksum
[2];
19776 digest
[3] = krb5tgs
->checksum
[3];
19778 return (PARSER_OK
);
19781 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19783 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19785 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19787 u32
*digest
= (u32
*) hash_buf
->digest
;
19789 salt_t
*salt
= hash_buf
->salt
;
19796 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19800 char *wrapped_key_pos
;
19804 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19806 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19808 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19810 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19815 data_pos
= salt_pos
;
19817 wrapped_key_pos
= strchr (salt_pos
, '*');
19819 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19821 uint salt_len
= wrapped_key_pos
- salt_pos
;
19823 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19828 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19830 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19832 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19833 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19834 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19835 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19839 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19840 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19841 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19842 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19843 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19844 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19846 salt
->salt_len
= 40;
19848 digest
[0] = salt
->salt_buf
[0];
19849 digest
[1] = salt
->salt_buf
[1];
19850 digest
[2] = salt
->salt_buf
[2];
19851 digest
[3] = salt
->salt_buf
[3];
19853 return (PARSER_OK
);
19856 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19858 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19860 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19862 u32
*digest
= (u32
*) hash_buf
->digest
;
19864 salt_t
*salt
= hash_buf
->salt
;
19866 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19876 char *algorithm_pos
;
19878 char *final_random_seed_pos
;
19879 u32 final_random_seed_len
;
19881 char *transf_random_seed_pos
;
19882 u32 transf_random_seed_len
;
19887 /* default is no keyfile provided */
19888 char *keyfile_len_pos
;
19889 u32 keyfile_len
= 0;
19890 u32 is_keyfile_present
= 0;
19891 char *keyfile_inline_pos
;
19894 /* specific to version 1 */
19895 char *contents_len_pos
;
19897 char *contents_pos
;
19899 /* specific to version 2 */
19900 char *expected_bytes_pos
;
19901 u32 expected_bytes_len
;
19903 char *contents_hash_pos
;
19904 u32 contents_hash_len
;
19906 version_pos
= input_buf
+ 8 + 1 + 1;
19908 keepass
->version
= atoi (version_pos
);
19910 rounds_pos
= strchr (version_pos
, '*');
19912 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19916 salt
->salt_iter
= (atoi (rounds_pos
));
19918 algorithm_pos
= strchr (rounds_pos
, '*');
19920 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19924 keepass
->algorithm
= atoi (algorithm_pos
);
19926 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19928 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19930 final_random_seed_pos
++;
19932 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19933 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19934 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19935 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19937 if (keepass
->version
== 2)
19939 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19940 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19941 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19942 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19945 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19947 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19949 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19951 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19952 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19954 transf_random_seed_pos
++;
19956 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19957 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19958 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19959 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19960 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19961 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19962 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19963 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19965 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19967 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19969 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19971 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19975 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19976 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19977 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19978 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19980 if (keepass
->version
== 1)
19982 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19984 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19986 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19988 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19990 contents_hash_pos
++;
19992 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19993 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19994 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19995 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19996 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19997 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19998 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19999 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20001 /* get length of contents following */
20002 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
20004 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20006 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
20008 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20012 u32 inline_flag
= atoi (inline_flag_pos
);
20014 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
20016 contents_len_pos
= strchr (inline_flag_pos
, '*');
20018 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20020 contents_len_pos
++;
20022 contents_len
= atoi (contents_len_pos
);
20024 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
20026 contents_pos
= strchr (contents_len_pos
, '*');
20028 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20034 keepass
->contents_len
= contents_len
;
20036 contents_len
= contents_len
/ 4;
20038 keyfile_inline_pos
= strchr (contents_pos
, '*');
20040 u32 real_contents_len
;
20042 if (keyfile_inline_pos
== NULL
)
20043 real_contents_len
= input_len
- (contents_pos
- input_buf
);
20046 real_contents_len
= keyfile_inline_pos
- contents_pos
;
20047 keyfile_inline_pos
++;
20048 is_keyfile_present
= 1;
20051 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
20053 for (i
= 0; i
< contents_len
; i
++)
20054 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
20056 else if (keepass
->version
== 2)
20058 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
20060 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20062 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
20064 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
20066 expected_bytes_pos
++;
20068 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
20069 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
20070 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
20071 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
20072 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
20073 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
20074 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
20075 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
20077 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
20079 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20081 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
20083 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
20085 contents_hash_pos
++;
20087 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
20088 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
20089 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
20090 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20091 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20092 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20093 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20094 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20096 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
20098 if (keyfile_inline_pos
== NULL
)
20099 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
20102 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
20103 keyfile_inline_pos
++;
20104 is_keyfile_present
= 1;
20106 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20109 if (is_keyfile_present
!= 0)
20111 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20115 keyfile_len
= atoi (keyfile_len_pos
);
20117 keepass
->keyfile_len
= keyfile_len
;
20119 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20121 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20123 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20127 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20129 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20131 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20132 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20133 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20134 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20135 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20136 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20137 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20138 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20141 digest
[0] = keepass
->enc_iv
[0];
20142 digest
[1] = keepass
->enc_iv
[1];
20143 digest
[2] = keepass
->enc_iv
[2];
20144 digest
[3] = keepass
->enc_iv
[3];
20146 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20147 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20148 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20149 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20150 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20151 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20152 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20153 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20155 return (PARSER_OK
);
20158 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20160 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20162 u32
*digest
= (u32
*) hash_buf
->digest
;
20164 salt_t
*salt
= hash_buf
->salt
;
20166 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20167 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20168 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20169 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20170 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20171 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20172 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20173 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20175 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20177 uint salt_len
= input_len
- 64 - 1;
20179 char *salt_buf
= input_buf
+ 64 + 1;
20181 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20183 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20185 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20187 salt
->salt_len
= salt_len
;
20190 * we can precompute the first sha256 transform
20193 uint w
[16] = { 0 };
20195 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20196 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20197 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20198 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20199 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20200 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20201 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20202 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20203 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20204 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20205 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20206 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20207 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20208 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20209 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20210 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20212 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20214 sha256_64 (w
, pc256
);
20216 salt
->salt_buf_pc
[0] = pc256
[0];
20217 salt
->salt_buf_pc
[1] = pc256
[1];
20218 salt
->salt_buf_pc
[2] = pc256
[2];
20219 salt
->salt_buf_pc
[3] = pc256
[3];
20220 salt
->salt_buf_pc
[4] = pc256
[4];
20221 salt
->salt_buf_pc
[5] = pc256
[5];
20222 salt
->salt_buf_pc
[6] = pc256
[6];
20223 salt
->salt_buf_pc
[7] = pc256
[7];
20225 digest
[0] -= pc256
[0];
20226 digest
[1] -= pc256
[1];
20227 digest
[2] -= pc256
[2];
20228 digest
[3] -= pc256
[3];
20229 digest
[4] -= pc256
[4];
20230 digest
[5] -= pc256
[5];
20231 digest
[6] -= pc256
[6];
20232 digest
[7] -= pc256
[7];
20234 return (PARSER_OK
);
20237 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20239 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20241 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20243 u32
*digest
= (u32
*) hash_buf
->digest
;
20245 salt_t
*salt
= hash_buf
->salt
;
20251 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20253 char *data_buf_pos
= strchr (data_len_pos
, '$');
20255 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20257 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20259 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20260 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20264 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20266 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20268 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20270 u32 data_len
= atoi (data_len_pos
);
20272 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20278 char *salt_pos
= data_buf_pos
;
20280 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20281 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20282 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20283 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20285 // this is actually the CT, which is also the hash later (if matched)
20287 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20288 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20289 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20290 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20292 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20294 salt
->salt_iter
= 10 - 1;
20300 digest
[0] = salt
->salt_buf
[4];
20301 digest
[1] = salt
->salt_buf
[5];
20302 digest
[2] = salt
->salt_buf
[6];
20303 digest
[3] = salt
->salt_buf
[7];
20305 return (PARSER_OK
);
20308 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20310 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20312 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20314 u32
*digest
= (u32
*) hash_buf
->digest
;
20316 salt_t
*salt
= hash_buf
->salt
;
20322 char *salt_pos
= input_buf
+ 11 + 1;
20324 char *iter_pos
= strchr (salt_pos
, ',');
20326 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20328 u32 salt_len
= iter_pos
- salt_pos
;
20330 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20334 char *hash_pos
= strchr (iter_pos
, ',');
20336 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20338 u32 iter_len
= hash_pos
- iter_pos
;
20340 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20344 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20346 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20352 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20353 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20354 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20355 salt
->salt_buf
[3] = 0x00018000;
20357 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20358 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20359 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20360 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20362 salt
->salt_len
= salt_len
/ 2;
20364 salt
->salt_iter
= atoi (iter_pos
) - 1;
20370 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20371 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20372 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20373 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20374 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20375 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20376 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20377 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20379 return (PARSER_OK
);
20382 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20384 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20386 u32
*digest
= (u32
*) hash_buf
->digest
;
20388 salt_t
*salt
= hash_buf
->salt
;
20394 char *hash_pos
= input_buf
+ 64;
20395 char *salt1_pos
= input_buf
+ 128;
20396 char *salt2_pos
= input_buf
;
20402 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20403 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20404 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20405 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20407 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20408 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20409 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20410 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20412 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20413 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20414 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20415 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20417 salt
->salt_len
= 48;
20419 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20425 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20426 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20427 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20428 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20429 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20430 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20431 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20432 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20434 return (PARSER_OK
);
20437 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20439 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20441 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20442 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20444 u32
*digest
= (u32
*) hash_buf
->digest
;
20446 salt_t
*salt
= hash_buf
->salt
;
20448 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20454 char *param0_pos
= input_buf
+ 6 + 1;
20456 char *param1_pos
= strchr (param0_pos
, '*');
20458 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20460 u32 param0_len
= param1_pos
- param0_pos
;
20464 char *param2_pos
= strchr (param1_pos
, '*');
20466 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20468 u32 param1_len
= param2_pos
- param1_pos
;
20472 char *param3_pos
= strchr (param2_pos
, '*');
20474 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20476 u32 param2_len
= param3_pos
- param2_pos
;
20480 char *param4_pos
= strchr (param3_pos
, '*');
20482 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20484 u32 param3_len
= param4_pos
- param3_pos
;
20488 char *param5_pos
= strchr (param4_pos
, '*');
20490 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20492 u32 param4_len
= param5_pos
- param4_pos
;
20496 char *param6_pos
= strchr (param5_pos
, '*');
20498 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20500 u32 param5_len
= param6_pos
- param5_pos
;
20504 char *param7_pos
= strchr (param6_pos
, '*');
20506 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20508 u32 param6_len
= param7_pos
- param6_pos
;
20512 char *param8_pos
= strchr (param7_pos
, '*');
20514 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20516 u32 param7_len
= param8_pos
- param7_pos
;
20520 const uint type
= atoi (param0_pos
);
20521 const uint mode
= atoi (param1_pos
);
20522 const uint magic
= atoi (param2_pos
);
20524 char *salt_buf
= param3_pos
;
20526 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20528 const uint compress_length
= atoi (param5_pos
);
20530 char *data_buf
= param6_pos
;
20531 char *auth
= param7_pos
;
20537 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20539 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20541 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20543 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20545 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20547 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20549 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20551 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20553 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20555 if (type
!= 0) return (PARSER_SALT_VALUE
);
20557 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20559 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20561 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20569 zip2
->magic
= magic
;
20573 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20574 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20575 zip2
->salt_buf
[2] = 0;
20576 zip2
->salt_buf
[3] = 0;
20578 zip2
->salt_len
= 8;
20580 else if (mode
== 2)
20582 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20583 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20584 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20585 zip2
->salt_buf
[3] = 0;
20587 zip2
->salt_len
= 12;
20589 else if (mode
== 3)
20591 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20592 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20593 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20594 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20596 zip2
->salt_len
= 16;
20599 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20600 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20601 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20602 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20604 zip2
->verify_bytes
= verify_bytes
;
20606 zip2
->compress_length
= compress_length
;
20608 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20610 for (uint i
= 0; i
< param6_len
; i
+= 2)
20612 const char p0
= data_buf
[i
+ 0];
20613 const char p1
= data_buf
[i
+ 1];
20615 *data_buf_ptr
++ = hex_convert (p1
) << 0
20616 | hex_convert (p0
) << 4;
20621 *data_buf_ptr
= 0x80;
20623 char *auth_ptr
= (char *) zip2
->auth_buf
;
20625 for (uint i
= 0; i
< param7_len
; i
+= 2)
20627 const char p0
= auth
[i
+ 0];
20628 const char p1
= auth
[i
+ 1];
20630 *auth_ptr
++ = hex_convert (p1
) << 0
20631 | hex_convert (p0
) << 4;
20640 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20641 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20642 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20643 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20644 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20645 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20646 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20647 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20649 salt
->salt_len
= 32;
20651 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20654 * digest buf (fake)
20657 digest
[0] = zip2
->auth_buf
[0];
20658 digest
[1] = zip2
->auth_buf
[1];
20659 digest
[2] = zip2
->auth_buf
[2];
20660 digest
[3] = zip2
->auth_buf
[3];
20662 return (PARSER_OK
);
20665 int win8phone_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20667 if ((input_len
< DISPLAY_LEN_MIN_13800
) || (input_len
> DISPLAY_LEN_MAX_13800
)) return (PARSER_GLOBAL_LENGTH
);
20669 u32
*digest
= (u32
*) hash_buf
->digest
;
20671 salt_t
*salt
= hash_buf
->salt
;
20673 win8phone_t
*esalt
= hash_buf
->esalt
;
20675 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20676 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20677 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20678 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20679 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20680 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20681 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20682 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20684 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20686 char *salt_buf_ptr
= input_buf
+ 64 + 1;
20688 u32
*salt_buf
= esalt
->salt_buf
;
20690 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
20692 salt_buf
[i
] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[j
]);
20695 salt
->salt_buf
[0] = salt_buf
[0];
20696 salt
->salt_buf
[1] = salt_buf
[1];
20697 salt
->salt_buf
[2] = salt_buf
[2];
20698 salt
->salt_buf
[3] = salt_buf
[3];
20699 salt
->salt_buf
[4] = salt_buf
[4];
20700 salt
->salt_buf
[5] = salt_buf
[5];
20701 salt
->salt_buf
[6] = salt_buf
[6];
20702 salt
->salt_buf
[7] = salt_buf
[7];
20704 salt
->salt_len
= 64;
20706 return (PARSER_OK
);
20710 * parallel running threads
20715 BOOL WINAPI
sigHandler_default (DWORD sig
)
20719 case CTRL_CLOSE_EVENT
:
20722 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20723 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20724 * function otherwise it is too late (e.g. after returning from this function)
20729 SetConsoleCtrlHandler (NULL
, TRUE
);
20736 case CTRL_LOGOFF_EVENT
:
20737 case CTRL_SHUTDOWN_EVENT
:
20741 SetConsoleCtrlHandler (NULL
, TRUE
);
20749 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20753 case CTRL_CLOSE_EVENT
:
20757 SetConsoleCtrlHandler (NULL
, TRUE
);
20764 case CTRL_LOGOFF_EVENT
:
20765 case CTRL_SHUTDOWN_EVENT
:
20769 SetConsoleCtrlHandler (NULL
, TRUE
);
20777 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20779 if (callback
== NULL
)
20781 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20785 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20791 void sigHandler_default (int sig
)
20795 signal (sig
, NULL
);
20798 void sigHandler_benchmark (int sig
)
20802 signal (sig
, NULL
);
20805 void hc_signal (void (callback
) (int))
20807 if (callback
== NULL
) callback
= SIG_DFL
;
20809 signal (SIGINT
, callback
);
20810 signal (SIGTERM
, callback
);
20811 signal (SIGABRT
, callback
);
20816 void status_display ();
20818 void *thread_keypress (void *p
)
20820 uint quiet
= data
.quiet
;
20824 while (data
.shutdown_outer
== 0)
20826 int ch
= tty_getchar();
20828 if (ch
== -1) break;
20830 if (ch
== 0) continue;
20832 //https://github.com/hashcat/hashcat/issues/302
20837 hc_thread_mutex_lock (mux_display
);
20853 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20854 if (quiet
== 0) fflush (stdout
);
20866 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20867 if (quiet
== 0) fflush (stdout
);
20879 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20880 if (quiet
== 0) fflush (stdout
);
20892 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20893 if (quiet
== 0) fflush (stdout
);
20901 stop_at_checkpoint ();
20905 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20906 if (quiet
== 0) fflush (stdout
);
20919 //https://github.com/hashcat/hashcat/issues/302
20924 hc_thread_mutex_unlock (mux_display
);
20936 bool class_num (const u8 c
)
20938 return ((c
>= '0') && (c
<= '9'));
20941 bool class_lower (const u8 c
)
20943 return ((c
>= 'a') && (c
<= 'z'));
20946 bool class_upper (const u8 c
)
20948 return ((c
>= 'A') && (c
<= 'Z'));
20951 bool class_alpha (const u8 c
)
20953 return (class_lower (c
) || class_upper (c
));
20956 int conv_ctoi (const u8 c
)
20962 else if (class_upper (c
))
20964 return c
- 'A' + 10;
20970 int conv_itoc (const u8 c
)
20978 return c
+ 'A' - 10;
20988 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20989 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20990 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20991 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20992 #define MAX_KERNEL_RULES 255
20993 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20994 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20995 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20997 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20998 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20999 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
21000 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
21002 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
21007 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21009 switch (rule_buf
[rule_pos
])
21015 case RULE_OP_MANGLE_NOOP
:
21016 SET_NAME (rule
, rule_buf
[rule_pos
]);
21019 case RULE_OP_MANGLE_LREST
:
21020 SET_NAME (rule
, rule_buf
[rule_pos
]);
21023 case RULE_OP_MANGLE_UREST
:
21024 SET_NAME (rule
, rule_buf
[rule_pos
]);
21027 case RULE_OP_MANGLE_LREST_UFIRST
:
21028 SET_NAME (rule
, rule_buf
[rule_pos
]);
21031 case RULE_OP_MANGLE_UREST_LFIRST
:
21032 SET_NAME (rule
, rule_buf
[rule_pos
]);
21035 case RULE_OP_MANGLE_TREST
:
21036 SET_NAME (rule
, rule_buf
[rule_pos
]);
21039 case RULE_OP_MANGLE_TOGGLE_AT
:
21040 SET_NAME (rule
, rule_buf
[rule_pos
]);
21041 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21044 case RULE_OP_MANGLE_REVERSE
:
21045 SET_NAME (rule
, rule_buf
[rule_pos
]);
21048 case RULE_OP_MANGLE_DUPEWORD
:
21049 SET_NAME (rule
, rule_buf
[rule_pos
]);
21052 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21053 SET_NAME (rule
, rule_buf
[rule_pos
]);
21054 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21057 case RULE_OP_MANGLE_REFLECT
:
21058 SET_NAME (rule
, rule_buf
[rule_pos
]);
21061 case RULE_OP_MANGLE_ROTATE_LEFT
:
21062 SET_NAME (rule
, rule_buf
[rule_pos
]);
21065 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21066 SET_NAME (rule
, rule_buf
[rule_pos
]);
21069 case RULE_OP_MANGLE_APPEND
:
21070 SET_NAME (rule
, rule_buf
[rule_pos
]);
21071 SET_P0 (rule
, rule_buf
[rule_pos
]);
21074 case RULE_OP_MANGLE_PREPEND
:
21075 SET_NAME (rule
, rule_buf
[rule_pos
]);
21076 SET_P0 (rule
, rule_buf
[rule_pos
]);
21079 case RULE_OP_MANGLE_DELETE_FIRST
:
21080 SET_NAME (rule
, rule_buf
[rule_pos
]);
21083 case RULE_OP_MANGLE_DELETE_LAST
:
21084 SET_NAME (rule
, rule_buf
[rule_pos
]);
21087 case RULE_OP_MANGLE_DELETE_AT
:
21088 SET_NAME (rule
, rule_buf
[rule_pos
]);
21089 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21092 case RULE_OP_MANGLE_EXTRACT
:
21093 SET_NAME (rule
, rule_buf
[rule_pos
]);
21094 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21095 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21098 case RULE_OP_MANGLE_OMIT
:
21099 SET_NAME (rule
, rule_buf
[rule_pos
]);
21100 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21101 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21104 case RULE_OP_MANGLE_INSERT
:
21105 SET_NAME (rule
, rule_buf
[rule_pos
]);
21106 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21107 SET_P1 (rule
, rule_buf
[rule_pos
]);
21110 case RULE_OP_MANGLE_OVERSTRIKE
:
21111 SET_NAME (rule
, rule_buf
[rule_pos
]);
21112 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21113 SET_P1 (rule
, rule_buf
[rule_pos
]);
21116 case RULE_OP_MANGLE_TRUNCATE_AT
:
21117 SET_NAME (rule
, rule_buf
[rule_pos
]);
21118 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21121 case RULE_OP_MANGLE_REPLACE
:
21122 SET_NAME (rule
, rule_buf
[rule_pos
]);
21123 SET_P0 (rule
, rule_buf
[rule_pos
]);
21124 SET_P1 (rule
, rule_buf
[rule_pos
]);
21127 case RULE_OP_MANGLE_PURGECHAR
:
21131 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21135 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21136 SET_NAME (rule
, rule_buf
[rule_pos
]);
21137 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21140 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21141 SET_NAME (rule
, rule_buf
[rule_pos
]);
21142 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21145 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21146 SET_NAME (rule
, rule_buf
[rule_pos
]);
21149 case RULE_OP_MANGLE_SWITCH_FIRST
:
21150 SET_NAME (rule
, rule_buf
[rule_pos
]);
21153 case RULE_OP_MANGLE_SWITCH_LAST
:
21154 SET_NAME (rule
, rule_buf
[rule_pos
]);
21157 case RULE_OP_MANGLE_SWITCH_AT
:
21158 SET_NAME (rule
, rule_buf
[rule_pos
]);
21159 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21160 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21163 case RULE_OP_MANGLE_CHR_SHIFTL
:
21164 SET_NAME (rule
, rule_buf
[rule_pos
]);
21165 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21168 case RULE_OP_MANGLE_CHR_SHIFTR
:
21169 SET_NAME (rule
, rule_buf
[rule_pos
]);
21170 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21173 case RULE_OP_MANGLE_CHR_INCR
:
21174 SET_NAME (rule
, rule_buf
[rule_pos
]);
21175 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21178 case RULE_OP_MANGLE_CHR_DECR
:
21179 SET_NAME (rule
, rule_buf
[rule_pos
]);
21180 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21183 case RULE_OP_MANGLE_REPLACE_NP1
:
21184 SET_NAME (rule
, rule_buf
[rule_pos
]);
21185 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21188 case RULE_OP_MANGLE_REPLACE_NM1
:
21189 SET_NAME (rule
, rule_buf
[rule_pos
]);
21190 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21193 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21194 SET_NAME (rule
, rule_buf
[rule_pos
]);
21195 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21198 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21199 SET_NAME (rule
, rule_buf
[rule_pos
]);
21200 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21203 case RULE_OP_MANGLE_TITLE
:
21204 SET_NAME (rule
, rule_buf
[rule_pos
]);
21213 if (rule_pos
< rule_len
) return (-1);
21218 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21222 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21226 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21230 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21234 case RULE_OP_MANGLE_NOOP
:
21235 rule_buf
[rule_pos
] = rule_cmd
;
21238 case RULE_OP_MANGLE_LREST
:
21239 rule_buf
[rule_pos
] = rule_cmd
;
21242 case RULE_OP_MANGLE_UREST
:
21243 rule_buf
[rule_pos
] = rule_cmd
;
21246 case RULE_OP_MANGLE_LREST_UFIRST
:
21247 rule_buf
[rule_pos
] = rule_cmd
;
21250 case RULE_OP_MANGLE_UREST_LFIRST
:
21251 rule_buf
[rule_pos
] = rule_cmd
;
21254 case RULE_OP_MANGLE_TREST
:
21255 rule_buf
[rule_pos
] = rule_cmd
;
21258 case RULE_OP_MANGLE_TOGGLE_AT
:
21259 rule_buf
[rule_pos
] = rule_cmd
;
21260 GET_P0_CONV (rule
);
21263 case RULE_OP_MANGLE_REVERSE
:
21264 rule_buf
[rule_pos
] = rule_cmd
;
21267 case RULE_OP_MANGLE_DUPEWORD
:
21268 rule_buf
[rule_pos
] = rule_cmd
;
21271 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21272 rule_buf
[rule_pos
] = rule_cmd
;
21273 GET_P0_CONV (rule
);
21276 case RULE_OP_MANGLE_REFLECT
:
21277 rule_buf
[rule_pos
] = rule_cmd
;
21280 case RULE_OP_MANGLE_ROTATE_LEFT
:
21281 rule_buf
[rule_pos
] = rule_cmd
;
21284 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21285 rule_buf
[rule_pos
] = rule_cmd
;
21288 case RULE_OP_MANGLE_APPEND
:
21289 rule_buf
[rule_pos
] = rule_cmd
;
21293 case RULE_OP_MANGLE_PREPEND
:
21294 rule_buf
[rule_pos
] = rule_cmd
;
21298 case RULE_OP_MANGLE_DELETE_FIRST
:
21299 rule_buf
[rule_pos
] = rule_cmd
;
21302 case RULE_OP_MANGLE_DELETE_LAST
:
21303 rule_buf
[rule_pos
] = rule_cmd
;
21306 case RULE_OP_MANGLE_DELETE_AT
:
21307 rule_buf
[rule_pos
] = rule_cmd
;
21308 GET_P0_CONV (rule
);
21311 case RULE_OP_MANGLE_EXTRACT
:
21312 rule_buf
[rule_pos
] = rule_cmd
;
21313 GET_P0_CONV (rule
);
21314 GET_P1_CONV (rule
);
21317 case RULE_OP_MANGLE_OMIT
:
21318 rule_buf
[rule_pos
] = rule_cmd
;
21319 GET_P0_CONV (rule
);
21320 GET_P1_CONV (rule
);
21323 case RULE_OP_MANGLE_INSERT
:
21324 rule_buf
[rule_pos
] = rule_cmd
;
21325 GET_P0_CONV (rule
);
21329 case RULE_OP_MANGLE_OVERSTRIKE
:
21330 rule_buf
[rule_pos
] = rule_cmd
;
21331 GET_P0_CONV (rule
);
21335 case RULE_OP_MANGLE_TRUNCATE_AT
:
21336 rule_buf
[rule_pos
] = rule_cmd
;
21337 GET_P0_CONV (rule
);
21340 case RULE_OP_MANGLE_REPLACE
:
21341 rule_buf
[rule_pos
] = rule_cmd
;
21346 case RULE_OP_MANGLE_PURGECHAR
:
21350 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21354 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21355 rule_buf
[rule_pos
] = rule_cmd
;
21356 GET_P0_CONV (rule
);
21359 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21360 rule_buf
[rule_pos
] = rule_cmd
;
21361 GET_P0_CONV (rule
);
21364 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21365 rule_buf
[rule_pos
] = rule_cmd
;
21368 case RULE_OP_MANGLE_SWITCH_FIRST
:
21369 rule_buf
[rule_pos
] = rule_cmd
;
21372 case RULE_OP_MANGLE_SWITCH_LAST
:
21373 rule_buf
[rule_pos
] = rule_cmd
;
21376 case RULE_OP_MANGLE_SWITCH_AT
:
21377 rule_buf
[rule_pos
] = rule_cmd
;
21378 GET_P0_CONV (rule
);
21379 GET_P1_CONV (rule
);
21382 case RULE_OP_MANGLE_CHR_SHIFTL
:
21383 rule_buf
[rule_pos
] = rule_cmd
;
21384 GET_P0_CONV (rule
);
21387 case RULE_OP_MANGLE_CHR_SHIFTR
:
21388 rule_buf
[rule_pos
] = rule_cmd
;
21389 GET_P0_CONV (rule
);
21392 case RULE_OP_MANGLE_CHR_INCR
:
21393 rule_buf
[rule_pos
] = rule_cmd
;
21394 GET_P0_CONV (rule
);
21397 case RULE_OP_MANGLE_CHR_DECR
:
21398 rule_buf
[rule_pos
] = rule_cmd
;
21399 GET_P0_CONV (rule
);
21402 case RULE_OP_MANGLE_REPLACE_NP1
:
21403 rule_buf
[rule_pos
] = rule_cmd
;
21404 GET_P0_CONV (rule
);
21407 case RULE_OP_MANGLE_REPLACE_NM1
:
21408 rule_buf
[rule_pos
] = rule_cmd
;
21409 GET_P0_CONV (rule
);
21412 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21413 rule_buf
[rule_pos
] = rule_cmd
;
21414 GET_P0_CONV (rule
);
21417 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21418 rule_buf
[rule_pos
] = rule_cmd
;
21419 GET_P0_CONV (rule
);
21422 case RULE_OP_MANGLE_TITLE
:
21423 rule_buf
[rule_pos
] = rule_cmd
;
21427 return rule_pos
- 1;
21445 * CPU rules : this is from hashcat sources, cpu based rules
21448 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21449 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21451 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21452 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21453 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21455 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21456 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21457 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21459 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21463 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21468 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21472 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21477 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21481 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21486 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21491 for (l
= 0; l
< arr_len
; l
++)
21493 r
= arr_len
- 1 - l
;
21497 MANGLE_SWITCH (arr
, l
, r
);
21503 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21505 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21507 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21509 return (arr_len
* 2);
21512 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21514 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21516 int orig_len
= arr_len
;
21520 for (i
= 0; i
< times
; i
++)
21522 memcpy (&arr
[arr_len
], arr
, orig_len
);
21524 arr_len
+= orig_len
;
21530 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21532 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21534 mangle_double (arr
, arr_len
);
21536 mangle_reverse (arr
+ arr_len
, arr_len
);
21538 return (arr_len
* 2);
21541 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21546 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21548 MANGLE_SWITCH (arr
, l
, r
);
21554 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21559 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21561 MANGLE_SWITCH (arr
, l
, r
);
21567 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21569 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21573 return (arr_len
+ 1);
21576 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21578 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21582 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21584 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21589 return (arr_len
+ 1);
21592 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21594 if (upos
>= arr_len
) return (arr_len
);
21598 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21600 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21603 return (arr_len
- 1);
21606 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21608 if (upos
>= arr_len
) return (arr_len
);
21610 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21614 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21616 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21622 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21624 if (upos
>= arr_len
) return (arr_len
);
21626 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21630 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21632 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21635 return (arr_len
- ulen
);
21638 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21640 if (upos
>= arr_len
) return (arr_len
);
21642 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21646 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21648 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21653 return (arr_len
+ 1);
21656 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
)
21658 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21660 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21662 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21664 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21666 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21668 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21670 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21672 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21674 return (arr_len
+ arr2_cpy
);
21677 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21679 if (upos
>= arr_len
) return (arr_len
);
21686 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21688 if (upos
>= arr_len
) return (arr_len
);
21690 memset (arr
+ upos
, 0, arr_len
- upos
);
21695 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21699 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21701 if (arr
[arr_pos
] != oldc
) continue;
21703 arr
[arr_pos
] = newc
;
21709 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21715 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21717 if (arr
[arr_pos
] == c
) continue;
21719 arr
[ret_len
] = arr
[arr_pos
];
21727 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21729 if (ulen
> arr_len
) return (arr_len
);
21731 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21733 char cs
[100] = { 0 };
21735 memcpy (cs
, arr
, ulen
);
21739 for (i
= 0; i
< ulen
; i
++)
21743 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21749 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21751 if (ulen
> arr_len
) return (arr_len
);
21753 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21755 int upos
= arr_len
- ulen
;
21759 for (i
= 0; i
< ulen
; i
++)
21761 char c
= arr
[upos
+ i
];
21763 arr_len
= mangle_append (arr
, arr_len
, c
);
21769 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21771 if ( arr_len
== 0) return (arr_len
);
21772 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21774 char c
= arr
[upos
];
21778 for (i
= 0; i
< ulen
; i
++)
21780 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21786 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21788 if ( arr_len
== 0) return (arr_len
);
21789 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21793 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21795 int new_pos
= arr_pos
* 2;
21797 arr
[new_pos
] = arr
[arr_pos
];
21799 arr
[new_pos
+ 1] = arr
[arr_pos
];
21802 return (arr_len
* 2);
21805 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21807 if (upos
>= arr_len
) return (arr_len
);
21808 if (upos2
>= arr_len
) return (arr_len
);
21810 MANGLE_SWITCH (arr
, upos
, upos2
);
21815 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21817 MANGLE_SWITCH (arr
, upos
, upos2
);
21822 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21824 if (upos
>= arr_len
) return (arr_len
);
21831 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21833 if (upos
>= arr_len
) return (arr_len
);
21840 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21842 if (upos
>= arr_len
) return (arr_len
);
21849 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21851 if (upos
>= arr_len
) return (arr_len
);
21858 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21860 int upper_next
= 1;
21864 for (pos
= 0; pos
< arr_len
; pos
++)
21866 if (arr
[pos
] == ' ')
21877 MANGLE_UPPER_AT (arr
, pos
);
21881 MANGLE_LOWER_AT (arr
, pos
);
21888 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21890 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21896 for (j
= 0; j
< rp_gen_num
; j
++)
21903 switch ((char) get_random_num (0, 9))
21906 r
= get_random_num (0, sizeof (grp_op_nop
));
21907 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21911 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21912 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21913 p1
= get_random_num (0, sizeof (grp_pos
));
21914 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21918 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21919 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21920 p1
= get_random_num (1, 6);
21921 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21925 r
= get_random_num (0, sizeof (grp_op_chr
));
21926 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21927 p1
= get_random_num (0x20, 0x7e);
21928 rule_buf
[rule_pos
++] = (char) p1
;
21932 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21933 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21934 p1
= get_random_num (0x20, 0x7e);
21935 rule_buf
[rule_pos
++] = (char) p1
;
21936 p2
= get_random_num (0x20, 0x7e);
21938 p2
= get_random_num (0x20, 0x7e);
21939 rule_buf
[rule_pos
++] = (char) p2
;
21943 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21944 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21945 p1
= get_random_num (0, sizeof (grp_pos
));
21946 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21947 p2
= get_random_num (0x20, 0x7e);
21948 rule_buf
[rule_pos
++] = (char) p2
;
21952 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21953 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21954 p1
= get_random_num (0, sizeof (grp_pos
));
21955 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21956 p2
= get_random_num (0, sizeof (grp_pos
));
21958 p2
= get_random_num (0, sizeof (grp_pos
));
21959 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21963 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21964 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21965 p1
= get_random_num (0, sizeof (grp_pos
));
21966 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21967 p2
= get_random_num (1, sizeof (grp_pos
));
21969 p2
= get_random_num (1, sizeof (grp_pos
));
21970 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21974 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21975 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21976 p1
= get_random_num (0, sizeof (grp_pos
));
21977 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21978 p2
= get_random_num (1, sizeof (grp_pos
));
21979 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21980 p3
= get_random_num (0, sizeof (grp_pos
));
21981 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21989 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21991 char mem
[BLOCK_SIZE
] = { 0 };
21993 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21995 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21997 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21999 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
22001 int out_len
= in_len
;
22002 int mem_len
= in_len
;
22004 memcpy (out
, in
, out_len
);
22008 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
22013 switch (rule
[rule_pos
])
22018 case RULE_OP_MANGLE_NOOP
:
22021 case RULE_OP_MANGLE_LREST
:
22022 out_len
= mangle_lrest (out
, out_len
);
22025 case RULE_OP_MANGLE_UREST
:
22026 out_len
= mangle_urest (out
, out_len
);
22029 case RULE_OP_MANGLE_LREST_UFIRST
:
22030 out_len
= mangle_lrest (out
, out_len
);
22031 if (out_len
) MANGLE_UPPER_AT (out
, 0);
22034 case RULE_OP_MANGLE_UREST_LFIRST
:
22035 out_len
= mangle_urest (out
, out_len
);
22036 if (out_len
) MANGLE_LOWER_AT (out
, 0);
22039 case RULE_OP_MANGLE_TREST
:
22040 out_len
= mangle_trest (out
, out_len
);
22043 case RULE_OP_MANGLE_TOGGLE_AT
:
22044 NEXT_RULEPOS (rule_pos
);
22045 NEXT_RPTOI (rule
, rule_pos
, upos
);
22046 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
22049 case RULE_OP_MANGLE_REVERSE
:
22050 out_len
= mangle_reverse (out
, out_len
);
22053 case RULE_OP_MANGLE_DUPEWORD
:
22054 out_len
= mangle_double (out
, out_len
);
22057 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
22058 NEXT_RULEPOS (rule_pos
);
22059 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22060 out_len
= mangle_double_times (out
, out_len
, ulen
);
22063 case RULE_OP_MANGLE_REFLECT
:
22064 out_len
= mangle_reflect (out
, out_len
);
22067 case RULE_OP_MANGLE_ROTATE_LEFT
:
22068 mangle_rotate_left (out
, out_len
);
22071 case RULE_OP_MANGLE_ROTATE_RIGHT
:
22072 mangle_rotate_right (out
, out_len
);
22075 case RULE_OP_MANGLE_APPEND
:
22076 NEXT_RULEPOS (rule_pos
);
22077 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
22080 case RULE_OP_MANGLE_PREPEND
:
22081 NEXT_RULEPOS (rule_pos
);
22082 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
22085 case RULE_OP_MANGLE_DELETE_FIRST
:
22086 out_len
= mangle_delete_at (out
, out_len
, 0);
22089 case RULE_OP_MANGLE_DELETE_LAST
:
22090 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
22093 case RULE_OP_MANGLE_DELETE_AT
:
22094 NEXT_RULEPOS (rule_pos
);
22095 NEXT_RPTOI (rule
, rule_pos
, upos
);
22096 out_len
= mangle_delete_at (out
, out_len
, upos
);
22099 case RULE_OP_MANGLE_EXTRACT
:
22100 NEXT_RULEPOS (rule_pos
);
22101 NEXT_RPTOI (rule
, rule_pos
, upos
);
22102 NEXT_RULEPOS (rule_pos
);
22103 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22104 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
22107 case RULE_OP_MANGLE_OMIT
:
22108 NEXT_RULEPOS (rule_pos
);
22109 NEXT_RPTOI (rule
, rule_pos
, upos
);
22110 NEXT_RULEPOS (rule_pos
);
22111 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22112 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
22115 case RULE_OP_MANGLE_INSERT
:
22116 NEXT_RULEPOS (rule_pos
);
22117 NEXT_RPTOI (rule
, rule_pos
, upos
);
22118 NEXT_RULEPOS (rule_pos
);
22119 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22122 case RULE_OP_MANGLE_OVERSTRIKE
:
22123 NEXT_RULEPOS (rule_pos
);
22124 NEXT_RPTOI (rule
, rule_pos
, upos
);
22125 NEXT_RULEPOS (rule_pos
);
22126 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22129 case RULE_OP_MANGLE_TRUNCATE_AT
:
22130 NEXT_RULEPOS (rule_pos
);
22131 NEXT_RPTOI (rule
, rule_pos
, upos
);
22132 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22135 case RULE_OP_MANGLE_REPLACE
:
22136 NEXT_RULEPOS (rule_pos
);
22137 NEXT_RULEPOS (rule_pos
);
22138 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22141 case RULE_OP_MANGLE_PURGECHAR
:
22142 NEXT_RULEPOS (rule_pos
);
22143 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22146 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22150 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22151 NEXT_RULEPOS (rule_pos
);
22152 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22153 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22156 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22157 NEXT_RULEPOS (rule_pos
);
22158 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22159 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22162 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22163 out_len
= mangle_dupechar (out
, out_len
);
22166 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22167 NEXT_RULEPOS (rule_pos
);
22168 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22169 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22172 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22173 NEXT_RULEPOS (rule_pos
);
22174 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22175 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22178 case RULE_OP_MANGLE_SWITCH_FIRST
:
22179 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22182 case RULE_OP_MANGLE_SWITCH_LAST
:
22183 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22186 case RULE_OP_MANGLE_SWITCH_AT
:
22187 NEXT_RULEPOS (rule_pos
);
22188 NEXT_RPTOI (rule
, rule_pos
, upos
);
22189 NEXT_RULEPOS (rule_pos
);
22190 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22191 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22194 case RULE_OP_MANGLE_CHR_SHIFTL
:
22195 NEXT_RULEPOS (rule_pos
);
22196 NEXT_RPTOI (rule
, rule_pos
, upos
);
22197 mangle_chr_shiftl (out
, out_len
, upos
);
22200 case RULE_OP_MANGLE_CHR_SHIFTR
:
22201 NEXT_RULEPOS (rule_pos
);
22202 NEXT_RPTOI (rule
, rule_pos
, upos
);
22203 mangle_chr_shiftr (out
, out_len
, upos
);
22206 case RULE_OP_MANGLE_CHR_INCR
:
22207 NEXT_RULEPOS (rule_pos
);
22208 NEXT_RPTOI (rule
, rule_pos
, upos
);
22209 mangle_chr_incr (out
, out_len
, upos
);
22212 case RULE_OP_MANGLE_CHR_DECR
:
22213 NEXT_RULEPOS (rule_pos
);
22214 NEXT_RPTOI (rule
, rule_pos
, upos
);
22215 mangle_chr_decr (out
, out_len
, upos
);
22218 case RULE_OP_MANGLE_REPLACE_NP1
:
22219 NEXT_RULEPOS (rule_pos
);
22220 NEXT_RPTOI (rule
, rule_pos
, upos
);
22221 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22224 case RULE_OP_MANGLE_REPLACE_NM1
:
22225 NEXT_RULEPOS (rule_pos
);
22226 NEXT_RPTOI (rule
, rule_pos
, upos
);
22227 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22230 case RULE_OP_MANGLE_TITLE
:
22231 out_len
= mangle_title (out
, out_len
);
22234 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22235 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22236 NEXT_RULEPOS (rule_pos
);
22237 NEXT_RPTOI (rule
, rule_pos
, upos
);
22238 NEXT_RULEPOS (rule_pos
);
22239 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22240 NEXT_RULEPOS (rule_pos
);
22241 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22242 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22245 case RULE_OP_MANGLE_APPEND_MEMORY
:
22246 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22247 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22248 memcpy (out
+ out_len
, mem
, mem_len
);
22249 out_len
+= mem_len
;
22252 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22253 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22254 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22255 memcpy (mem
+ mem_len
, out
, out_len
);
22256 out_len
+= mem_len
;
22257 memcpy (out
, mem
, out_len
);
22260 case RULE_OP_MEMORIZE_WORD
:
22261 memcpy (mem
, out
, out_len
);
22265 case RULE_OP_REJECT_LESS
:
22266 NEXT_RULEPOS (rule_pos
);
22267 NEXT_RPTOI (rule
, rule_pos
, upos
);
22268 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22271 case RULE_OP_REJECT_GREATER
:
22272 NEXT_RULEPOS (rule_pos
);
22273 NEXT_RPTOI (rule
, rule_pos
, upos
);
22274 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22277 case RULE_OP_REJECT_CONTAIN
:
22278 NEXT_RULEPOS (rule_pos
);
22279 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22282 case RULE_OP_REJECT_NOT_CONTAIN
:
22283 NEXT_RULEPOS (rule_pos
);
22284 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22287 case RULE_OP_REJECT_EQUAL_FIRST
:
22288 NEXT_RULEPOS (rule_pos
);
22289 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22292 case RULE_OP_REJECT_EQUAL_LAST
:
22293 NEXT_RULEPOS (rule_pos
);
22294 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22297 case RULE_OP_REJECT_EQUAL_AT
:
22298 NEXT_RULEPOS (rule_pos
);
22299 NEXT_RPTOI (rule
, rule_pos
, upos
);
22300 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22301 NEXT_RULEPOS (rule_pos
);
22302 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22305 case RULE_OP_REJECT_CONTAINS
:
22306 NEXT_RULEPOS (rule_pos
);
22307 NEXT_RPTOI (rule
, rule_pos
, upos
);
22308 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22309 NEXT_RULEPOS (rule_pos
);
22310 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22311 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22314 case RULE_OP_REJECT_MEMORY
:
22315 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22319 return (RULE_RC_SYNTAX_ERROR
);
22324 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);