2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
20 u32
is_power_of_2(u32 v
)
22 return (v
&& !(v
& (v
- 1)));
25 u32
rotl32 (const u32 a
, const u32 n
)
27 return ((a
<< n
) | (a
>> (32 - n
)));
30 u32
rotr32 (const u32 a
, const u32 n
)
32 return ((a
>> n
) | (a
<< (32 - n
)));
35 u64
rotl64 (const u64 a
, const u64 n
)
37 return ((a
<< n
) | (a
>> (64 - n
)));
40 u64
rotr64 (const u64 a
, const u64 n
)
42 return ((a
>> n
) | (a
<< (64 - n
)));
45 u32
byte_swap_32 (const u32 n
)
47 return (n
& 0xff000000) >> 24
48 | (n
& 0x00ff0000) >> 8
49 | (n
& 0x0000ff00) << 8
50 | (n
& 0x000000ff) << 24;
53 u64
byte_swap_64 (const u64 n
)
55 return (n
& 0xff00000000000000ULL
) >> 56
56 | (n
& 0x00ff000000000000ULL
) >> 40
57 | (n
& 0x0000ff0000000000ULL
) >> 24
58 | (n
& 0x000000ff00000000ULL
) >> 8
59 | (n
& 0x00000000ff000000ULL
) << 8
60 | (n
& 0x0000000000ff0000ULL
) << 24
61 | (n
& 0x000000000000ff00ULL
) << 40
62 | (n
& 0x00000000000000ffULL
) << 56;
66 * ciphers for use on cpu
73 * hashes for use on cpu
78 #include "cpu-sha256.c"
86 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
92 for (int i
= 0; i
< last_len
; i
++)
100 char s
[4096] = { 0 };
102 int max_len
= (int) sizeof (s
);
104 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
106 if (len
> max_len
) len
= max_len
;
108 fwrite (s
, len
, 1, fp
);
115 void log_out_nn (FILE *fp
, const char *fmt
, ...)
117 if (SUPPRESS_OUTPUT
) return;
123 log_final (fp
, fmt
, ap
);
128 void log_info_nn (const char *fmt
, ...)
130 if (SUPPRESS_OUTPUT
) return;
136 log_final (stdout
, fmt
, ap
);
141 void log_error_nn (const char *fmt
, ...)
143 if (SUPPRESS_OUTPUT
) return;
149 log_final (stderr
, fmt
, ap
);
154 void log_out (FILE *fp
, const char *fmt
, ...)
156 if (SUPPRESS_OUTPUT
) return;
162 log_final (fp
, fmt
, ap
);
171 void log_info (const char *fmt
, ...)
173 if (SUPPRESS_OUTPUT
) return;
179 log_final (stdout
, fmt
, ap
);
183 fputc ('\n', stdout
);
188 void log_error (const char *fmt
, ...)
190 if (SUPPRESS_OUTPUT
) return;
192 fputc ('\n', stderr
);
193 fputc ('\n', stderr
);
199 log_final (stderr
, fmt
, ap
);
203 fputc ('\n', stderr
);
204 fputc ('\n', stderr
);
213 u8
int_to_base32 (const u8 c
)
215 static const u8 tbl
[0x20] =
217 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
218 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
224 u8
base32_to_int (const u8 c
)
226 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
227 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
232 u8
int_to_itoa32 (const u8 c
)
234 static const u8 tbl
[0x20] =
236 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
237 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
243 u8
itoa32_to_int (const u8 c
)
245 if ((c
>= '0') && (c
<= '9')) return c
- '0';
246 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
251 u8
int_to_itoa64 (const u8 c
)
253 static const u8 tbl
[0x40] =
255 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
256 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
257 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
258 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
264 u8
itoa64_to_int (const u8 c
)
266 static const u8 tbl
[0x100] =
268 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
269 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
270 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
271 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
272 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
273 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
274 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
275 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
276 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
277 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
278 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
279 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
280 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
281 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
282 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
283 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
289 u8
int_to_base64 (const u8 c
)
291 static const u8 tbl
[0x40] =
293 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
294 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
295 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
296 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
302 u8
base64_to_int (const u8 c
)
304 static const u8 tbl
[0x100] =
306 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
308 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
309 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
310 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
311 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
313 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
327 u8
int_to_bf64 (const u8 c
)
329 static const u8 tbl
[0x40] =
331 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
332 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
333 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
334 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
340 u8
bf64_to_int (const u8 c
)
342 static const u8 tbl
[0x100] =
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
346 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
347 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
348 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
349 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
350 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
351 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
365 u8
int_to_lotus64 (const u8 c
)
367 if (c
< 10) return '0' + c
;
368 else if (c
< 36) return 'A' + c
- 10;
369 else if (c
< 62) return 'a' + c
- 36;
370 else if (c
== 62) return '+';
371 else if (c
== 63) return '/';
376 u8
lotus64_to_int (const u8 c
)
378 if ((c
>= '0') && (c
<= '9')) return c
- '0';
379 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
380 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
381 else if (c
== '+') return 62;
382 else if (c
== '/') return 63;
388 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
390 const u8
*in_ptr
= in_buf
;
392 u8
*out_ptr
= out_buf
;
394 for (int i
= 0; i
< in_len
; i
+= 8)
396 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
397 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
398 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
399 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
400 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
401 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
402 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
403 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
405 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
406 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
407 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
408 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
409 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
415 for (int i
= 0; i
< in_len
; i
++)
417 if (in_buf
[i
] != '=') continue;
422 int out_len
= (in_len
* 5) / 8;
427 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
429 const u8
*in_ptr
= in_buf
;
431 u8
*out_ptr
= out_buf
;
433 for (int i
= 0; i
< in_len
; i
+= 5)
435 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
436 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
437 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
438 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
439 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
440 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
441 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
442 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
444 out_ptr
[0] = out_val0
& 0x7f;
445 out_ptr
[1] = out_val1
& 0x7f;
446 out_ptr
[2] = out_val2
& 0x7f;
447 out_ptr
[3] = out_val3
& 0x7f;
448 out_ptr
[4] = out_val4
& 0x7f;
449 out_ptr
[5] = out_val5
& 0x7f;
450 out_ptr
[6] = out_val6
& 0x7f;
451 out_ptr
[7] = out_val7
& 0x7f;
457 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
461 out_buf
[out_len
] = '=';
469 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
471 const u8
*in_ptr
= in_buf
;
473 u8
*out_ptr
= out_buf
;
475 for (int i
= 0; i
< in_len
; i
+= 4)
477 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
478 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
479 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
480 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
482 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
483 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
484 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
490 for (int i
= 0; i
< in_len
; i
++)
492 if (in_buf
[i
] != '=') continue;
497 int out_len
= (in_len
* 6) / 8;
502 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
504 const u8
*in_ptr
= in_buf
;
506 u8
*out_ptr
= out_buf
;
508 for (int i
= 0; i
< in_len
; i
+= 3)
510 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
511 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
512 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
513 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
515 out_ptr
[0] = out_val0
& 0x7f;
516 out_ptr
[1] = out_val1
& 0x7f;
517 out_ptr
[2] = out_val2
& 0x7f;
518 out_ptr
[3] = out_val3
& 0x7f;
524 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
528 out_buf
[out_len
] = '=';
536 int is_valid_hex_char (const u8 c
)
538 if ((c
>= '0') && (c
<= '9')) return 1;
539 if ((c
>= 'A') && (c
<= 'F')) return 1;
540 if ((c
>= 'a') && (c
<= 'f')) return 1;
545 u8
hex_convert (const u8 c
)
547 return (c
& 15) + (c
>> 6) * 9;
550 u8
hex_to_u8 (const u8 hex
[2])
554 v
|= (hex_convert (hex
[1]) << 0);
555 v
|= (hex_convert (hex
[0]) << 4);
560 u32
hex_to_u32 (const u8 hex
[8])
564 v
|= ((u32
) hex_convert (hex
[7])) << 0;
565 v
|= ((u32
) hex_convert (hex
[6])) << 4;
566 v
|= ((u32
) hex_convert (hex
[5])) << 8;
567 v
|= ((u32
) hex_convert (hex
[4])) << 12;
568 v
|= ((u32
) hex_convert (hex
[3])) << 16;
569 v
|= ((u32
) hex_convert (hex
[2])) << 20;
570 v
|= ((u32
) hex_convert (hex
[1])) << 24;
571 v
|= ((u32
) hex_convert (hex
[0])) << 28;
576 u64
hex_to_u64 (const u8 hex
[16])
580 v
|= ((u64
) hex_convert (hex
[15]) << 0);
581 v
|= ((u64
) hex_convert (hex
[14]) << 4);
582 v
|= ((u64
) hex_convert (hex
[13]) << 8);
583 v
|= ((u64
) hex_convert (hex
[12]) << 12);
584 v
|= ((u64
) hex_convert (hex
[11]) << 16);
585 v
|= ((u64
) hex_convert (hex
[10]) << 20);
586 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
587 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
588 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
589 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
590 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
591 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
592 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
593 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
594 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
595 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
600 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
602 hex
[0] = v
>> 28 & 15;
603 hex
[1] = v
>> 24 & 15;
604 hex
[2] = v
>> 20 & 15;
605 hex
[3] = v
>> 16 & 15;
606 hex
[4] = v
>> 12 & 15;
607 hex
[5] = v
>> 8 & 15;
608 hex
[6] = v
>> 4 & 15;
609 hex
[7] = v
>> 0 & 15;
613 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
614 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
615 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
616 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
617 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
618 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
619 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
620 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
627 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
631 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
640 for (int i
= 0; i
< 16; i
+= 4)
650 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
657 out
[i
+ 0] = _out
[0];
658 out
[i
+ 1] = _out
[1];
659 out
[i
+ 2] = _out
[2];
660 out
[i
+ 3] = _out
[3];
669 static void juniper_decrypt_hash (char *in
, char *out
)
673 u8 base64_buf
[100] = { 0 };
675 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
679 u32 juniper_iv
[4] = { 0 };
681 memcpy (juniper_iv
, base64_buf
, 12);
683 memcpy (out
, juniper_iv
, 12);
687 u32 juniper_key
[4] = { 0 };
689 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
690 juniper_key
[1] = byte_swap_32 (0x8df91059);
691 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
692 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
696 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
697 u32
*out_ptr
= (u32
*) (out
+ 12);
699 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
702 void phpass_decode (u8 digest
[16], u8 buf
[22])
706 l
= itoa64_to_int (buf
[ 0]) << 0;
707 l
|= itoa64_to_int (buf
[ 1]) << 6;
708 l
|= itoa64_to_int (buf
[ 2]) << 12;
709 l
|= itoa64_to_int (buf
[ 3]) << 18;
711 digest
[ 0] = (l
>> 0) & 0xff;
712 digest
[ 1] = (l
>> 8) & 0xff;
713 digest
[ 2] = (l
>> 16) & 0xff;
715 l
= itoa64_to_int (buf
[ 4]) << 0;
716 l
|= itoa64_to_int (buf
[ 5]) << 6;
717 l
|= itoa64_to_int (buf
[ 6]) << 12;
718 l
|= itoa64_to_int (buf
[ 7]) << 18;
720 digest
[ 3] = (l
>> 0) & 0xff;
721 digest
[ 4] = (l
>> 8) & 0xff;
722 digest
[ 5] = (l
>> 16) & 0xff;
724 l
= itoa64_to_int (buf
[ 8]) << 0;
725 l
|= itoa64_to_int (buf
[ 9]) << 6;
726 l
|= itoa64_to_int (buf
[10]) << 12;
727 l
|= itoa64_to_int (buf
[11]) << 18;
729 digest
[ 6] = (l
>> 0) & 0xff;
730 digest
[ 7] = (l
>> 8) & 0xff;
731 digest
[ 8] = (l
>> 16) & 0xff;
733 l
= itoa64_to_int (buf
[12]) << 0;
734 l
|= itoa64_to_int (buf
[13]) << 6;
735 l
|= itoa64_to_int (buf
[14]) << 12;
736 l
|= itoa64_to_int (buf
[15]) << 18;
738 digest
[ 9] = (l
>> 0) & 0xff;
739 digest
[10] = (l
>> 8) & 0xff;
740 digest
[11] = (l
>> 16) & 0xff;
742 l
= itoa64_to_int (buf
[16]) << 0;
743 l
|= itoa64_to_int (buf
[17]) << 6;
744 l
|= itoa64_to_int (buf
[18]) << 12;
745 l
|= itoa64_to_int (buf
[19]) << 18;
747 digest
[12] = (l
>> 0) & 0xff;
748 digest
[13] = (l
>> 8) & 0xff;
749 digest
[14] = (l
>> 16) & 0xff;
751 l
= itoa64_to_int (buf
[20]) << 0;
752 l
|= itoa64_to_int (buf
[21]) << 6;
754 digest
[15] = (l
>> 0) & 0xff;
757 void phpass_encode (u8 digest
[16], u8 buf
[22])
761 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
763 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
766 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
768 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
770 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
773 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
775 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
777 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[11] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
784 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[15] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
791 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[19] = int_to_itoa64 (l
& 0x3f);
796 l
= (digest
[15] << 0);
798 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[21] = int_to_itoa64 (l
& 0x3f);
802 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
806 l
= itoa64_to_int (buf
[ 0]) << 0;
807 l
|= itoa64_to_int (buf
[ 1]) << 6;
808 l
|= itoa64_to_int (buf
[ 2]) << 12;
809 l
|= itoa64_to_int (buf
[ 3]) << 18;
811 digest
[ 0] = (l
>> 16) & 0xff;
812 digest
[ 6] = (l
>> 8) & 0xff;
813 digest
[12] = (l
>> 0) & 0xff;
815 l
= itoa64_to_int (buf
[ 4]) << 0;
816 l
|= itoa64_to_int (buf
[ 5]) << 6;
817 l
|= itoa64_to_int (buf
[ 6]) << 12;
818 l
|= itoa64_to_int (buf
[ 7]) << 18;
820 digest
[ 1] = (l
>> 16) & 0xff;
821 digest
[ 7] = (l
>> 8) & 0xff;
822 digest
[13] = (l
>> 0) & 0xff;
824 l
= itoa64_to_int (buf
[ 8]) << 0;
825 l
|= itoa64_to_int (buf
[ 9]) << 6;
826 l
|= itoa64_to_int (buf
[10]) << 12;
827 l
|= itoa64_to_int (buf
[11]) << 18;
829 digest
[ 2] = (l
>> 16) & 0xff;
830 digest
[ 8] = (l
>> 8) & 0xff;
831 digest
[14] = (l
>> 0) & 0xff;
833 l
= itoa64_to_int (buf
[12]) << 0;
834 l
|= itoa64_to_int (buf
[13]) << 6;
835 l
|= itoa64_to_int (buf
[14]) << 12;
836 l
|= itoa64_to_int (buf
[15]) << 18;
838 digest
[ 3] = (l
>> 16) & 0xff;
839 digest
[ 9] = (l
>> 8) & 0xff;
840 digest
[15] = (l
>> 0) & 0xff;
842 l
= itoa64_to_int (buf
[16]) << 0;
843 l
|= itoa64_to_int (buf
[17]) << 6;
844 l
|= itoa64_to_int (buf
[18]) << 12;
845 l
|= itoa64_to_int (buf
[19]) << 18;
847 digest
[ 4] = (l
>> 16) & 0xff;
848 digest
[10] = (l
>> 8) & 0xff;
849 digest
[ 5] = (l
>> 0) & 0xff;
851 l
= itoa64_to_int (buf
[20]) << 0;
852 l
|= itoa64_to_int (buf
[21]) << 6;
854 digest
[11] = (l
>> 0) & 0xff;
857 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
861 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
863 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
866 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
870 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
873 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
877 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
884 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
891 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 l
= (digest
[11] << 0);
898 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
902 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
906 l
= itoa64_to_int (buf
[ 0]) << 0;
907 l
|= itoa64_to_int (buf
[ 1]) << 6;
908 l
|= itoa64_to_int (buf
[ 2]) << 12;
909 l
|= itoa64_to_int (buf
[ 3]) << 18;
911 digest
[ 0] = (l
>> 16) & 0xff;
912 digest
[21] = (l
>> 8) & 0xff;
913 digest
[42] = (l
>> 0) & 0xff;
915 l
= itoa64_to_int (buf
[ 4]) << 0;
916 l
|= itoa64_to_int (buf
[ 5]) << 6;
917 l
|= itoa64_to_int (buf
[ 6]) << 12;
918 l
|= itoa64_to_int (buf
[ 7]) << 18;
920 digest
[22] = (l
>> 16) & 0xff;
921 digest
[43] = (l
>> 8) & 0xff;
922 digest
[ 1] = (l
>> 0) & 0xff;
924 l
= itoa64_to_int (buf
[ 8]) << 0;
925 l
|= itoa64_to_int (buf
[ 9]) << 6;
926 l
|= itoa64_to_int (buf
[10]) << 12;
927 l
|= itoa64_to_int (buf
[11]) << 18;
929 digest
[44] = (l
>> 16) & 0xff;
930 digest
[ 2] = (l
>> 8) & 0xff;
931 digest
[23] = (l
>> 0) & 0xff;
933 l
= itoa64_to_int (buf
[12]) << 0;
934 l
|= itoa64_to_int (buf
[13]) << 6;
935 l
|= itoa64_to_int (buf
[14]) << 12;
936 l
|= itoa64_to_int (buf
[15]) << 18;
938 digest
[ 3] = (l
>> 16) & 0xff;
939 digest
[24] = (l
>> 8) & 0xff;
940 digest
[45] = (l
>> 0) & 0xff;
942 l
= itoa64_to_int (buf
[16]) << 0;
943 l
|= itoa64_to_int (buf
[17]) << 6;
944 l
|= itoa64_to_int (buf
[18]) << 12;
945 l
|= itoa64_to_int (buf
[19]) << 18;
947 digest
[25] = (l
>> 16) & 0xff;
948 digest
[46] = (l
>> 8) & 0xff;
949 digest
[ 4] = (l
>> 0) & 0xff;
951 l
= itoa64_to_int (buf
[20]) << 0;
952 l
|= itoa64_to_int (buf
[21]) << 6;
953 l
|= itoa64_to_int (buf
[22]) << 12;
954 l
|= itoa64_to_int (buf
[23]) << 18;
956 digest
[47] = (l
>> 16) & 0xff;
957 digest
[ 5] = (l
>> 8) & 0xff;
958 digest
[26] = (l
>> 0) & 0xff;
960 l
= itoa64_to_int (buf
[24]) << 0;
961 l
|= itoa64_to_int (buf
[25]) << 6;
962 l
|= itoa64_to_int (buf
[26]) << 12;
963 l
|= itoa64_to_int (buf
[27]) << 18;
965 digest
[ 6] = (l
>> 16) & 0xff;
966 digest
[27] = (l
>> 8) & 0xff;
967 digest
[48] = (l
>> 0) & 0xff;
969 l
= itoa64_to_int (buf
[28]) << 0;
970 l
|= itoa64_to_int (buf
[29]) << 6;
971 l
|= itoa64_to_int (buf
[30]) << 12;
972 l
|= itoa64_to_int (buf
[31]) << 18;
974 digest
[28] = (l
>> 16) & 0xff;
975 digest
[49] = (l
>> 8) & 0xff;
976 digest
[ 7] = (l
>> 0) & 0xff;
978 l
= itoa64_to_int (buf
[32]) << 0;
979 l
|= itoa64_to_int (buf
[33]) << 6;
980 l
|= itoa64_to_int (buf
[34]) << 12;
981 l
|= itoa64_to_int (buf
[35]) << 18;
983 digest
[50] = (l
>> 16) & 0xff;
984 digest
[ 8] = (l
>> 8) & 0xff;
985 digest
[29] = (l
>> 0) & 0xff;
987 l
= itoa64_to_int (buf
[36]) << 0;
988 l
|= itoa64_to_int (buf
[37]) << 6;
989 l
|= itoa64_to_int (buf
[38]) << 12;
990 l
|= itoa64_to_int (buf
[39]) << 18;
992 digest
[ 9] = (l
>> 16) & 0xff;
993 digest
[30] = (l
>> 8) & 0xff;
994 digest
[51] = (l
>> 0) & 0xff;
996 l
= itoa64_to_int (buf
[40]) << 0;
997 l
|= itoa64_to_int (buf
[41]) << 6;
998 l
|= itoa64_to_int (buf
[42]) << 12;
999 l
|= itoa64_to_int (buf
[43]) << 18;
1001 digest
[31] = (l
>> 16) & 0xff;
1002 digest
[52] = (l
>> 8) & 0xff;
1003 digest
[10] = (l
>> 0) & 0xff;
1005 l
= itoa64_to_int (buf
[44]) << 0;
1006 l
|= itoa64_to_int (buf
[45]) << 6;
1007 l
|= itoa64_to_int (buf
[46]) << 12;
1008 l
|= itoa64_to_int (buf
[47]) << 18;
1010 digest
[53] = (l
>> 16) & 0xff;
1011 digest
[11] = (l
>> 8) & 0xff;
1012 digest
[32] = (l
>> 0) & 0xff;
1014 l
= itoa64_to_int (buf
[48]) << 0;
1015 l
|= itoa64_to_int (buf
[49]) << 6;
1016 l
|= itoa64_to_int (buf
[50]) << 12;
1017 l
|= itoa64_to_int (buf
[51]) << 18;
1019 digest
[12] = (l
>> 16) & 0xff;
1020 digest
[33] = (l
>> 8) & 0xff;
1021 digest
[54] = (l
>> 0) & 0xff;
1023 l
= itoa64_to_int (buf
[52]) << 0;
1024 l
|= itoa64_to_int (buf
[53]) << 6;
1025 l
|= itoa64_to_int (buf
[54]) << 12;
1026 l
|= itoa64_to_int (buf
[55]) << 18;
1028 digest
[34] = (l
>> 16) & 0xff;
1029 digest
[55] = (l
>> 8) & 0xff;
1030 digest
[13] = (l
>> 0) & 0xff;
1032 l
= itoa64_to_int (buf
[56]) << 0;
1033 l
|= itoa64_to_int (buf
[57]) << 6;
1034 l
|= itoa64_to_int (buf
[58]) << 12;
1035 l
|= itoa64_to_int (buf
[59]) << 18;
1037 digest
[56] = (l
>> 16) & 0xff;
1038 digest
[14] = (l
>> 8) & 0xff;
1039 digest
[35] = (l
>> 0) & 0xff;
1041 l
= itoa64_to_int (buf
[60]) << 0;
1042 l
|= itoa64_to_int (buf
[61]) << 6;
1043 l
|= itoa64_to_int (buf
[62]) << 12;
1044 l
|= itoa64_to_int (buf
[63]) << 18;
1046 digest
[15] = (l
>> 16) & 0xff;
1047 digest
[36] = (l
>> 8) & 0xff;
1048 digest
[57] = (l
>> 0) & 0xff;
1050 l
= itoa64_to_int (buf
[64]) << 0;
1051 l
|= itoa64_to_int (buf
[65]) << 6;
1052 l
|= itoa64_to_int (buf
[66]) << 12;
1053 l
|= itoa64_to_int (buf
[67]) << 18;
1055 digest
[37] = (l
>> 16) & 0xff;
1056 digest
[58] = (l
>> 8) & 0xff;
1057 digest
[16] = (l
>> 0) & 0xff;
1059 l
= itoa64_to_int (buf
[68]) << 0;
1060 l
|= itoa64_to_int (buf
[69]) << 6;
1061 l
|= itoa64_to_int (buf
[70]) << 12;
1062 l
|= itoa64_to_int (buf
[71]) << 18;
1064 digest
[59] = (l
>> 16) & 0xff;
1065 digest
[17] = (l
>> 8) & 0xff;
1066 digest
[38] = (l
>> 0) & 0xff;
1068 l
= itoa64_to_int (buf
[72]) << 0;
1069 l
|= itoa64_to_int (buf
[73]) << 6;
1070 l
|= itoa64_to_int (buf
[74]) << 12;
1071 l
|= itoa64_to_int (buf
[75]) << 18;
1073 digest
[18] = (l
>> 16) & 0xff;
1074 digest
[39] = (l
>> 8) & 0xff;
1075 digest
[60] = (l
>> 0) & 0xff;
1077 l
= itoa64_to_int (buf
[76]) << 0;
1078 l
|= itoa64_to_int (buf
[77]) << 6;
1079 l
|= itoa64_to_int (buf
[78]) << 12;
1080 l
|= itoa64_to_int (buf
[79]) << 18;
1082 digest
[40] = (l
>> 16) & 0xff;
1083 digest
[61] = (l
>> 8) & 0xff;
1084 digest
[19] = (l
>> 0) & 0xff;
1086 l
= itoa64_to_int (buf
[80]) << 0;
1087 l
|= itoa64_to_int (buf
[81]) << 6;
1088 l
|= itoa64_to_int (buf
[82]) << 12;
1089 l
|= itoa64_to_int (buf
[83]) << 18;
1091 digest
[62] = (l
>> 16) & 0xff;
1092 digest
[20] = (l
>> 8) & 0xff;
1093 digest
[41] = (l
>> 0) & 0xff;
1095 l
= itoa64_to_int (buf
[84]) << 0;
1096 l
|= itoa64_to_int (buf
[85]) << 6;
1098 digest
[63] = (l
>> 0) & 0xff;
1101 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1105 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1107 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1110 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1114 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1117 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1121 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1128 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1135 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1142 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1149 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1156 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1163 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1170 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1177 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1184 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1191 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1198 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1205 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1212 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1219 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1226 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1233 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1240 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1247 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 l
= 0 | 0 | (digest
[63] << 0);
1254 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1258 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1262 l
= itoa64_to_int (buf
[ 0]) << 0;
1263 l
|= itoa64_to_int (buf
[ 1]) << 6;
1264 l
|= itoa64_to_int (buf
[ 2]) << 12;
1265 l
|= itoa64_to_int (buf
[ 3]) << 18;
1267 digest
[ 2] = (l
>> 0) & 0xff;
1268 digest
[ 1] = (l
>> 8) & 0xff;
1269 digest
[ 0] = (l
>> 16) & 0xff;
1271 l
= itoa64_to_int (buf
[ 4]) << 0;
1272 l
|= itoa64_to_int (buf
[ 5]) << 6;
1273 l
|= itoa64_to_int (buf
[ 6]) << 12;
1274 l
|= itoa64_to_int (buf
[ 7]) << 18;
1276 digest
[ 5] = (l
>> 0) & 0xff;
1277 digest
[ 4] = (l
>> 8) & 0xff;
1278 digest
[ 3] = (l
>> 16) & 0xff;
1280 l
= itoa64_to_int (buf
[ 8]) << 0;
1281 l
|= itoa64_to_int (buf
[ 9]) << 6;
1282 l
|= itoa64_to_int (buf
[10]) << 12;
1283 l
|= itoa64_to_int (buf
[11]) << 18;
1285 digest
[ 8] = (l
>> 0) & 0xff;
1286 digest
[ 7] = (l
>> 8) & 0xff;
1287 digest
[ 6] = (l
>> 16) & 0xff;
1289 l
= itoa64_to_int (buf
[12]) << 0;
1290 l
|= itoa64_to_int (buf
[13]) << 6;
1291 l
|= itoa64_to_int (buf
[14]) << 12;
1292 l
|= itoa64_to_int (buf
[15]) << 18;
1294 digest
[11] = (l
>> 0) & 0xff;
1295 digest
[10] = (l
>> 8) & 0xff;
1296 digest
[ 9] = (l
>> 16) & 0xff;
1298 l
= itoa64_to_int (buf
[16]) << 0;
1299 l
|= itoa64_to_int (buf
[17]) << 6;
1300 l
|= itoa64_to_int (buf
[18]) << 12;
1301 l
|= itoa64_to_int (buf
[19]) << 18;
1303 digest
[14] = (l
>> 0) & 0xff;
1304 digest
[13] = (l
>> 8) & 0xff;
1305 digest
[12] = (l
>> 16) & 0xff;
1307 l
= itoa64_to_int (buf
[20]) << 0;
1308 l
|= itoa64_to_int (buf
[21]) << 6;
1309 l
|= itoa64_to_int (buf
[22]) << 12;
1310 l
|= itoa64_to_int (buf
[23]) << 18;
1312 digest
[17] = (l
>> 0) & 0xff;
1313 digest
[16] = (l
>> 8) & 0xff;
1314 digest
[15] = (l
>> 16) & 0xff;
1316 l
= itoa64_to_int (buf
[24]) << 0;
1317 l
|= itoa64_to_int (buf
[25]) << 6;
1318 l
|= itoa64_to_int (buf
[26]) << 12;
1320 digest
[19] = (l
>> 8) & 0xff;
1321 digest
[18] = (l
>> 16) & 0xff;
1324 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1328 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1330 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1333 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1335 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1337 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1340 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1342 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1344 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[11] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1351 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[15] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1358 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[19] = int_to_itoa64 (l
& 0x3f);
1363 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1365 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[23] = int_to_itoa64 (l
& 0x3f);
1370 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1372 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1374 buf
[26] = int_to_itoa64 (l
& 0x3f);
1377 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1381 l
= itoa64_to_int (buf
[ 0]) << 0;
1382 l
|= itoa64_to_int (buf
[ 1]) << 6;
1383 l
|= itoa64_to_int (buf
[ 2]) << 12;
1384 l
|= itoa64_to_int (buf
[ 3]) << 18;
1386 digest
[ 2] = (l
>> 0) & 0xff;
1387 digest
[ 1] = (l
>> 8) & 0xff;
1388 digest
[ 0] = (l
>> 16) & 0xff;
1390 l
= itoa64_to_int (buf
[ 4]) << 0;
1391 l
|= itoa64_to_int (buf
[ 5]) << 6;
1392 l
|= itoa64_to_int (buf
[ 6]) << 12;
1393 l
|= itoa64_to_int (buf
[ 7]) << 18;
1395 digest
[ 5] = (l
>> 0) & 0xff;
1396 digest
[ 4] = (l
>> 8) & 0xff;
1397 digest
[ 3] = (l
>> 16) & 0xff;
1399 l
= itoa64_to_int (buf
[ 8]) << 0;
1400 l
|= itoa64_to_int (buf
[ 9]) << 6;
1401 l
|= itoa64_to_int (buf
[10]) << 12;
1402 l
|= itoa64_to_int (buf
[11]) << 18;
1404 digest
[ 8] = (l
>> 0) & 0xff;
1405 digest
[ 7] = (l
>> 8) & 0xff;
1406 digest
[ 6] = (l
>> 16) & 0xff;
1408 l
= itoa64_to_int (buf
[12]) << 0;
1409 l
|= itoa64_to_int (buf
[13]) << 6;
1410 l
|= itoa64_to_int (buf
[14]) << 12;
1411 l
|= itoa64_to_int (buf
[15]) << 18;
1413 digest
[11] = (l
>> 0) & 0xff;
1414 digest
[10] = (l
>> 8) & 0xff;
1415 digest
[ 9] = (l
>> 16) & 0xff;
1417 l
= itoa64_to_int (buf
[16]) << 0;
1418 l
|= itoa64_to_int (buf
[17]) << 6;
1419 l
|= itoa64_to_int (buf
[18]) << 12;
1420 l
|= itoa64_to_int (buf
[19]) << 18;
1422 digest
[14] = (l
>> 0) & 0xff;
1423 digest
[13] = (l
>> 8) & 0xff;
1424 digest
[12] = (l
>> 16) & 0xff;
1426 l
= itoa64_to_int (buf
[20]) << 0;
1427 l
|= itoa64_to_int (buf
[21]) << 6;
1428 l
|= itoa64_to_int (buf
[22]) << 12;
1429 l
|= itoa64_to_int (buf
[23]) << 18;
1431 digest
[17] = (l
>> 0) & 0xff;
1432 digest
[16] = (l
>> 8) & 0xff;
1433 digest
[15] = (l
>> 16) & 0xff;
1435 l
= itoa64_to_int (buf
[24]) << 0;
1436 l
|= itoa64_to_int (buf
[25]) << 6;
1437 l
|= itoa64_to_int (buf
[26]) << 12;
1438 l
|= itoa64_to_int (buf
[27]) << 18;
1440 digest
[20] = (l
>> 0) & 0xff;
1441 digest
[19] = (l
>> 8) & 0xff;
1442 digest
[18] = (l
>> 16) & 0xff;
1444 l
= itoa64_to_int (buf
[28]) << 0;
1445 l
|= itoa64_to_int (buf
[29]) << 6;
1446 l
|= itoa64_to_int (buf
[30]) << 12;
1447 l
|= itoa64_to_int (buf
[31]) << 18;
1449 digest
[23] = (l
>> 0) & 0xff;
1450 digest
[22] = (l
>> 8) & 0xff;
1451 digest
[21] = (l
>> 16) & 0xff;
1453 l
= itoa64_to_int (buf
[32]) << 0;
1454 l
|= itoa64_to_int (buf
[33]) << 6;
1455 l
|= itoa64_to_int (buf
[34]) << 12;
1456 l
|= itoa64_to_int (buf
[35]) << 18;
1458 digest
[26] = (l
>> 0) & 0xff;
1459 digest
[25] = (l
>> 8) & 0xff;
1460 digest
[24] = (l
>> 16) & 0xff;
1462 l
= itoa64_to_int (buf
[36]) << 0;
1463 l
|= itoa64_to_int (buf
[37]) << 6;
1464 l
|= itoa64_to_int (buf
[38]) << 12;
1465 l
|= itoa64_to_int (buf
[39]) << 18;
1467 digest
[29] = (l
>> 0) & 0xff;
1468 digest
[28] = (l
>> 8) & 0xff;
1469 digest
[27] = (l
>> 16) & 0xff;
1471 l
= itoa64_to_int (buf
[40]) << 0;
1472 l
|= itoa64_to_int (buf
[41]) << 6;
1473 l
|= itoa64_to_int (buf
[42]) << 12;
1475 //digest[32] = (l >> 0) & 0xff;
1476 digest
[31] = (l
>> 8) & 0xff;
1477 digest
[30] = (l
>> 16) & 0xff;
1480 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1484 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1486 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1489 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1491 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1493 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1496 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1498 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1500 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[11] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1507 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[15] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1514 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[19] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1521 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[23] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1528 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[27] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1535 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[31] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1542 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[35] = int_to_itoa64 (l
& 0x3f);
1547 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1549 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[39] = int_to_itoa64 (l
& 0x3f);
1554 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1556 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1558 buf
[42] = int_to_itoa64 (l
& 0x3f);
1561 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1565 l
= itoa64_to_int (buf
[ 0]) << 0;
1566 l
|= itoa64_to_int (buf
[ 1]) << 6;
1567 l
|= itoa64_to_int (buf
[ 2]) << 12;
1568 l
|= itoa64_to_int (buf
[ 3]) << 18;
1570 digest
[ 2] = (l
>> 0) & 0xff;
1571 digest
[ 1] = (l
>> 8) & 0xff;
1572 digest
[ 0] = (l
>> 16) & 0xff;
1574 l
= itoa64_to_int (buf
[ 4]) << 0;
1575 l
|= itoa64_to_int (buf
[ 5]) << 6;
1576 l
|= itoa64_to_int (buf
[ 6]) << 12;
1577 l
|= itoa64_to_int (buf
[ 7]) << 18;
1579 digest
[ 5] = (l
>> 0) & 0xff;
1580 digest
[ 4] = (l
>> 8) & 0xff;
1581 digest
[ 3] = (l
>> 16) & 0xff;
1583 l
= itoa64_to_int (buf
[ 8]) << 0;
1584 l
|= itoa64_to_int (buf
[ 9]) << 6;
1585 l
|= itoa64_to_int (buf
[10]) << 12;
1586 l
|= itoa64_to_int (buf
[11]) << 18;
1588 digest
[ 8] = (l
>> 0) & 0xff;
1589 digest
[ 7] = (l
>> 8) & 0xff;
1590 digest
[ 6] = (l
>> 16) & 0xff;
1592 l
= itoa64_to_int (buf
[12]) << 0;
1593 l
|= itoa64_to_int (buf
[13]) << 6;
1594 l
|= itoa64_to_int (buf
[14]) << 12;
1595 l
|= itoa64_to_int (buf
[15]) << 18;
1597 digest
[11] = (l
>> 0) & 0xff;
1598 digest
[10] = (l
>> 8) & 0xff;
1599 digest
[ 9] = (l
>> 16) & 0xff;
1601 l
= itoa64_to_int (buf
[16]) << 0;
1602 l
|= itoa64_to_int (buf
[17]) << 6;
1603 l
|= itoa64_to_int (buf
[18]) << 12;
1604 l
|= itoa64_to_int (buf
[19]) << 18;
1606 digest
[14] = (l
>> 0) & 0xff;
1607 digest
[13] = (l
>> 8) & 0xff;
1608 digest
[12] = (l
>> 16) & 0xff;
1610 l
= itoa64_to_int (buf
[20]) << 0;
1611 l
|= itoa64_to_int (buf
[21]) << 6;
1612 l
|= itoa64_to_int (buf
[22]) << 12;
1613 l
|= itoa64_to_int (buf
[23]) << 18;
1615 digest
[17] = (l
>> 0) & 0xff;
1616 digest
[16] = (l
>> 8) & 0xff;
1617 digest
[15] = (l
>> 16) & 0xff;
1619 l
= itoa64_to_int (buf
[24]) << 0;
1620 l
|= itoa64_to_int (buf
[25]) << 6;
1621 l
|= itoa64_to_int (buf
[26]) << 12;
1622 l
|= itoa64_to_int (buf
[27]) << 18;
1624 digest
[20] = (l
>> 0) & 0xff;
1625 digest
[19] = (l
>> 8) & 0xff;
1626 digest
[18] = (l
>> 16) & 0xff;
1628 l
= itoa64_to_int (buf
[28]) << 0;
1629 l
|= itoa64_to_int (buf
[29]) << 6;
1630 l
|= itoa64_to_int (buf
[30]) << 12;
1631 l
|= itoa64_to_int (buf
[31]) << 18;
1633 digest
[23] = (l
>> 0) & 0xff;
1634 digest
[22] = (l
>> 8) & 0xff;
1635 digest
[21] = (l
>> 16) & 0xff;
1637 l
= itoa64_to_int (buf
[32]) << 0;
1638 l
|= itoa64_to_int (buf
[33]) << 6;
1639 l
|= itoa64_to_int (buf
[34]) << 12;
1640 l
|= itoa64_to_int (buf
[35]) << 18;
1642 digest
[26] = (l
>> 0) & 0xff;
1643 digest
[25] = (l
>> 8) & 0xff;
1644 digest
[24] = (l
>> 16) & 0xff;
1646 l
= itoa64_to_int (buf
[36]) << 0;
1647 l
|= itoa64_to_int (buf
[37]) << 6;
1648 l
|= itoa64_to_int (buf
[38]) << 12;
1649 l
|= itoa64_to_int (buf
[39]) << 18;
1651 digest
[29] = (l
>> 0) & 0xff;
1652 digest
[28] = (l
>> 8) & 0xff;
1653 digest
[27] = (l
>> 16) & 0xff;
1655 l
= itoa64_to_int (buf
[40]) << 0;
1656 l
|= itoa64_to_int (buf
[41]) << 6;
1657 l
|= itoa64_to_int (buf
[42]) << 12;
1658 l
|= itoa64_to_int (buf
[43]) << 18;
1660 digest
[32] = (l
>> 0) & 0xff;
1661 digest
[31] = (l
>> 8) & 0xff;
1662 digest
[30] = (l
>> 16) & 0xff;
1664 l
= itoa64_to_int (buf
[44]) << 0;
1665 l
|= itoa64_to_int (buf
[45]) << 6;
1666 l
|= itoa64_to_int (buf
[46]) << 12;
1667 l
|= itoa64_to_int (buf
[47]) << 18;
1669 digest
[35] = (l
>> 0) & 0xff;
1670 digest
[34] = (l
>> 8) & 0xff;
1671 digest
[33] = (l
>> 16) & 0xff;
1673 l
= itoa64_to_int (buf
[48]) << 0;
1674 l
|= itoa64_to_int (buf
[49]) << 6;
1675 l
|= itoa64_to_int (buf
[50]) << 12;
1676 l
|= itoa64_to_int (buf
[51]) << 18;
1678 digest
[38] = (l
>> 0) & 0xff;
1679 digest
[37] = (l
>> 8) & 0xff;
1680 digest
[36] = (l
>> 16) & 0xff;
1682 l
= itoa64_to_int (buf
[52]) << 0;
1683 l
|= itoa64_to_int (buf
[53]) << 6;
1684 l
|= itoa64_to_int (buf
[54]) << 12;
1685 l
|= itoa64_to_int (buf
[55]) << 18;
1687 digest
[41] = (l
>> 0) & 0xff;
1688 digest
[40] = (l
>> 8) & 0xff;
1689 digest
[39] = (l
>> 16) & 0xff;
1691 l
= itoa64_to_int (buf
[56]) << 0;
1692 l
|= itoa64_to_int (buf
[57]) << 6;
1693 l
|= itoa64_to_int (buf
[58]) << 12;
1694 l
|= itoa64_to_int (buf
[59]) << 18;
1696 digest
[44] = (l
>> 0) & 0xff;
1697 digest
[43] = (l
>> 8) & 0xff;
1698 digest
[42] = (l
>> 16) & 0xff;
1700 l
= itoa64_to_int (buf
[60]) << 0;
1701 l
|= itoa64_to_int (buf
[61]) << 6;
1702 l
|= itoa64_to_int (buf
[62]) << 12;
1703 l
|= itoa64_to_int (buf
[63]) << 18;
1705 digest
[47] = (l
>> 0) & 0xff;
1706 digest
[46] = (l
>> 8) & 0xff;
1707 digest
[45] = (l
>> 16) & 0xff;
1709 l
= itoa64_to_int (buf
[64]) << 0;
1710 l
|= itoa64_to_int (buf
[65]) << 6;
1711 l
|= itoa64_to_int (buf
[66]) << 12;
1712 l
|= itoa64_to_int (buf
[67]) << 18;
1714 digest
[50] = (l
>> 0) & 0xff;
1715 digest
[49] = (l
>> 8) & 0xff;
1716 digest
[48] = (l
>> 16) & 0xff;
1718 l
= itoa64_to_int (buf
[68]) << 0;
1719 l
|= itoa64_to_int (buf
[69]) << 6;
1720 l
|= itoa64_to_int (buf
[70]) << 12;
1721 l
|= itoa64_to_int (buf
[71]) << 18;
1723 digest
[53] = (l
>> 0) & 0xff;
1724 digest
[52] = (l
>> 8) & 0xff;
1725 digest
[51] = (l
>> 16) & 0xff;
1727 l
= itoa64_to_int (buf
[72]) << 0;
1728 l
|= itoa64_to_int (buf
[73]) << 6;
1729 l
|= itoa64_to_int (buf
[74]) << 12;
1730 l
|= itoa64_to_int (buf
[75]) << 18;
1732 digest
[56] = (l
>> 0) & 0xff;
1733 digest
[55] = (l
>> 8) & 0xff;
1734 digest
[54] = (l
>> 16) & 0xff;
1736 l
= itoa64_to_int (buf
[76]) << 0;
1737 l
|= itoa64_to_int (buf
[77]) << 6;
1738 l
|= itoa64_to_int (buf
[78]) << 12;
1739 l
|= itoa64_to_int (buf
[79]) << 18;
1741 digest
[59] = (l
>> 0) & 0xff;
1742 digest
[58] = (l
>> 8) & 0xff;
1743 digest
[57] = (l
>> 16) & 0xff;
1745 l
= itoa64_to_int (buf
[80]) << 0;
1746 l
|= itoa64_to_int (buf
[81]) << 6;
1747 l
|= itoa64_to_int (buf
[82]) << 12;
1748 l
|= itoa64_to_int (buf
[83]) << 18;
1750 digest
[62] = (l
>> 0) & 0xff;
1751 digest
[61] = (l
>> 8) & 0xff;
1752 digest
[60] = (l
>> 16) & 0xff;
1754 l
= itoa64_to_int (buf
[84]) << 0;
1755 l
|= itoa64_to_int (buf
[85]) << 6;
1757 digest
[63] = (l
>> 16) & 0xff;
1760 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1764 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1766 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1769 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1771 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1773 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1776 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1778 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1780 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[11] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1787 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[15] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1794 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[19] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1801 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[23] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1808 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[27] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1815 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[31] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1822 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[35] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1829 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[39] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1836 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[43] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1843 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[47] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1850 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[51] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1857 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[55] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1864 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[59] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1871 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[63] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1878 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[67] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1885 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[71] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1892 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[75] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1899 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[79] = int_to_itoa64 (l
& 0x3f);
1904 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1906 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[83] = int_to_itoa64 (l
& 0x3f);
1911 l
= 0 | 0 | (digest
[63] << 16);
1913 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1917 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1921 l
= itoa64_to_int (buf
[ 0]) << 0;
1922 l
|= itoa64_to_int (buf
[ 1]) << 6;
1923 l
|= itoa64_to_int (buf
[ 2]) << 12;
1924 l
|= itoa64_to_int (buf
[ 3]) << 18;
1926 digest
[ 0] = (l
>> 16) & 0xff;
1927 digest
[10] = (l
>> 8) & 0xff;
1928 digest
[20] = (l
>> 0) & 0xff;
1930 l
= itoa64_to_int (buf
[ 4]) << 0;
1931 l
|= itoa64_to_int (buf
[ 5]) << 6;
1932 l
|= itoa64_to_int (buf
[ 6]) << 12;
1933 l
|= itoa64_to_int (buf
[ 7]) << 18;
1935 digest
[21] = (l
>> 16) & 0xff;
1936 digest
[ 1] = (l
>> 8) & 0xff;
1937 digest
[11] = (l
>> 0) & 0xff;
1939 l
= itoa64_to_int (buf
[ 8]) << 0;
1940 l
|= itoa64_to_int (buf
[ 9]) << 6;
1941 l
|= itoa64_to_int (buf
[10]) << 12;
1942 l
|= itoa64_to_int (buf
[11]) << 18;
1944 digest
[12] = (l
>> 16) & 0xff;
1945 digest
[22] = (l
>> 8) & 0xff;
1946 digest
[ 2] = (l
>> 0) & 0xff;
1948 l
= itoa64_to_int (buf
[12]) << 0;
1949 l
|= itoa64_to_int (buf
[13]) << 6;
1950 l
|= itoa64_to_int (buf
[14]) << 12;
1951 l
|= itoa64_to_int (buf
[15]) << 18;
1953 digest
[ 3] = (l
>> 16) & 0xff;
1954 digest
[13] = (l
>> 8) & 0xff;
1955 digest
[23] = (l
>> 0) & 0xff;
1957 l
= itoa64_to_int (buf
[16]) << 0;
1958 l
|= itoa64_to_int (buf
[17]) << 6;
1959 l
|= itoa64_to_int (buf
[18]) << 12;
1960 l
|= itoa64_to_int (buf
[19]) << 18;
1962 digest
[24] = (l
>> 16) & 0xff;
1963 digest
[ 4] = (l
>> 8) & 0xff;
1964 digest
[14] = (l
>> 0) & 0xff;
1966 l
= itoa64_to_int (buf
[20]) << 0;
1967 l
|= itoa64_to_int (buf
[21]) << 6;
1968 l
|= itoa64_to_int (buf
[22]) << 12;
1969 l
|= itoa64_to_int (buf
[23]) << 18;
1971 digest
[15] = (l
>> 16) & 0xff;
1972 digest
[25] = (l
>> 8) & 0xff;
1973 digest
[ 5] = (l
>> 0) & 0xff;
1975 l
= itoa64_to_int (buf
[24]) << 0;
1976 l
|= itoa64_to_int (buf
[25]) << 6;
1977 l
|= itoa64_to_int (buf
[26]) << 12;
1978 l
|= itoa64_to_int (buf
[27]) << 18;
1980 digest
[ 6] = (l
>> 16) & 0xff;
1981 digest
[16] = (l
>> 8) & 0xff;
1982 digest
[26] = (l
>> 0) & 0xff;
1984 l
= itoa64_to_int (buf
[28]) << 0;
1985 l
|= itoa64_to_int (buf
[29]) << 6;
1986 l
|= itoa64_to_int (buf
[30]) << 12;
1987 l
|= itoa64_to_int (buf
[31]) << 18;
1989 digest
[27] = (l
>> 16) & 0xff;
1990 digest
[ 7] = (l
>> 8) & 0xff;
1991 digest
[17] = (l
>> 0) & 0xff;
1993 l
= itoa64_to_int (buf
[32]) << 0;
1994 l
|= itoa64_to_int (buf
[33]) << 6;
1995 l
|= itoa64_to_int (buf
[34]) << 12;
1996 l
|= itoa64_to_int (buf
[35]) << 18;
1998 digest
[18] = (l
>> 16) & 0xff;
1999 digest
[28] = (l
>> 8) & 0xff;
2000 digest
[ 8] = (l
>> 0) & 0xff;
2002 l
= itoa64_to_int (buf
[36]) << 0;
2003 l
|= itoa64_to_int (buf
[37]) << 6;
2004 l
|= itoa64_to_int (buf
[38]) << 12;
2005 l
|= itoa64_to_int (buf
[39]) << 18;
2007 digest
[ 9] = (l
>> 16) & 0xff;
2008 digest
[19] = (l
>> 8) & 0xff;
2009 digest
[29] = (l
>> 0) & 0xff;
2011 l
= itoa64_to_int (buf
[40]) << 0;
2012 l
|= itoa64_to_int (buf
[41]) << 6;
2013 l
|= itoa64_to_int (buf
[42]) << 12;
2015 digest
[31] = (l
>> 8) & 0xff;
2016 digest
[30] = (l
>> 0) & 0xff;
2019 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2023 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2025 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2028 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2032 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2035 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2039 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2046 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2053 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2060 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2067 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2074 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2081 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2088 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2095 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2097 buf
[42] = int_to_itoa64 (l
& 0x3f);
2100 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2104 l
= itoa64_to_int (buf
[ 0]) << 0;
2105 l
|= itoa64_to_int (buf
[ 1]) << 6;
2106 l
|= itoa64_to_int (buf
[ 2]) << 12;
2107 l
|= itoa64_to_int (buf
[ 3]) << 18;
2109 digest
[ 0] = (l
>> 0) & 0xff;
2110 digest
[ 1] = (l
>> 8) & 0xff;
2111 digest
[ 2] = (l
>> 16) & 0xff;
2113 l
= itoa64_to_int (buf
[ 4]) << 0;
2114 l
|= itoa64_to_int (buf
[ 5]) << 6;
2115 l
|= itoa64_to_int (buf
[ 6]) << 12;
2116 l
|= itoa64_to_int (buf
[ 7]) << 18;
2118 digest
[ 3] = (l
>> 0) & 0xff;
2119 digest
[ 4] = (l
>> 8) & 0xff;
2120 digest
[ 5] = (l
>> 16) & 0xff;
2122 l
= itoa64_to_int (buf
[ 8]) << 0;
2123 l
|= itoa64_to_int (buf
[ 9]) << 6;
2124 l
|= itoa64_to_int (buf
[10]) << 12;
2125 l
|= itoa64_to_int (buf
[11]) << 18;
2127 digest
[ 6] = (l
>> 0) & 0xff;
2128 digest
[ 7] = (l
>> 8) & 0xff;
2129 digest
[ 8] = (l
>> 16) & 0xff;
2131 l
= itoa64_to_int (buf
[12]) << 0;
2132 l
|= itoa64_to_int (buf
[13]) << 6;
2133 l
|= itoa64_to_int (buf
[14]) << 12;
2134 l
|= itoa64_to_int (buf
[15]) << 18;
2136 digest
[ 9] = (l
>> 0) & 0xff;
2137 digest
[10] = (l
>> 8) & 0xff;
2138 digest
[11] = (l
>> 16) & 0xff;
2140 l
= itoa64_to_int (buf
[16]) << 0;
2141 l
|= itoa64_to_int (buf
[17]) << 6;
2142 l
|= itoa64_to_int (buf
[18]) << 12;
2143 l
|= itoa64_to_int (buf
[19]) << 18;
2145 digest
[12] = (l
>> 0) & 0xff;
2146 digest
[13] = (l
>> 8) & 0xff;
2147 digest
[14] = (l
>> 16) & 0xff;
2149 l
= itoa64_to_int (buf
[20]) << 0;
2150 l
|= itoa64_to_int (buf
[21]) << 6;
2151 l
|= itoa64_to_int (buf
[22]) << 12;
2152 l
|= itoa64_to_int (buf
[23]) << 18;
2154 digest
[15] = (l
>> 0) & 0xff;
2155 digest
[16] = (l
>> 8) & 0xff;
2156 digest
[17] = (l
>> 16) & 0xff;
2158 l
= itoa64_to_int (buf
[24]) << 0;
2159 l
|= itoa64_to_int (buf
[25]) << 6;
2160 l
|= itoa64_to_int (buf
[26]) << 12;
2161 l
|= itoa64_to_int (buf
[27]) << 18;
2163 digest
[18] = (l
>> 0) & 0xff;
2164 digest
[19] = (l
>> 8) & 0xff;
2165 digest
[20] = (l
>> 16) & 0xff;
2167 l
= itoa64_to_int (buf
[28]) << 0;
2168 l
|= itoa64_to_int (buf
[29]) << 6;
2169 l
|= itoa64_to_int (buf
[30]) << 12;
2170 l
|= itoa64_to_int (buf
[31]) << 18;
2172 digest
[21] = (l
>> 0) & 0xff;
2173 digest
[22] = (l
>> 8) & 0xff;
2174 digest
[23] = (l
>> 16) & 0xff;
2176 l
= itoa64_to_int (buf
[32]) << 0;
2177 l
|= itoa64_to_int (buf
[33]) << 6;
2178 l
|= itoa64_to_int (buf
[34]) << 12;
2179 l
|= itoa64_to_int (buf
[35]) << 18;
2181 digest
[24] = (l
>> 0) & 0xff;
2182 digest
[25] = (l
>> 8) & 0xff;
2183 digest
[26] = (l
>> 16) & 0xff;
2185 l
= itoa64_to_int (buf
[36]) << 0;
2186 l
|= itoa64_to_int (buf
[37]) << 6;
2187 l
|= itoa64_to_int (buf
[38]) << 12;
2188 l
|= itoa64_to_int (buf
[39]) << 18;
2190 digest
[27] = (l
>> 0) & 0xff;
2191 digest
[28] = (l
>> 8) & 0xff;
2192 digest
[29] = (l
>> 16) & 0xff;
2194 l
= itoa64_to_int (buf
[40]) << 0;
2195 l
|= itoa64_to_int (buf
[41]) << 6;
2196 l
|= itoa64_to_int (buf
[42]) << 12;
2197 l
|= itoa64_to_int (buf
[43]) << 18;
2199 digest
[30] = (l
>> 0) & 0xff;
2200 digest
[31] = (l
>> 8) & 0xff;
2201 digest
[32] = (l
>> 16) & 0xff;
2236 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2240 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2242 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2245 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2247 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2249 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2252 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2254 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2256 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[11] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2263 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[15] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2270 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[19] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2277 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[23] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2284 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[27] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2291 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[31] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2298 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[35] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2305 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[39] = int_to_itoa64 (l
& 0x3f);
2310 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2312 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2315 //buf[43] = int_to_itoa64 (l & 0x3f);
2323 static struct termio savemodes
;
2324 static int havemodes
= 0;
2328 struct termio modmodes
;
2330 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2334 modmodes
= savemodes
;
2335 modmodes
.c_lflag
&= ~ICANON
;
2336 modmodes
.c_cc
[VMIN
] = 1;
2337 modmodes
.c_cc
[VTIME
] = 0;
2339 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2348 FD_SET (fileno (stdin
), &rfds
);
2355 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2357 if (retval
== 0) return 0;
2358 if (retval
== -1) return -1;
2365 if (!havemodes
) return 0;
2367 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2372 static struct termios savemodes
;
2373 static int havemodes
= 0;
2377 struct termios modmodes
;
2379 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2383 modmodes
= savemodes
;
2384 modmodes
.c_lflag
&= ~ICANON
;
2385 modmodes
.c_cc
[VMIN
] = 1;
2386 modmodes
.c_cc
[VTIME
] = 0;
2388 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2397 FD_SET (fileno (stdin
), &rfds
);
2404 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2406 if (retval
== 0) return 0;
2407 if (retval
== -1) return -1;
2414 if (!havemodes
) return 0;
2416 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2421 static DWORD saveMode
= 0;
2425 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2427 GetConsoleMode (stdinHandle
, &saveMode
);
2428 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2435 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2437 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2439 if (rc
== WAIT_TIMEOUT
) return 0;
2440 if (rc
== WAIT_ABANDONED
) return -1;
2441 if (rc
== WAIT_FAILED
) return -1;
2443 // The whole ReadConsoleInput () part is a workaround.
2444 // For some unknown reason, maybe a mingw bug, a random signal
2445 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2446 // Then it wants to read with getche () a keyboard input
2447 // which has never been made.
2449 INPUT_RECORD buf
[100];
2453 memset (buf
, 0, sizeof (buf
));
2455 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2457 FlushConsoleInputBuffer (stdinHandle
);
2459 for (uint i
= 0; i
< num
; i
++)
2461 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2463 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2465 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2467 return KeyEvent
.uChar
.AsciiChar
;
2475 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2477 SetConsoleMode (stdinHandle
, saveMode
);
2487 #define MSG_ENOMEM "Insufficient memory available"
2489 void *mycalloc (size_t nmemb
, size_t size
)
2491 void *p
= calloc (nmemb
, size
);
2495 log_error ("ERROR: %s", MSG_ENOMEM
);
2503 void *mymalloc (size_t size
)
2505 void *p
= malloc (size
);
2509 log_error ("ERROR: %s", MSG_ENOMEM
);
2514 memset (p
, 0, size
);
2519 void myfree (void *ptr
)
2521 if (ptr
== NULL
) return;
2526 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2528 void *p
= realloc (ptr
, oldsz
+ add
);
2532 log_error ("ERROR: %s", MSG_ENOMEM
);
2537 memset ((char *) p
+ oldsz
, 0, add
);
2542 char *mystrdup (const char *s
)
2544 const size_t len
= strlen (s
);
2546 char *b
= (char *) mymalloc (len
+ 1);
2553 FILE *logfile_open (char *logfile
)
2555 FILE *fp
= fopen (logfile
, "ab");
2565 void logfile_close (FILE *fp
)
2567 if (fp
== stdout
) return;
2572 void logfile_append (const char *fmt
, ...)
2574 if (data
.logfile_disable
== 1) return;
2576 FILE *fp
= logfile_open (data
.logfile
);
2582 vfprintf (fp
, fmt
, ap
);
2593 int logfile_generate_id ()
2595 const int n
= rand ();
2604 char *logfile_generate_topid ()
2606 const int id
= logfile_generate_id ();
2608 char *topid
= (char *) mymalloc (1 + 16 + 1);
2610 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2615 char *logfile_generate_subid ()
2617 const int id
= logfile_generate_id ();
2619 char *subid
= (char *) mymalloc (1 + 16 + 1);
2621 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2631 void lock_file (FILE *fp
)
2635 memset (&lock
, 0, sizeof (struct flock
));
2637 lock
.l_type
= F_WRLCK
;
2638 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2642 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2649 void unlock_file (FILE *fp
)
2653 memset (&lock
, 0, sizeof (struct flock
));
2655 lock
.l_type
= F_UNLCK
;
2656 fcntl(fileno(fp
), F_SETLK
, &lock
);
2663 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2665 FlushFileBuffers (h
);
2674 #if defined(_WIN) && defined(HAVE_NVAPI)
2675 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2679 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2683 log_info ("WARN: No NvAPI adapters found");
2690 #endif // _WIN && HAVE_NVAPI
2692 #if defined(LINUX) && defined(HAVE_NVML)
2693 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2697 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2699 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2701 // can be used to determine if the device by index matches the cuda device by index
2702 // char name[100]; memset (name, 0, sizeof (name));
2703 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2710 log_info ("WARN: No NVML adapters found");
2717 #endif // LINUX && HAVE_NVML
2720 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2722 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2724 if (iNumberAdapters
== 0)
2726 log_info ("WARN: No ADL adapters found.");
2735 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2737 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2738 ADLODParameters lpOdParameters;
2740 lpOdParameters.iSize = sizeof (ADLODParameters);
2741 size_t plevels_size = 0;
2743 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2745 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2746 __func__, iAdapterIndex,
2747 lpOdParameters.iNumberOfPerformanceLevels,
2748 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2749 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2751 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2753 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2755 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2757 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2759 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2760 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2761 __func__, iAdapterIndex, j,
2762 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2764 myfree (lpOdPerformanceLevels);
2770 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2772 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2774 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2776 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2778 return lpAdapterInfo
;
2783 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2786 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2790 for (uint i = 0; i < num_adl_adapters; i++)
2792 int opencl_bus_num = hm_device[i].busid;
2793 int opencl_dev_num = hm_device[i].devid;
2795 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2803 if (idx >= DEVICES_MAX) return -1;
2808 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2810 for (uint i = 0; i < opencl_num_devices; i++)
2812 cl_device_topology_amd device_topology;
2814 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2816 hm_device[i].busid = device_topology.pcie.bus;
2817 hm_device[i].devid = device_topology.pcie.device;
2822 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2824 // basically bubble sort
2826 for (int i
= 0; i
< num_adl_adapters
; i
++)
2828 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2830 // get info of adapter [x]
2832 u32 adapter_index_x
= valid_adl_device_list
[j
];
2833 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2835 u32 bus_num_x
= info_x
.iBusNumber
;
2836 u32 dev_num_x
= info_x
.iDeviceNumber
;
2838 // get info of adapter [y]
2840 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2841 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2843 u32 bus_num_y
= info_y
.iBusNumber
;
2844 u32 dev_num_y
= info_y
.iDeviceNumber
;
2848 if (bus_num_y
< bus_num_x
)
2852 else if (bus_num_y
== bus_num_x
)
2854 if (dev_num_y
< dev_num_x
)
2862 u32 temp
= valid_adl_device_list
[j
+ 1];
2864 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2865 valid_adl_device_list
[j
+ 0] = temp
;
2871 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2873 *num_adl_adapters
= 0;
2875 u32
*adl_adapters
= NULL
;
2877 int *bus_numbers
= NULL
;
2878 int *device_numbers
= NULL
;
2880 for (int i
= 0; i
< iNumberAdapters
; i
++)
2882 AdapterInfo info
= lpAdapterInfo
[i
];
2884 if (strlen (info
.strUDID
) < 1) continue;
2887 if (info
.iVendorID
!= 1002) continue;
2889 if (info
.iVendorID
!= 0x1002) continue;
2892 if (info
.iBusNumber
< 0) continue;
2893 if (info
.iDeviceNumber
< 0) continue;
2897 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2899 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2906 if (found
) continue;
2908 // add it to the list
2910 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2912 adl_adapters
[*num_adl_adapters
] = i
;
2914 // rest is just bookkeeping
2916 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2917 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2919 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2920 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2922 (*num_adl_adapters
)++;
2925 myfree (bus_numbers
);
2926 myfree (device_numbers
);
2928 // sort the list by increasing bus id, device id number
2930 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2932 return adl_adapters
;
2935 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2937 // loop through all valid devices
2939 for (int i
= 0; i
< num_adl_adapters
; i
++)
2941 u32 adapter_index
= valid_adl_device_list
[i
];
2945 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2947 // unfortunately this doesn't work since bus id and dev id are not unique
2948 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2949 // if (opencl_device_index == -1) continue;
2951 int opencl_device_index
= i
;
2953 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2955 // get fanspeed info
2957 if (hm_device
[opencl_device_index
].od_version
== 5)
2959 ADLFanSpeedInfo FanSpeedInfo
;
2961 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2963 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2965 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2967 // check read and write capability in fanspeedinfo
2969 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2970 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2972 hm_device
[opencl_device_index
].fan_supported
= 1;
2976 hm_device
[opencl_device_index
].fan_supported
= 0;
2979 else // od_version == 6
2981 ADLOD6FanSpeedInfo faninfo
;
2983 memset (&faninfo
, 0, sizeof (faninfo
));
2985 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2987 // check read capability in fanspeedinfo
2989 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2991 hm_device
[opencl_device_index
].fan_supported
= 1;
2995 hm_device
[opencl_device_index
].fan_supported
= 0;
3003 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3005 for (int i
= 0; i
< num_adl_adapters
; i
++)
3007 u32 adapter_index
= valid_adl_device_list
[i
];
3011 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3013 // get overdrive version
3015 int od_supported
= 0;
3019 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3021 // store the overdrive version in hm_device
3023 // unfortunately this doesn't work since bus id and dev id are not unique
3024 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3025 // if (opencl_device_index == -1) continue;
3027 int opencl_device_index
= i
;
3029 hm_device
[opencl_device_index
].od_version
= od_version
;
3035 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3037 for (int i
= 0; i
< num_adl_adapters
; i
++)
3039 u32 adapter_index
= valid_adl_device_list
[i
];
3043 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3045 // store the iAdapterIndex in hm_device
3047 // unfortunately this doesn't work since bus id and dev id are not unique
3048 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3049 // if (opencl_device_index == -1) continue;
3051 int opencl_device_index
= i
;
3053 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3056 return num_adl_adapters
;
3060 int hm_get_temperature_with_device_id (const uint device_id
)
3062 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3065 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3069 if (data
.hm_device
[device_id
].od_version
== 5)
3071 ADLTemperature Temperature
;
3073 Temperature
.iSize
= sizeof (ADLTemperature
);
3075 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3077 return Temperature
.iTemperature
/ 1000;
3079 else if (data
.hm_device
[device_id
].od_version
== 6)
3081 int Temperature
= 0;
3083 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3085 return Temperature
/ 1000;
3091 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3092 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3094 #if defined(LINUX) && defined(HAVE_NVML)
3095 int temperature
= 0;
3097 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
);
3102 #if defined(WIN) && defined(HAVE_NVAPI)
3103 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3105 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3106 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3107 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3108 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3110 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3112 return pThermalSettings
.sensor
[0].currentTemp
;
3113 #endif // WIN && HAVE_NVAPI
3115 #endif // HAVE_NVML || HAVE_NVAPI
3120 int hm_get_fanspeed_with_device_id (const uint device_id
)
3122 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3123 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3125 if (data
.hm_device
[device_id
].fan_supported
== 1)
3128 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3132 if (data
.hm_device
[device_id
].od_version
== 5)
3134 ADLFanSpeedValue lpFanSpeedValue
;
3136 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3138 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3139 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3140 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3142 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3144 return lpFanSpeedValue
.iFanSpeed
;
3146 else // od_version == 6
3148 ADLOD6FanSpeedInfo faninfo
;
3150 memset (&faninfo
, 0, sizeof (faninfo
));
3152 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3154 return faninfo
.iFanSpeedPercent
;
3160 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3161 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3163 #if defined(LINUX) && defined(HAVE_NVML)
3166 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
);
3171 #if defined(WIN) && defined(HAVE_NVAPI)
3173 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3175 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3177 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3179 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3182 #endif // HAVE_NVML || HAVE_NVAPI
3188 int hm_get_utilization_with_device_id (const uint device_id
)
3190 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3193 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3197 ADLPMActivity PMActivity
;
3199 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3201 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3203 return PMActivity
.iActivityPercent
;
3208 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3209 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3211 #if defined(LINUX) && defined(HAVE_NVML)
3212 nvmlUtilization_t utilization
;
3214 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3216 return utilization
.gpu
;
3219 #if defined(WIN) && defined(HAVE_NVAPI)
3220 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3222 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3224 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3226 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3229 #endif // HAVE_NVML || HAVE_NVAPI
3234 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3236 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3239 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3243 ADLPMActivity PMActivity
;
3245 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3247 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3249 return PMActivity
.iMemoryClock
/ 100;
3254 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3255 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3257 #if defined(LINUX) && defined(HAVE_NVML)
3260 hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_CLOCK_MEM
, &clock
);
3265 #if defined(WIN) && defined(HAVE_NVAPI)
3269 #endif // HAVE_NVML || HAVE_NVAPI
3274 int hm_get_corespeed_with_device_id (const uint device_id
)
3276 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3279 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3283 ADLPMActivity PMActivity
;
3285 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3287 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3289 return PMActivity
.iEngineClock
/ 100;
3294 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3295 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3297 #if defined(LINUX) && defined(HAVE_NVML)
3300 hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_CLOCK_SM
, &clock
);
3305 #if defined(WIN) && defined(HAVE_NVAPI)
3309 #endif // HAVE_NVML || HAVE_NVAPI
3315 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3317 if (data
.hm_device
[device_id
].fan_supported
== 1)
3321 if (data
.hm_device
[device_id
].od_version
== 5)
3323 ADLFanSpeedValue lpFanSpeedValue
;
3325 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3327 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3328 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3329 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3330 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3332 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3336 else // od_version == 6
3338 ADLOD6FanSpeedValue fan_speed_value
;
3340 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3342 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3343 fan_speed_value
.iFanSpeed
= fanspeed
;
3345 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3356 // helper function for status display
3358 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3360 #define VALUE_NOT_AVAILABLE "N/A"
3364 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3368 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3371 #endif // HAVE_HWMON
3377 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3379 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3381 if (css_cnt
> SP_PW_MAX
)
3383 log_error ("ERROR: mask length is too long");
3388 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3390 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3392 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3393 uint cs_len
= css
[css_pos
].cs_len
;
3395 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3397 uint c
= cs_buf
[cs_pos
] & 0xff;
3404 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3406 cs_t
*cs
= &css
[css_cnt
];
3408 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3410 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3414 for (i
= 0; i
< cs
->cs_len
; i
++)
3416 const uint u
= cs
->cs_buf
[i
];
3421 for (i
= 0; i
< in_len
; i
++)
3423 uint u
= in_buf
[i
] & 0xff;
3425 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3427 if (css_uniq
[u
] == 1) continue;
3431 cs
->cs_buf
[cs
->cs_len
] = u
;
3439 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3443 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3445 uint p0
= in_buf
[in_pos
] & 0xff;
3447 if (interpret
== 1 && p0
== '?')
3451 if (in_pos
== in_len
) break;
3453 uint p1
= in_buf
[in_pos
] & 0xff;
3457 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3459 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3461 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3463 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3465 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3467 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3469 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3470 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3472 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3473 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3475 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3476 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3478 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3479 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3481 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3483 default: log_error ("Syntax error: %s", in_buf
);
3489 if (data
.hex_charset
)
3493 if (in_pos
== in_len
)
3495 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3500 uint p1
= in_buf
[in_pos
] & 0xff;
3502 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3504 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3511 chr
= hex_convert (p1
) << 0;
3512 chr
|= hex_convert (p0
) << 4;
3514 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3520 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3526 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3530 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3532 sum
*= css
[css_pos
].cs_len
;
3538 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3540 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3545 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3547 char p0
= mask_buf
[mask_pos
];
3553 if (mask_pos
== mask_len
) break;
3555 char p1
= mask_buf
[mask_pos
];
3561 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3563 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3565 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3567 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3569 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3571 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3573 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3574 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3576 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3577 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3579 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3580 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3582 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3583 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3585 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3587 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3593 if (data
.hex_charset
)
3597 // if there is no 2nd hex character, show an error:
3599 if (mask_pos
== mask_len
)
3601 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3606 char p1
= mask_buf
[mask_pos
];
3608 // if they are not valid hex character, show an error:
3610 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3612 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3619 chr
|= hex_convert (p1
) << 0;
3620 chr
|= hex_convert (p0
) << 4;
3622 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3628 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3635 log_error ("ERROR: invalid mask length (0)");
3645 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3647 for (int i
= 0; i
< css_cnt
; i
++)
3649 uint len
= css
[i
].cs_len
;
3650 u64 next
= val
/ len
;
3651 uint pos
= val
% len
;
3652 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3657 void mp_cut_at (char *mask
, uint max
)
3661 uint mask_len
= strlen (mask
);
3663 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3665 if (mask
[i
] == '?') i
++;
3671 void mp_setup_sys (cs_t
*mp_sys
)
3675 uint donec
[CHARSIZ
] = { 0 };
3677 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3678 mp_sys
[0].cs_buf
[pos
++] = chr
;
3679 mp_sys
[0].cs_len
= pos
; }
3681 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3682 mp_sys
[1].cs_buf
[pos
++] = chr
;
3683 mp_sys
[1].cs_len
= pos
; }
3685 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3686 mp_sys
[2].cs_buf
[pos
++] = chr
;
3687 mp_sys
[2].cs_len
= pos
; }
3689 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3690 mp_sys
[3].cs_buf
[pos
++] = chr
;
3691 mp_sys
[3].cs_len
= pos
; }
3693 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3694 mp_sys
[4].cs_len
= pos
; }
3696 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3697 mp_sys
[5].cs_len
= pos
; }
3700 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3702 FILE *fp
= fopen (buf
, "rb");
3704 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3706 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3710 char mp_file
[1024] = { 0 };
3712 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3716 len
= in_superchop (mp_file
);
3720 log_info ("WARNING: charset file corrupted");
3722 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3726 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3731 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3733 mp_usr
[index
].cs_len
= 0;
3735 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3738 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3740 char *new_mask_buf
= (char *) mymalloc (256);
3746 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3748 if (css_pos
== len
) break;
3750 char p0
= mask_buf
[mask_pos
];
3752 new_mask_buf
[mask_pos
] = p0
;
3758 if (mask_pos
== mask_len
) break;
3760 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3764 if (data
.hex_charset
)
3768 if (mask_pos
== mask_len
)
3770 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3775 char p1
= mask_buf
[mask_pos
];
3777 // if they are not valid hex character, show an error:
3779 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3781 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3786 new_mask_buf
[mask_pos
] = p1
;
3791 if (css_pos
== len
) return (new_mask_buf
);
3793 myfree (new_mask_buf
);
3802 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3808 for (i
= start
; i
< stop
; i
++)
3810 sum
*= root_css_buf
[i
].cs_len
;
3816 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3820 cs_t
*cs
= &root_css_buf
[start
];
3824 for (i
= start
; i
< stop
; i
++)
3826 const u64 m
= v
% cs
->cs_len
;
3827 const u64 d
= v
/ cs
->cs_len
;
3831 const uint k
= cs
->cs_buf
[m
];
3833 pw_buf
[i
- start
] = (char) k
;
3835 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3839 int sp_comp_val (const void *p1
, const void *p2
)
3841 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3842 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3844 return b2
->val
- b1
->val
;
3847 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
)
3854 * Initialize hcstats
3857 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3859 u64
*root_stats_ptr
= root_stats_buf
;
3861 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3863 for (i
= 0; i
< SP_PW_MAX
; i
++)
3865 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3867 root_stats_ptr
+= CHARSIZ
;
3870 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3872 u64
*markov_stats_ptr
= markov_stats_buf
;
3874 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3876 for (i
= 0; i
< SP_PW_MAX
; i
++)
3878 for (j
= 0; j
< CHARSIZ
; j
++)
3880 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3882 markov_stats_ptr
+= CHARSIZ
;
3892 char hcstat_tmp
[256] = { 0 };
3894 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3896 hcstat
= hcstat_tmp
;
3899 FILE *fd
= fopen (hcstat
, "rb");
3903 log_error ("%s: %s", hcstat
, strerror (errno
));
3908 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3910 log_error ("%s: Could not load data", hcstat
);
3917 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3919 log_error ("%s: Could not load data", hcstat
);
3929 * Markov modifier of hcstat_table on user request
3934 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3935 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3940 /* Add all stats to first position */
3942 for (i
= 1; i
< SP_PW_MAX
; i
++)
3944 u64
*out
= root_stats_buf_by_pos
[0];
3945 u64
*in
= root_stats_buf_by_pos
[i
];
3947 for (j
= 0; j
< CHARSIZ
; j
++)
3953 for (i
= 1; i
< SP_PW_MAX
; i
++)
3955 u64
*out
= markov_stats_buf_by_key
[0][0];
3956 u64
*in
= markov_stats_buf_by_key
[i
][0];
3958 for (j
= 0; j
< CHARSIZ
; j
++)
3960 for (k
= 0; k
< CHARSIZ
; k
++)
3967 /* copy them to all pw_positions */
3969 for (i
= 1; i
< SP_PW_MAX
; i
++)
3971 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3974 for (i
= 1; i
< SP_PW_MAX
; i
++)
3976 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3984 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3986 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3988 for (i
= 0; i
< SP_PW_MAX
; i
++)
3990 root_table_buf_by_pos
[i
] = root_table_ptr
;
3992 root_table_ptr
+= CHARSIZ
;
3995 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3997 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3999 for (i
= 0; i
< SP_PW_MAX
; i
++)
4001 for (j
= 0; j
< CHARSIZ
; j
++)
4003 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4005 markov_table_ptr
+= CHARSIZ
;
4010 * Convert hcstat to tables
4013 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4015 uint key
= i
% CHARSIZ
;
4017 root_table_buf
[i
].key
= key
;
4018 root_table_buf
[i
].val
= root_stats_buf
[i
];
4021 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4023 uint key
= i
% CHARSIZ
;
4025 markov_table_buf
[i
].key
= key
;
4026 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4029 myfree (root_stats_buf
);
4030 myfree (markov_stats_buf
);
4036 for (i
= 0; i
< SP_PW_MAX
; i
++)
4038 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4041 for (i
= 0; i
< SP_PW_MAX
; i
++)
4043 for (j
= 0; j
< CHARSIZ
; j
++)
4045 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4050 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
])
4053 * Convert tables to css
4056 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4058 uint pw_pos
= i
/ CHARSIZ
;
4060 cs_t
*cs
= &root_css_buf
[pw_pos
];
4062 if (cs
->cs_len
== threshold
) continue;
4064 uint key
= root_table_buf
[i
].key
;
4066 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4068 cs
->cs_buf
[cs
->cs_len
] = key
;
4074 * Convert table to css
4077 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4079 uint c
= i
/ CHARSIZ
;
4081 cs_t
*cs
= &markov_css_buf
[c
];
4083 if (cs
->cs_len
== threshold
) continue;
4085 uint pw_pos
= c
/ CHARSIZ
;
4087 uint key
= markov_table_buf
[i
].key
;
4089 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4091 cs
->cs_buf
[cs
->cs_len
] = key
;
4097 for (uint i = 0; i < 8; i++)
4099 for (uint j = 0x20; j < 0x80; j++)
4101 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4103 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4105 for (uint k = 0; k < 10; k++)
4107 printf (" %u\n", ptr->cs_buf[k]);
4114 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4116 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4118 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4128 for (uint j
= 1; j
< CHARSIZ
; j
++)
4138 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4140 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4142 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4144 out
+= CHARSIZ
* CHARSIZ
;
4145 in
+= CHARSIZ
* CHARSIZ
;
4147 for (uint j
= 0; j
< CHARSIZ
; j
++)
4154 for (uint k
= 1; k
< CHARSIZ
; k
++)
4166 * mixed shared functions
4169 void dump_hex (const u8
*s
, const int sz
)
4171 for (int i
= 0; i
< sz
; i
++)
4173 log_info_nn ("%02x ", s
[i
]);
4179 void usage_mini_print (const char *progname
)
4181 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4184 void usage_big_print (const char *progname
)
4186 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4189 char *get_exec_path ()
4191 int exec_path_len
= 1024;
4193 char *exec_path
= (char *) mymalloc (exec_path_len
);
4197 char tmp
[32] = { 0 };
4199 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4201 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4205 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4209 uint size
= exec_path_len
;
4211 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4213 log_error("! executable path buffer too small\n");
4218 const int len
= strlen (exec_path
);
4221 #error Your Operating System is not supported or detected
4229 char *get_install_dir (const char *progname
)
4231 char *install_dir
= mystrdup (progname
);
4232 char *last_slash
= NULL
;
4234 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4238 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4244 install_dir
[0] = '.';
4248 return (install_dir
);
4251 char *get_profile_dir (const char *homedir
)
4253 #define DOT_HASHCAT ".hashcat"
4255 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4257 char *profile_dir
= (char *) mymalloc (len
+ 1);
4259 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4264 char *get_session_dir (const char *profile_dir
)
4266 #define SESSIONS_FOLDER "sessions"
4268 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4270 char *session_dir
= (char *) mymalloc (len
+ 1);
4272 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4277 uint
count_lines (FILE *fd
)
4281 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4287 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4289 if (nread
< 1) continue;
4293 for (i
= 0; i
< nread
; i
++)
4295 if (prev
== '\n') cnt
++;
4306 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4310 FILE *fd
= fopen (filename
, "rb");
4314 log_error ("%s: %s", filename
, strerror (errno
));
4319 #define MAX_KEY_SIZE (1024 * 1024)
4321 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4323 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4329 for (int fpos
= 0; fpos
< nread
; fpos
++)
4331 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4333 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4334 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4335 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4336 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4338 if (kpos
>= 64) kpos
= 0;
4345 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4349 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4350 if (CPU_ISSET(core
, cpu_set
)) break;
4352 thread_affinity_policy_data_t policy
= { core
};
4354 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4356 if (data
.quiet
== 0)
4358 if (rc
!= KERN_SUCCESS
)
4360 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4368 void set_cpu_affinity (char *cpu_affinity
)
4371 DWORD_PTR aff_mask
= 0;
4379 char *devices
= strdup (cpu_affinity
);
4381 char *next
= strtok (devices
, ",");
4385 uint cpu_id
= atoi (next
);
4400 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4406 aff_mask
|= 1 << (cpu_id
- 1);
4408 CPU_SET ((cpu_id
- 1), &cpuset
);
4411 } while ((next
= strtok (NULL
, ",")) != NULL
);
4417 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4418 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4420 pthread_t thread
= pthread_self ();
4421 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4425 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4427 char *element
, *end
;
4429 end
= (char *) base
+ nmemb
* size
;
4431 for (element
= (char *) base
; element
< end
; element
+= size
)
4432 if (!compar (element
, key
))
4438 int sort_by_u32 (const void *v1
, const void *v2
)
4440 const u32
*s1
= (const u32
*) v1
;
4441 const u32
*s2
= (const u32
*) v2
;
4446 int sort_by_salt (const void *v1
, const void *v2
)
4448 const salt_t
*s1
= (const salt_t
*) v1
;
4449 const salt_t
*s2
= (const salt_t
*) v2
;
4451 const int res1
= s1
->salt_len
- s2
->salt_len
;
4453 if (res1
!= 0) return (res1
);
4455 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4457 if (res2
!= 0) return (res2
);
4465 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4466 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4473 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4474 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4480 int sort_by_salt_buf (const void *v1
, const void *v2
)
4482 const pot_t
*p1
= (const pot_t
*) v1
;
4483 const pot_t
*p2
= (const pot_t
*) v2
;
4485 const hash_t
*h1
= &p1
->hash
;
4486 const hash_t
*h2
= &p2
->hash
;
4488 const salt_t
*s1
= h1
->salt
;
4489 const salt_t
*s2
= h2
->salt
;
4495 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4496 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4502 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4504 const hash_t
*h1
= (const hash_t
*) v1
;
4505 const hash_t
*h2
= (const hash_t
*) v2
;
4507 const salt_t
*s1
= h1
->salt
;
4508 const salt_t
*s2
= h2
->salt
;
4510 // testphase: this should work
4515 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4516 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4519 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4520 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4521 if (s1->salt_len > s2->salt_len) return ( 1);
4522 if (s1->salt_len < s2->salt_len) return (-1);
4524 uint n = s1->salt_len;
4528 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4529 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4536 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4538 const hash_t
*h1
= (const hash_t
*) v1
;
4539 const hash_t
*h2
= (const hash_t
*) v2
;
4541 const salt_t
*s1
= h1
->salt
;
4542 const salt_t
*s2
= h2
->salt
;
4544 // 16 - 2 (since last 2 uints contain the digest)
4549 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4550 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4556 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4558 const hash_t
*h1
= (const hash_t
*) v1
;
4559 const hash_t
*h2
= (const hash_t
*) v2
;
4561 const void *d1
= h1
->digest
;
4562 const void *d2
= h2
->digest
;
4564 return data
.sort_by_digest (d1
, d2
);
4567 int sort_by_hash (const void *v1
, const void *v2
)
4569 const hash_t
*h1
= (const hash_t
*) v1
;
4570 const hash_t
*h2
= (const hash_t
*) v2
;
4574 const salt_t
*s1
= h1
->salt
;
4575 const salt_t
*s2
= h2
->salt
;
4577 int res
= sort_by_salt (s1
, s2
);
4579 if (res
!= 0) return (res
);
4582 const void *d1
= h1
->digest
;
4583 const void *d2
= h2
->digest
;
4585 return data
.sort_by_digest (d1
, d2
);
4588 int sort_by_pot (const void *v1
, const void *v2
)
4590 const pot_t
*p1
= (const pot_t
*) v1
;
4591 const pot_t
*p2
= (const pot_t
*) v2
;
4593 const hash_t
*h1
= &p1
->hash
;
4594 const hash_t
*h2
= &p2
->hash
;
4596 return sort_by_hash (h1
, h2
);
4599 int sort_by_mtime (const void *p1
, const void *p2
)
4601 const char **f1
= (const char **) p1
;
4602 const char **f2
= (const char **) p2
;
4604 struct stat s1
; stat (*f1
, &s1
);
4605 struct stat s2
; stat (*f2
, &s2
);
4607 return s2
.st_mtime
- s1
.st_mtime
;
4610 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4612 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4613 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4615 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4618 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4620 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4621 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4623 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4626 int sort_by_stringptr (const void *p1
, const void *p2
)
4628 const char **s1
= (const char **) p1
;
4629 const char **s2
= (const char **) p2
;
4631 return strcmp (*s1
, *s2
);
4634 int sort_by_dictstat (const void *s1
, const void *s2
)
4636 dictstat_t
*d1
= (dictstat_t
*) s1
;
4637 dictstat_t
*d2
= (dictstat_t
*) s2
;
4640 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4642 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4645 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4648 int sort_by_bitmap (const void *p1
, const void *p2
)
4650 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4651 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4653 return b1
->collisions
- b2
->collisions
;
4656 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4658 const u32
*d1
= (const u32
*) v1
;
4659 const u32
*d2
= (const u32
*) v2
;
4665 if (d1
[n
] > d2
[n
]) return ( 1);
4666 if (d1
[n
] < d2
[n
]) return (-1);
4672 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4674 const u32
*d1
= (const u32
*) v1
;
4675 const u32
*d2
= (const u32
*) v2
;
4681 if (d1
[n
] > d2
[n
]) return ( 1);
4682 if (d1
[n
] < d2
[n
]) return (-1);
4688 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4690 const u32
*d1
= (const u32
*) v1
;
4691 const u32
*d2
= (const u32
*) v2
;
4697 if (d1
[n
] > d2
[n
]) return ( 1);
4698 if (d1
[n
] < d2
[n
]) return (-1);
4704 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4706 const u32
*d1
= (const u32
*) v1
;
4707 const u32
*d2
= (const u32
*) v2
;
4713 if (d1
[n
] > d2
[n
]) return ( 1);
4714 if (d1
[n
] < d2
[n
]) return (-1);
4720 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4722 const u32
*d1
= (const u32
*) v1
;
4723 const u32
*d2
= (const u32
*) v2
;
4729 if (d1
[n
] > d2
[n
]) return ( 1);
4730 if (d1
[n
] < d2
[n
]) return (-1);
4736 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4738 const u32
*d1
= (const u32
*) v1
;
4739 const u32
*d2
= (const u32
*) v2
;
4745 if (d1
[n
] > d2
[n
]) return ( 1);
4746 if (d1
[n
] < d2
[n
]) return (-1);
4752 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4754 const u32
*d1
= (const u32
*) v1
;
4755 const u32
*d2
= (const u32
*) v2
;
4761 if (d1
[n
] > d2
[n
]) return ( 1);
4762 if (d1
[n
] < d2
[n
]) return (-1);
4768 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4770 const u32
*d1
= (const u32
*) v1
;
4771 const u32
*d2
= (const u32
*) v2
;
4777 if (d1
[n
] > d2
[n
]) return ( 1);
4778 if (d1
[n
] < d2
[n
]) return (-1);
4784 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4786 const u64
*d1
= (const u64
*) v1
;
4787 const u64
*d2
= (const u64
*) v2
;
4793 if (d1
[n
] > d2
[n
]) return ( 1);
4794 if (d1
[n
] < d2
[n
]) return (-1);
4800 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4802 const u64
*d1
= (const u64
*) v1
;
4803 const u64
*d2
= (const u64
*) v2
;
4809 if (d1
[n
] > d2
[n
]) return ( 1);
4810 if (d1
[n
] < d2
[n
]) return (-1);
4816 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4818 const u64
*d1
= (const u64
*) v1
;
4819 const u64
*d2
= (const u64
*) v2
;
4825 if (d1
[n
] > d2
[n
]) return ( 1);
4826 if (d1
[n
] < d2
[n
]) return (-1);
4832 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4834 const u32
*d1
= (const u32
*) v1
;
4835 const u32
*d2
= (const u32
*) v2
;
4837 const uint dgst_pos0
= data
.dgst_pos0
;
4838 const uint dgst_pos1
= data
.dgst_pos1
;
4839 const uint dgst_pos2
= data
.dgst_pos2
;
4840 const uint dgst_pos3
= data
.dgst_pos3
;
4842 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4843 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4844 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4845 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4846 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4847 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4848 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4849 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4854 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4856 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4857 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4859 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4861 if (res1
!= 0) return (res1
);
4866 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4868 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4869 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4871 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4873 if (res1
!= 0) return (res1
);
4875 const int res2
= t1
->attack_mode
4878 if (res2
!= 0) return (res2
);
4880 const int res3
= t1
->hash_type
4883 if (res3
!= 0) return (res3
);
4888 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
)
4890 uint outfile_autohex
= data
.outfile_autohex
;
4892 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4894 FILE *debug_fp
= NULL
;
4896 if (debug_file
!= NULL
)
4898 debug_fp
= fopen (debug_file
, "ab");
4900 lock_file (debug_fp
);
4907 if (debug_fp
== NULL
)
4909 log_info ("WARNING: Could not open debug-file for writing");
4913 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4915 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4917 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4920 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4922 if (debug_mode
== 4)
4924 fputc (':', debug_fp
);
4926 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4929 fputc ('\n', debug_fp
);
4931 if (debug_file
!= NULL
) fclose (debug_fp
);
4935 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4937 int needs_hexify
= 0;
4939 if (outfile_autohex
== 1)
4941 for (uint i
= 0; i
< plain_len
; i
++)
4943 if (plain_ptr
[i
] < 0x20)
4950 if (plain_ptr
[i
] > 0x7f)
4959 if (needs_hexify
== 1)
4961 fprintf (fp
, "$HEX[");
4963 for (uint i
= 0; i
< plain_len
; i
++)
4965 fprintf (fp
, "%02x", plain_ptr
[i
]);
4972 fwrite (plain_ptr
, plain_len
, 1, fp
);
4976 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
)
4978 uint outfile_format
= data
.outfile_format
;
4980 char separator
= data
.separator
;
4982 if (outfile_format
& OUTFILE_FMT_HASH
)
4984 fprintf (out_fp
, "%s", out_buf
);
4986 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4988 fputc (separator
, out_fp
);
4991 else if (data
.username
)
4993 if (username
!= NULL
)
4995 for (uint i
= 0; i
< user_len
; i
++)
4997 fprintf (out_fp
, "%c", username
[i
]);
5000 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5002 fputc (separator
, out_fp
);
5007 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5009 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5011 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5013 fputc (separator
, out_fp
);
5017 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5019 for (uint i
= 0; i
< plain_len
; i
++)
5021 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5024 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5026 fputc (separator
, out_fp
);
5030 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5033 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5038 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5040 fprintf (out_fp
, "%llu", crackpos
);
5045 fputc ('\n', out_fp
);
5048 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
)
5052 pot_key
.hash
.salt
= hashes_buf
->salt
;
5053 pot_key
.hash
.digest
= hashes_buf
->digest
;
5055 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5061 input_buf
[input_len
] = 0;
5064 unsigned char *username
= NULL
;
5069 user_t
*user
= hashes_buf
->hash_info
->user
;
5073 username
= (unsigned char *) (user
->user_name
);
5075 user_len
= user
->user_len
;
5079 // do output the line
5080 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5084 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5085 #define LM_MASKED_PLAIN "[notfound]"
5087 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
)
5093 pot_left_key
.hash
.salt
= hash_left
->salt
;
5094 pot_left_key
.hash
.digest
= hash_left
->digest
;
5096 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5100 uint weak_hash_found
= 0;
5102 pot_t pot_right_key
;
5104 pot_right_key
.hash
.salt
= hash_right
->salt
;
5105 pot_right_key
.hash
.digest
= hash_right
->digest
;
5107 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5109 if (pot_right_ptr
== NULL
)
5111 // special case, if "weak hash"
5113 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5115 weak_hash_found
= 1;
5117 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5119 // in theory this is not needed, but we are paranoia:
5121 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5122 pot_right_ptr
->plain_len
= 0;
5126 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5128 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
5133 // at least one half was found:
5137 input_buf
[input_len
] = 0;
5141 unsigned char *username
= NULL
;
5146 user_t
*user
= hash_left
->hash_info
->user
;
5150 username
= (unsigned char *) (user
->user_name
);
5152 user_len
= user
->user_len
;
5156 // mask the part which was not found
5158 uint left_part_masked
= 0;
5159 uint right_part_masked
= 0;
5161 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5163 if (pot_left_ptr
== NULL
)
5165 left_part_masked
= 1;
5167 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5169 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5171 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5172 pot_left_ptr
->plain_len
= mask_plain_len
;
5175 if (pot_right_ptr
== NULL
)
5177 right_part_masked
= 1;
5179 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5181 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5183 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5184 pot_right_ptr
->plain_len
= mask_plain_len
;
5187 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5191 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5193 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5195 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5197 // do output the line
5199 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5201 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5203 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5204 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5207 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
)
5211 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5213 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5215 if (pot_ptr
== NULL
)
5219 input_buf
[input_len
] = 0;
5221 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5225 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
)
5231 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5233 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5237 pot_t pot_right_key
;
5239 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5241 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5243 uint weak_hash_found
= 0;
5245 if (pot_right_ptr
== NULL
)
5247 // special case, if "weak hash"
5249 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5251 weak_hash_found
= 1;
5253 // we just need that pot_right_ptr is not a NULL pointer
5255 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5259 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5261 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5266 // ... at least one part was not cracked
5270 input_buf
[input_len
] = 0;
5272 // only show the hash part which is still not cracked
5274 uint user_len
= input_len
- 32;
5276 char *hash_output
= (char *) mymalloc (33);
5278 memcpy (hash_output
, input_buf
, input_len
);
5280 if (pot_left_ptr
!= NULL
)
5282 // only show right part (because left part was already found)
5284 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5286 hash_output
[user_len
+ 16] = 0;
5289 if (pot_right_ptr
!= NULL
)
5291 // only show left part (because right part was already found)
5293 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5295 hash_output
[user_len
+ 16] = 0;
5298 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5300 myfree (hash_output
);
5302 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5305 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5307 uint opencl_platforms_filter
= 0;
5309 if (opencl_platforms
)
5311 char *platforms
= strdup (opencl_platforms
);
5313 char *next
= strtok (platforms
, ",");
5317 int platform
= atoi (next
);
5319 if (platform
< 1 || platform
> 32)
5321 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5326 opencl_platforms_filter
|= 1 << (platform
- 1);
5328 } while ((next
= strtok (NULL
, ",")) != NULL
);
5334 opencl_platforms_filter
= -1;
5337 return opencl_platforms_filter
;
5340 u32
setup_devices_filter (char *opencl_devices
)
5342 u32 devices_filter
= 0;
5346 char *devices
= strdup (opencl_devices
);
5348 char *next
= strtok (devices
, ",");
5352 int device_id
= atoi (next
);
5354 if (device_id
< 1 || device_id
> 32)
5356 log_error ("ERROR: invalid device_id %u specified", device_id
);
5361 devices_filter
|= 1 << (device_id
- 1);
5363 } while ((next
= strtok (NULL
, ",")) != NULL
);
5369 devices_filter
= -1;
5372 return devices_filter
;
5375 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5377 cl_device_type device_types_filter
= 0;
5379 if (opencl_device_types
)
5381 char *device_types
= strdup (opencl_device_types
);
5383 char *next
= strtok (device_types
, ",");
5387 int device_type
= atoi (next
);
5389 if (device_type
< 1 || device_type
> 3)
5391 log_error ("ERROR: invalid device_type %u specified", device_type
);
5396 device_types_filter
|= 1 << device_type
;
5398 } while ((next
= strtok (NULL
, ",")) != NULL
);
5400 free (device_types
);
5404 // Do not use CPU by default, this often reduces GPU performance because
5405 // the CPU is too busy to handle GPU synchronization
5407 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5410 return device_types_filter
;
5413 u32
get_random_num (const u32 min
, const u32 max
)
5415 if (min
== max
) return (min
);
5417 return ((rand () % (max
- min
)) + min
);
5420 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5422 u32 quotient
= dividend
/ divisor
;
5424 if (dividend
% divisor
) quotient
++;
5429 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5431 u64 quotient
= dividend
/ divisor
;
5433 if (dividend
% divisor
) quotient
++;
5438 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5440 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5441 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5443 if (tm
->tm_year
- 70)
5445 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5446 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5448 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5450 else if (tm
->tm_yday
)
5452 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5453 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5455 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5457 else if (tm
->tm_hour
)
5459 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5460 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5462 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5464 else if (tm
->tm_min
)
5466 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5467 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5469 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5473 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5475 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5479 void format_speed_display (float val
, char *buf
, size_t len
)
5490 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5501 /* generate output */
5505 snprintf (buf
, len
- 1, "%.0f ", val
);
5509 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5513 void lowercase (u8
*buf
, int len
)
5515 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5518 void uppercase (u8
*buf
, int len
)
5520 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5523 int fgetl (FILE *fp
, char *line_buf
)
5529 const int c
= fgetc (fp
);
5531 if (c
== EOF
) break;
5533 line_buf
[line_len
] = (char) c
;
5537 if (line_len
== HCBUFSIZ
) line_len
--;
5539 if (c
== '\n') break;
5542 if (line_len
== 0) return 0;
5544 if (line_buf
[line_len
- 1] == '\n')
5548 line_buf
[line_len
] = 0;
5551 if (line_len
== 0) return 0;
5553 if (line_buf
[line_len
- 1] == '\r')
5557 line_buf
[line_len
] = 0;
5563 int in_superchop (char *buf
)
5565 int len
= strlen (buf
);
5569 if (buf
[len
- 1] == '\n')
5576 if (buf
[len
- 1] == '\r')
5591 char **scan_directory (const char *path
)
5593 char *tmp_path
= mystrdup (path
);
5595 size_t tmp_path_len
= strlen (tmp_path
);
5597 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5599 tmp_path
[tmp_path_len
- 1] = 0;
5601 tmp_path_len
= strlen (tmp_path
);
5604 char **files
= NULL
;
5610 if ((d
= opendir (tmp_path
)) != NULL
)
5616 memset (&e
, 0, sizeof (e
));
5617 struct dirent
*de
= NULL
;
5619 if (readdir_r (d
, &e
, &de
) != 0)
5621 log_error ("ERROR: readdir_r() failed");
5626 if (de
== NULL
) break;
5630 while ((de
= readdir (d
)) != NULL
)
5633 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5635 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5637 char *path_file
= (char *) mymalloc (path_size
+ 1);
5639 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5641 path_file
[path_size
] = 0;
5645 if ((d_test
= opendir (path_file
)) != NULL
)
5653 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5657 files
[num_files
- 1] = path_file
;
5663 else if (errno
== ENOTDIR
)
5665 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5669 files
[num_files
- 1] = mystrdup (path
);
5672 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5676 files
[num_files
- 1] = NULL
;
5683 int count_dictionaries (char **dictionary_files
)
5685 if (dictionary_files
== NULL
) return 0;
5689 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5697 char *stroptitype (const uint opti_type
)
5701 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5702 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5703 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5704 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5705 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5706 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5707 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5708 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5709 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5710 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5711 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5712 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5713 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5714 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5715 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5716 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5717 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5718 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5719 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5725 char *strparser (const uint parser_status
)
5727 switch (parser_status
)
5729 case PARSER_OK
: return ((char *) PA_000
); break;
5730 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5731 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5732 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5733 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5734 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5735 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5736 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5737 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5738 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5739 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5740 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5741 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5742 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5743 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5744 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5745 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5748 return ((char *) PA_255
);
5751 char *strhashtype (const uint hash_mode
)
5755 case 0: return ((char *) HT_00000
); break;
5756 case 10: return ((char *) HT_00010
); break;
5757 case 11: return ((char *) HT_00011
); break;
5758 case 12: return ((char *) HT_00012
); break;
5759 case 20: return ((char *) HT_00020
); break;
5760 case 21: return ((char *) HT_00021
); break;
5761 case 22: return ((char *) HT_00022
); break;
5762 case 23: return ((char *) HT_00023
); break;
5763 case 30: return ((char *) HT_00030
); break;
5764 case 40: return ((char *) HT_00040
); break;
5765 case 50: return ((char *) HT_00050
); break;
5766 case 60: return ((char *) HT_00060
); break;
5767 case 100: return ((char *) HT_00100
); break;
5768 case 101: return ((char *) HT_00101
); break;
5769 case 110: return ((char *) HT_00110
); break;
5770 case 111: return ((char *) HT_00111
); break;
5771 case 112: return ((char *) HT_00112
); break;
5772 case 120: return ((char *) HT_00120
); break;
5773 case 121: return ((char *) HT_00121
); break;
5774 case 122: return ((char *) HT_00122
); break;
5775 case 124: return ((char *) HT_00124
); break;
5776 case 125: return ((char *) HT_00125
); break;
5777 case 130: return ((char *) HT_00130
); break;
5778 case 131: return ((char *) HT_00131
); break;
5779 case 132: return ((char *) HT_00132
); break;
5780 case 133: return ((char *) HT_00133
); break;
5781 case 140: return ((char *) HT_00140
); break;
5782 case 141: return ((char *) HT_00141
); break;
5783 case 150: return ((char *) HT_00150
); break;
5784 case 160: return ((char *) HT_00160
); break;
5785 case 190: return ((char *) HT_00190
); break;
5786 case 200: return ((char *) HT_00200
); break;
5787 case 300: return ((char *) HT_00300
); break;
5788 case 400: return ((char *) HT_00400
); break;
5789 case 500: return ((char *) HT_00500
); break;
5790 case 501: return ((char *) HT_00501
); break;
5791 case 900: return ((char *) HT_00900
); break;
5792 case 910: return ((char *) HT_00910
); break;
5793 case 1000: return ((char *) HT_01000
); break;
5794 case 1100: return ((char *) HT_01100
); break;
5795 case 1400: return ((char *) HT_01400
); break;
5796 case 1410: return ((char *) HT_01410
); break;
5797 case 1420: return ((char *) HT_01420
); break;
5798 case 1421: return ((char *) HT_01421
); break;
5799 case 1430: return ((char *) HT_01430
); break;
5800 case 1440: return ((char *) HT_01440
); break;
5801 case 1441: return ((char *) HT_01441
); break;
5802 case 1450: return ((char *) HT_01450
); break;
5803 case 1460: return ((char *) HT_01460
); break;
5804 case 1500: return ((char *) HT_01500
); break;
5805 case 1600: return ((char *) HT_01600
); break;
5806 case 1700: return ((char *) HT_01700
); break;
5807 case 1710: return ((char *) HT_01710
); break;
5808 case 1711: return ((char *) HT_01711
); break;
5809 case 1720: return ((char *) HT_01720
); break;
5810 case 1722: return ((char *) HT_01722
); break;
5811 case 1730: return ((char *) HT_01730
); break;
5812 case 1731: return ((char *) HT_01731
); break;
5813 case 1740: return ((char *) HT_01740
); break;
5814 case 1750: return ((char *) HT_01750
); break;
5815 case 1760: return ((char *) HT_01760
); break;
5816 case 1800: return ((char *) HT_01800
); break;
5817 case 2100: return ((char *) HT_02100
); break;
5818 case 2400: return ((char *) HT_02400
); break;
5819 case 2410: return ((char *) HT_02410
); break;
5820 case 2500: return ((char *) HT_02500
); break;
5821 case 2600: return ((char *) HT_02600
); break;
5822 case 2611: return ((char *) HT_02611
); break;
5823 case 2612: return ((char *) HT_02612
); break;
5824 case 2711: return ((char *) HT_02711
); break;
5825 case 2811: return ((char *) HT_02811
); break;
5826 case 3000: return ((char *) HT_03000
); break;
5827 case 3100: return ((char *) HT_03100
); break;
5828 case 3200: return ((char *) HT_03200
); break;
5829 case 3710: return ((char *) HT_03710
); break;
5830 case 3711: return ((char *) HT_03711
); break;
5831 case 3800: return ((char *) HT_03800
); break;
5832 case 4300: return ((char *) HT_04300
); break;
5833 case 4400: return ((char *) HT_04400
); break;
5834 case 4500: return ((char *) HT_04500
); break;
5835 case 4700: return ((char *) HT_04700
); break;
5836 case 4800: return ((char *) HT_04800
); break;
5837 case 4900: return ((char *) HT_04900
); break;
5838 case 5000: return ((char *) HT_05000
); break;
5839 case 5100: return ((char *) HT_05100
); break;
5840 case 5200: return ((char *) HT_05200
); break;
5841 case 5300: return ((char *) HT_05300
); break;
5842 case 5400: return ((char *) HT_05400
); break;
5843 case 5500: return ((char *) HT_05500
); break;
5844 case 5600: return ((char *) HT_05600
); break;
5845 case 5700: return ((char *) HT_05700
); break;
5846 case 5800: return ((char *) HT_05800
); break;
5847 case 6000: return ((char *) HT_06000
); break;
5848 case 6100: return ((char *) HT_06100
); break;
5849 case 6211: return ((char *) HT_06211
); break;
5850 case 6212: return ((char *) HT_06212
); break;
5851 case 6213: return ((char *) HT_06213
); break;
5852 case 6221: return ((char *) HT_06221
); break;
5853 case 6222: return ((char *) HT_06222
); break;
5854 case 6223: return ((char *) HT_06223
); break;
5855 case 6231: return ((char *) HT_06231
); break;
5856 case 6232: return ((char *) HT_06232
); break;
5857 case 6233: return ((char *) HT_06233
); break;
5858 case 6241: return ((char *) HT_06241
); break;
5859 case 6242: return ((char *) HT_06242
); break;
5860 case 6243: return ((char *) HT_06243
); break;
5861 case 6300: return ((char *) HT_06300
); break;
5862 case 6400: return ((char *) HT_06400
); break;
5863 case 6500: return ((char *) HT_06500
); break;
5864 case 6600: return ((char *) HT_06600
); break;
5865 case 6700: return ((char *) HT_06700
); break;
5866 case 6800: return ((char *) HT_06800
); break;
5867 case 6900: return ((char *) HT_06900
); break;
5868 case 7100: return ((char *) HT_07100
); break;
5869 case 7200: return ((char *) HT_07200
); break;
5870 case 7300: return ((char *) HT_07300
); break;
5871 case 7400: return ((char *) HT_07400
); break;
5872 case 7500: return ((char *) HT_07500
); break;
5873 case 7600: return ((char *) HT_07600
); break;
5874 case 7700: return ((char *) HT_07700
); break;
5875 case 7800: return ((char *) HT_07800
); break;
5876 case 7900: return ((char *) HT_07900
); break;
5877 case 8000: return ((char *) HT_08000
); break;
5878 case 8100: return ((char *) HT_08100
); break;
5879 case 8200: return ((char *) HT_08200
); break;
5880 case 8300: return ((char *) HT_08300
); break;
5881 case 8400: return ((char *) HT_08400
); break;
5882 case 8500: return ((char *) HT_08500
); break;
5883 case 8600: return ((char *) HT_08600
); break;
5884 case 8700: return ((char *) HT_08700
); break;
5885 case 8800: return ((char *) HT_08800
); break;
5886 case 8900: return ((char *) HT_08900
); break;
5887 case 9000: return ((char *) HT_09000
); break;
5888 case 9100: return ((char *) HT_09100
); break;
5889 case 9200: return ((char *) HT_09200
); break;
5890 case 9300: return ((char *) HT_09300
); break;
5891 case 9400: return ((char *) HT_09400
); break;
5892 case 9500: return ((char *) HT_09500
); break;
5893 case 9600: return ((char *) HT_09600
); break;
5894 case 9700: return ((char *) HT_09700
); break;
5895 case 9710: return ((char *) HT_09710
); break;
5896 case 9720: return ((char *) HT_09720
); break;
5897 case 9800: return ((char *) HT_09800
); break;
5898 case 9810: return ((char *) HT_09810
); break;
5899 case 9820: return ((char *) HT_09820
); break;
5900 case 9900: return ((char *) HT_09900
); break;
5901 case 10000: return ((char *) HT_10000
); break;
5902 case 10100: return ((char *) HT_10100
); break;
5903 case 10200: return ((char *) HT_10200
); break;
5904 case 10300: return ((char *) HT_10300
); break;
5905 case 10400: return ((char *) HT_10400
); break;
5906 case 10410: return ((char *) HT_10410
); break;
5907 case 10420: return ((char *) HT_10420
); break;
5908 case 10500: return ((char *) HT_10500
); break;
5909 case 10600: return ((char *) HT_10600
); break;
5910 case 10700: return ((char *) HT_10700
); break;
5911 case 10800: return ((char *) HT_10800
); break;
5912 case 10900: return ((char *) HT_10900
); break;
5913 case 11000: return ((char *) HT_11000
); break;
5914 case 11100: return ((char *) HT_11100
); break;
5915 case 11200: return ((char *) HT_11200
); break;
5916 case 11300: return ((char *) HT_11300
); break;
5917 case 11400: return ((char *) HT_11400
); break;
5918 case 11500: return ((char *) HT_11500
); break;
5919 case 11600: return ((char *) HT_11600
); break;
5920 case 11700: return ((char *) HT_11700
); break;
5921 case 11800: return ((char *) HT_11800
); break;
5922 case 11900: return ((char *) HT_11900
); break;
5923 case 12000: return ((char *) HT_12000
); break;
5924 case 12100: return ((char *) HT_12100
); break;
5925 case 12200: return ((char *) HT_12200
); break;
5926 case 12300: return ((char *) HT_12300
); break;
5927 case 12400: return ((char *) HT_12400
); break;
5928 case 12500: return ((char *) HT_12500
); break;
5929 case 12600: return ((char *) HT_12600
); break;
5930 case 12700: return ((char *) HT_12700
); break;
5931 case 12800: return ((char *) HT_12800
); break;
5932 case 12900: return ((char *) HT_12900
); break;
5933 case 13000: return ((char *) HT_13000
); break;
5934 case 13100: return ((char *) HT_13100
); break;
5935 case 13200: return ((char *) HT_13200
); break;
5936 case 13300: return ((char *) HT_13300
); break;
5937 case 13400: return ((char *) HT_13400
); break;
5938 case 13500: return ((char *) HT_13500
); break;
5939 case 13600: return ((char *) HT_13600
); break;
5940 case 13711: return ((char *) HT_13711
); break;
5941 case 13712: return ((char *) HT_13712
); break;
5942 case 13713: return ((char *) HT_13713
); break;
5943 case 13721: return ((char *) HT_13721
); break;
5944 case 13722: return ((char *) HT_13722
); break;
5945 case 13723: return ((char *) HT_13723
); break;
5946 case 13731: return ((char *) HT_13731
); break;
5947 case 13732: return ((char *) HT_13732
); break;
5948 case 13733: return ((char *) HT_13733
); break;
5949 case 13741: return ((char *) HT_13741
); break;
5950 case 13742: return ((char *) HT_13742
); break;
5951 case 13743: return ((char *) HT_13743
); break;
5952 case 13751: return ((char *) HT_13751
); break;
5953 case 13752: return ((char *) HT_13752
); break;
5954 case 13753: return ((char *) HT_13753
); break;
5955 case 13761: return ((char *) HT_13761
); break;
5956 case 13762: return ((char *) HT_13762
); break;
5957 case 13763: return ((char *) HT_13763
); break;
5960 return ((char *) "Unknown");
5963 char *strstatus (const uint devices_status
)
5965 switch (devices_status
)
5967 case STATUS_INIT
: return ((char *) ST_0000
); break;
5968 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5969 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5970 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5971 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5972 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5973 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5974 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5975 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5976 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5977 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5980 return ((char *) "Unknown");
5983 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
5985 uint hash_type
= data
.hash_type
;
5986 uint hash_mode
= data
.hash_mode
;
5987 uint salt_type
= data
.salt_type
;
5988 uint opts_type
= data
.opts_type
;
5989 uint opti_type
= data
.opti_type
;
5990 uint dgst_size
= data
.dgst_size
;
5992 char *hashfile
= data
.hashfile
;
5996 uint digest_buf
[64] = { 0 };
5998 u64
*digest_buf64
= (u64
*) digest_buf
;
6000 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6002 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6004 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6010 case HASH_TYPE_DESCRYPT
:
6011 FP (digest_buf
[1], digest_buf
[0], tt
);
6014 case HASH_TYPE_DESRACF
:
6015 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6016 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6018 FP (digest_buf
[1], digest_buf
[0], tt
);
6022 FP (digest_buf
[1], digest_buf
[0], tt
);
6025 case HASH_TYPE_NETNTLM
:
6026 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6027 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6028 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6029 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6031 FP (digest_buf
[1], digest_buf
[0], tt
);
6032 FP (digest_buf
[3], digest_buf
[2], tt
);
6035 case HASH_TYPE_BSDICRYPT
:
6036 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6037 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6039 FP (digest_buf
[1], digest_buf
[0], tt
);
6044 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6049 digest_buf
[0] += MD4M_A
;
6050 digest_buf
[1] += MD4M_B
;
6051 digest_buf
[2] += MD4M_C
;
6052 digest_buf
[3] += MD4M_D
;
6056 digest_buf
[0] += MD5M_A
;
6057 digest_buf
[1] += MD5M_B
;
6058 digest_buf
[2] += MD5M_C
;
6059 digest_buf
[3] += MD5M_D
;
6062 case HASH_TYPE_SHA1
:
6063 digest_buf
[0] += SHA1M_A
;
6064 digest_buf
[1] += SHA1M_B
;
6065 digest_buf
[2] += SHA1M_C
;
6066 digest_buf
[3] += SHA1M_D
;
6067 digest_buf
[4] += SHA1M_E
;
6070 case HASH_TYPE_SHA256
:
6071 digest_buf
[0] += SHA256M_A
;
6072 digest_buf
[1] += SHA256M_B
;
6073 digest_buf
[2] += SHA256M_C
;
6074 digest_buf
[3] += SHA256M_D
;
6075 digest_buf
[4] += SHA256M_E
;
6076 digest_buf
[5] += SHA256M_F
;
6077 digest_buf
[6] += SHA256M_G
;
6078 digest_buf
[7] += SHA256M_H
;
6081 case HASH_TYPE_SHA384
:
6082 digest_buf64
[0] += SHA384M_A
;
6083 digest_buf64
[1] += SHA384M_B
;
6084 digest_buf64
[2] += SHA384M_C
;
6085 digest_buf64
[3] += SHA384M_D
;
6086 digest_buf64
[4] += SHA384M_E
;
6087 digest_buf64
[5] += SHA384M_F
;
6088 digest_buf64
[6] += 0;
6089 digest_buf64
[7] += 0;
6092 case HASH_TYPE_SHA512
:
6093 digest_buf64
[0] += SHA512M_A
;
6094 digest_buf64
[1] += SHA512M_B
;
6095 digest_buf64
[2] += SHA512M_C
;
6096 digest_buf64
[3] += SHA512M_D
;
6097 digest_buf64
[4] += SHA512M_E
;
6098 digest_buf64
[5] += SHA512M_F
;
6099 digest_buf64
[6] += SHA512M_G
;
6100 digest_buf64
[7] += SHA512M_H
;
6105 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6107 if (dgst_size
== DGST_SIZE_4_2
)
6109 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6111 else if (dgst_size
== DGST_SIZE_4_4
)
6113 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6115 else if (dgst_size
== DGST_SIZE_4_5
)
6117 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6119 else if (dgst_size
== DGST_SIZE_4_6
)
6121 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6123 else if (dgst_size
== DGST_SIZE_4_8
)
6125 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6127 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6129 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6131 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6133 else if (hash_type
== HASH_TYPE_SHA384
)
6135 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6137 else if (hash_type
== HASH_TYPE_SHA512
)
6139 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6141 else if (hash_type
== HASH_TYPE_GOST
)
6143 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6146 else if (dgst_size
== DGST_SIZE_4_64
)
6148 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6150 else if (dgst_size
== DGST_SIZE_8_25
)
6152 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6156 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6157 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6158 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6164 memset (&salt
, 0, sizeof (salt_t
));
6166 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6168 char *ptr
= (char *) salt
.salt_buf
;
6170 uint len
= salt
.salt_len
;
6172 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6178 case HASH_TYPE_NETNTLM
:
6180 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6181 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6183 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6189 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6191 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6199 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6201 uint max
= salt
.salt_len
/ 4;
6205 for (uint i
= 0; i
< max
; i
++)
6207 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6211 if (opts_type
& OPTS_TYPE_ST_HEX
)
6213 char tmp
[64] = { 0 };
6215 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6217 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6222 memcpy (ptr
, tmp
, len
);
6225 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6227 memset (ptr
+ len
, 0, memset_size
);
6229 salt
.salt_len
= len
;
6233 // some modes require special encoding
6236 uint out_buf_plain
[256] = { 0 };
6237 uint out_buf_salt
[256] = { 0 };
6239 char tmp_buf
[1024] = { 0 };
6241 char *ptr_plain
= (char *) out_buf_plain
;
6242 char *ptr_salt
= (char *) out_buf_salt
;
6244 if (hash_mode
== 22)
6246 char username
[30] = { 0 };
6248 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6250 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6252 u16
*ptr
= (u16
*) digest_buf
;
6254 tmp_buf
[ 0] = sig
[0];
6255 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6256 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6257 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6258 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6259 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6260 tmp_buf
[ 6] = sig
[1];
6261 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6262 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6263 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6264 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6265 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6266 tmp_buf
[12] = sig
[2];
6267 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6268 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6269 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6270 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6271 tmp_buf
[17] = sig
[3];
6272 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6273 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6274 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6275 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6276 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6277 tmp_buf
[23] = sig
[4];
6278 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6279 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6280 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6281 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6282 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6283 tmp_buf
[29] = sig
[5];
6285 snprintf (out_buf
, len
-1, "%s:%s",
6289 else if (hash_mode
== 23)
6291 // do not show the skyper part in output
6293 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6295 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6297 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6304 else if (hash_mode
== 101)
6306 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6308 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6309 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6310 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6311 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6312 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6314 memcpy (tmp_buf
, digest_buf
, 20);
6316 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6318 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6320 else if (hash_mode
== 111)
6322 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6324 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6325 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6326 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6327 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6328 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6330 memcpy (tmp_buf
, digest_buf
, 20);
6331 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6333 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6335 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6337 else if ((hash_mode
== 122) || (hash_mode
== 125))
6339 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6340 (char *) salt
.salt_buf
,
6347 else if (hash_mode
== 124)
6349 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6350 (char *) salt
.salt_buf
,
6357 else if (hash_mode
== 131)
6359 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6360 (char *) salt
.salt_buf
,
6368 else if (hash_mode
== 132)
6370 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6371 (char *) salt
.salt_buf
,
6378 else if (hash_mode
== 133)
6380 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6382 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6383 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6384 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6385 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6386 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6388 memcpy (tmp_buf
, digest_buf
, 20);
6390 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6392 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6394 else if (hash_mode
== 141)
6396 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6398 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6400 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6402 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6404 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6405 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6406 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6407 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6408 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6410 memcpy (tmp_buf
, digest_buf
, 20);
6412 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6416 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6418 else if (hash_mode
== 400)
6420 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6422 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6423 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6424 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6425 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6427 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6429 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6431 else if (hash_mode
== 500)
6433 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6435 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6436 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6437 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6438 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6440 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6442 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6444 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6448 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6451 else if (hash_mode
== 501)
6453 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6455 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6456 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6458 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6460 else if (hash_mode
== 1421)
6462 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6464 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6480 else if (hash_mode
== 1441)
6482 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6484 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6486 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6488 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6490 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6491 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6492 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6493 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6494 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6495 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6496 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6497 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6499 memcpy (tmp_buf
, digest_buf
, 32);
6501 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6505 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6507 else if (hash_mode
== 1500)
6509 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6510 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6511 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6512 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6513 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6515 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6517 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6519 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6520 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6522 memcpy (tmp_buf
, digest_buf
, 8);
6524 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6526 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6530 else if (hash_mode
== 1600)
6532 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6534 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6535 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6536 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6537 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6539 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6541 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6543 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6547 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6550 else if (hash_mode
== 1711)
6552 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6554 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6555 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6556 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6557 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6558 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6559 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6560 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6561 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6563 memcpy (tmp_buf
, digest_buf
, 64);
6564 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6566 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6568 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6570 else if (hash_mode
== 1722)
6572 uint
*ptr
= digest_buf
;
6574 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6575 (unsigned char *) salt
.salt_buf
,
6585 else if (hash_mode
== 1731)
6587 uint
*ptr
= digest_buf
;
6589 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6590 (unsigned char *) salt
.salt_buf
,
6600 else if (hash_mode
== 1800)
6604 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6605 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6606 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6607 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6608 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6609 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6610 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6611 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6613 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6615 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6617 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6621 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6624 else if (hash_mode
== 2100)
6628 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6630 salt
.salt_iter
+ 1);
6632 uint signature_len
= strlen (out_buf
);
6634 pos
+= signature_len
;
6635 len
-= signature_len
;
6637 char *salt_ptr
= (char *) salt
.salt_buf
;
6639 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6641 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6642 byte_swap_32 (digest_buf
[0]),
6643 byte_swap_32 (digest_buf
[1]),
6644 byte_swap_32 (digest_buf
[2]),
6645 byte_swap_32 (digest_buf
[3]));
6647 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6649 memcpy (tmp_buf
, digest_buf
, 16);
6651 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6653 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6654 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6655 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6656 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6658 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6659 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6660 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6661 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6663 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6664 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6665 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6666 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6668 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6669 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6670 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6671 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6673 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6674 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6675 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6676 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6680 else if (hash_mode
== 2500)
6682 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6684 wpa_t
*wpa
= &wpas
[salt_pos
];
6686 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6687 (char *) salt
.salt_buf
,
6701 else if (hash_mode
== 4400)
6703 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6704 byte_swap_32 (digest_buf
[0]),
6705 byte_swap_32 (digest_buf
[1]),
6706 byte_swap_32 (digest_buf
[2]),
6707 byte_swap_32 (digest_buf
[3]));
6709 else if (hash_mode
== 4700)
6711 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6712 byte_swap_32 (digest_buf
[0]),
6713 byte_swap_32 (digest_buf
[1]),
6714 byte_swap_32 (digest_buf
[2]),
6715 byte_swap_32 (digest_buf
[3]),
6716 byte_swap_32 (digest_buf
[4]));
6718 else if (hash_mode
== 4800)
6720 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6722 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6727 byte_swap_32 (salt
.salt_buf
[0]),
6728 byte_swap_32 (salt
.salt_buf
[1]),
6729 byte_swap_32 (salt
.salt_buf
[2]),
6730 byte_swap_32 (salt
.salt_buf
[3]),
6733 else if (hash_mode
== 4900)
6735 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6736 byte_swap_32 (digest_buf
[0]),
6737 byte_swap_32 (digest_buf
[1]),
6738 byte_swap_32 (digest_buf
[2]),
6739 byte_swap_32 (digest_buf
[3]),
6740 byte_swap_32 (digest_buf
[4]));
6742 else if (hash_mode
== 5100)
6744 snprintf (out_buf
, len
-1, "%08x%08x",
6748 else if (hash_mode
== 5200)
6750 snprintf (out_buf
, len
-1, "%s", hashfile
);
6752 else if (hash_mode
== 5300)
6754 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6756 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6758 int buf_len
= len
-1;
6762 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6764 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6766 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6768 snprintf (out_buf
, buf_len
, ":");
6774 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6782 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6784 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6786 if ((i
== 0) || (i
== 5))
6788 snprintf (out_buf
, buf_len
, ":");
6794 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6802 for (uint i
= 0; i
< 4; i
++)
6806 snprintf (out_buf
, buf_len
, ":");
6812 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6818 else if (hash_mode
== 5400)
6820 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6822 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6824 int buf_len
= len
-1;
6828 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6830 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6832 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6834 snprintf (out_buf
, buf_len
, ":");
6840 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6848 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6850 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6852 if ((i
== 0) || (i
== 5))
6854 snprintf (out_buf
, buf_len
, ":");
6860 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6868 for (uint i
= 0; i
< 5; i
++)
6872 snprintf (out_buf
, buf_len
, ":");
6878 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6884 else if (hash_mode
== 5500)
6886 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6888 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6890 char user_buf
[64] = { 0 };
6891 char domain_buf
[64] = { 0 };
6892 char srvchall_buf
[1024] = { 0 };
6893 char clichall_buf
[1024] = { 0 };
6895 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6897 char *ptr
= (char *) netntlm
->userdomain_buf
;
6899 user_buf
[i
] = ptr
[j
];
6902 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6904 char *ptr
= (char *) netntlm
->userdomain_buf
;
6906 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6909 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6911 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6913 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6916 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6918 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6920 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6923 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6931 byte_swap_32 (salt
.salt_buf_pc
[0]),
6932 byte_swap_32 (salt
.salt_buf_pc
[1]),
6935 else if (hash_mode
== 5600)
6937 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6939 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6941 char user_buf
[64] = { 0 };
6942 char domain_buf
[64] = { 0 };
6943 char srvchall_buf
[1024] = { 0 };
6944 char clichall_buf
[1024] = { 0 };
6946 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6948 char *ptr
= (char *) netntlm
->userdomain_buf
;
6950 user_buf
[i
] = ptr
[j
];
6953 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6955 char *ptr
= (char *) netntlm
->userdomain_buf
;
6957 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6960 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6962 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6964 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6967 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6969 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6971 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6974 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6984 else if (hash_mode
== 5700)
6986 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6988 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6989 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6990 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6991 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6992 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6993 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6994 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6995 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6997 memcpy (tmp_buf
, digest_buf
, 32);
6999 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7003 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7005 else if (hash_mode
== 5800)
7007 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7008 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7009 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7010 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7011 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7013 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7020 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7022 snprintf (out_buf
, len
-1, "%s", hashfile
);
7024 else if (hash_mode
== 6300)
7026 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7028 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7029 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7030 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7031 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7033 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7035 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7037 else if (hash_mode
== 6400)
7039 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7041 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7043 else if (hash_mode
== 6500)
7045 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7047 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7049 else if (hash_mode
== 6600)
7051 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7053 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7055 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7056 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7058 uint buf_len
= len
- 1;
7060 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7063 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7065 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7070 else if (hash_mode
== 6700)
7072 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7074 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7076 else if (hash_mode
== 6800)
7078 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7080 else if (hash_mode
== 7100)
7082 uint
*ptr
= digest_buf
;
7084 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7086 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7088 uint esalt
[8] = { 0 };
7090 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7091 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7092 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7093 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7094 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7095 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7096 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7097 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7099 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",
7100 SIGNATURE_SHA512OSX
,
7102 esalt
[ 0], esalt
[ 1],
7103 esalt
[ 2], esalt
[ 3],
7104 esalt
[ 4], esalt
[ 5],
7105 esalt
[ 6], esalt
[ 7],
7113 ptr
[15], ptr
[14]);
7115 else if (hash_mode
== 7200)
7117 uint
*ptr
= digest_buf
;
7119 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7121 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7125 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7127 len_used
= strlen (out_buf
);
7129 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7131 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7133 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7136 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",
7144 ptr
[15], ptr
[14]);
7146 else if (hash_mode
== 7300)
7148 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7150 rakp_t
*rakp
= &rakps
[salt_pos
];
7152 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7154 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7157 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7164 else if (hash_mode
== 7400)
7166 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7168 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7169 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7170 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7171 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7172 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7173 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7174 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7175 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7177 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7179 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7181 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7185 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7188 else if (hash_mode
== 7500)
7190 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7192 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7194 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7195 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7197 char data
[128] = { 0 };
7199 char *ptr_data
= data
;
7201 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7203 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7206 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7208 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7213 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7215 (char *) krb5pa
->user
,
7216 (char *) krb5pa
->realm
,
7217 (char *) krb5pa
->salt
,
7220 else if (hash_mode
== 7700)
7222 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7223 (char *) salt
.salt_buf
,
7227 else if (hash_mode
== 7800)
7229 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7230 (char *) salt
.salt_buf
,
7237 else if (hash_mode
== 7900)
7239 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7243 char *tmp
= (char *) salt
.salt_buf_pc
;
7245 ptr_plain
[42] = tmp
[0];
7251 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7253 else if (hash_mode
== 8000)
7255 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7256 (unsigned char *) salt
.salt_buf
,
7266 else if (hash_mode
== 8100)
7268 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7269 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7271 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7272 (unsigned char *) salt
.salt_buf
,
7279 else if (hash_mode
== 8200)
7281 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7283 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7285 char data_buf
[4096] = { 0 };
7287 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7289 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7292 data_buf
[cloudkey
->data_len
* 2] = 0;
7294 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7295 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7296 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7297 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7298 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7299 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7300 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7301 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7303 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7304 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7305 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7306 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7308 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7324 else if (hash_mode
== 8300)
7326 char digest_buf_c
[34] = { 0 };
7328 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7329 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7330 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7331 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7332 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7334 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7336 digest_buf_c
[32] = 0;
7340 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7342 char domain_buf_c
[33] = { 0 };
7344 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7346 for (uint i
= 0; i
< salt_pc_len
; i
++)
7348 const char next
= domain_buf_c
[i
];
7350 domain_buf_c
[i
] = '.';
7355 domain_buf_c
[salt_pc_len
] = 0;
7359 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7361 else if (hash_mode
== 8500)
7363 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7365 else if (hash_mode
== 2612)
7367 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7369 (char *) salt
.salt_buf
,
7375 else if (hash_mode
== 3711)
7377 char *salt_ptr
= (char *) salt
.salt_buf
;
7379 salt_ptr
[salt
.salt_len
- 1] = 0;
7381 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7382 SIGNATURE_MEDIAWIKI_B
,
7389 else if (hash_mode
== 8800)
7391 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7393 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7395 char tmp
[3073] = { 0 };
7397 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7399 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7404 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7405 SIGNATURE_ANDROIDFDE
,
7406 byte_swap_32 (salt
.salt_buf
[0]),
7407 byte_swap_32 (salt
.salt_buf
[1]),
7408 byte_swap_32 (salt
.salt_buf
[2]),
7409 byte_swap_32 (salt
.salt_buf
[3]),
7410 byte_swap_32 (digest_buf
[0]),
7411 byte_swap_32 (digest_buf
[1]),
7412 byte_swap_32 (digest_buf
[2]),
7413 byte_swap_32 (digest_buf
[3]),
7416 else if (hash_mode
== 8900)
7418 uint N
= salt
.scrypt_N
;
7419 uint r
= salt
.scrypt_r
;
7420 uint p
= salt
.scrypt_p
;
7422 char base64_salt
[32] = { 0 };
7424 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7426 memset (tmp_buf
, 0, 46);
7428 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7429 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7430 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7431 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7432 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7433 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7434 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7435 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7436 digest_buf
[8] = 0; // needed for base64_encode ()
7438 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7440 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7448 else if (hash_mode
== 9000)
7450 snprintf (out_buf
, len
-1, "%s", hashfile
);
7452 else if (hash_mode
== 9200)
7456 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7458 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7460 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7464 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7465 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7466 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7467 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7468 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7469 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7470 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7471 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7472 digest_buf
[8] = 0; // needed for base64_encode ()
7474 char tmp_buf
[64] = { 0 };
7476 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7477 tmp_buf
[43] = 0; // cut it here
7481 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7483 else if (hash_mode
== 9300)
7485 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7486 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7487 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7488 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7489 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7490 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7491 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7492 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7493 digest_buf
[8] = 0; // needed for base64_encode ()
7495 char tmp_buf
[64] = { 0 };
7497 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7498 tmp_buf
[43] = 0; // cut it here
7500 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7502 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7504 else if (hash_mode
== 9400)
7506 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7508 office2007_t
*office2007
= &office2007s
[salt_pos
];
7510 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7511 SIGNATURE_OFFICE2007
,
7514 office2007
->keySize
,
7520 office2007
->encryptedVerifier
[0],
7521 office2007
->encryptedVerifier
[1],
7522 office2007
->encryptedVerifier
[2],
7523 office2007
->encryptedVerifier
[3],
7524 office2007
->encryptedVerifierHash
[0],
7525 office2007
->encryptedVerifierHash
[1],
7526 office2007
->encryptedVerifierHash
[2],
7527 office2007
->encryptedVerifierHash
[3],
7528 office2007
->encryptedVerifierHash
[4]);
7530 else if (hash_mode
== 9500)
7532 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7534 office2010_t
*office2010
= &office2010s
[salt_pos
];
7536 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,
7542 office2010
->encryptedVerifier
[0],
7543 office2010
->encryptedVerifier
[1],
7544 office2010
->encryptedVerifier
[2],
7545 office2010
->encryptedVerifier
[3],
7546 office2010
->encryptedVerifierHash
[0],
7547 office2010
->encryptedVerifierHash
[1],
7548 office2010
->encryptedVerifierHash
[2],
7549 office2010
->encryptedVerifierHash
[3],
7550 office2010
->encryptedVerifierHash
[4],
7551 office2010
->encryptedVerifierHash
[5],
7552 office2010
->encryptedVerifierHash
[6],
7553 office2010
->encryptedVerifierHash
[7]);
7555 else if (hash_mode
== 9600)
7557 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7559 office2013_t
*office2013
= &office2013s
[salt_pos
];
7561 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,
7567 office2013
->encryptedVerifier
[0],
7568 office2013
->encryptedVerifier
[1],
7569 office2013
->encryptedVerifier
[2],
7570 office2013
->encryptedVerifier
[3],
7571 office2013
->encryptedVerifierHash
[0],
7572 office2013
->encryptedVerifierHash
[1],
7573 office2013
->encryptedVerifierHash
[2],
7574 office2013
->encryptedVerifierHash
[3],
7575 office2013
->encryptedVerifierHash
[4],
7576 office2013
->encryptedVerifierHash
[5],
7577 office2013
->encryptedVerifierHash
[6],
7578 office2013
->encryptedVerifierHash
[7]);
7580 else if (hash_mode
== 9700)
7582 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7584 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7586 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7587 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7588 byte_swap_32 (salt
.salt_buf
[0]),
7589 byte_swap_32 (salt
.salt_buf
[1]),
7590 byte_swap_32 (salt
.salt_buf
[2]),
7591 byte_swap_32 (salt
.salt_buf
[3]),
7592 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7593 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7594 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7595 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7596 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7597 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7598 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7599 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7601 else if (hash_mode
== 9710)
7603 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7605 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7607 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7608 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7609 byte_swap_32 (salt
.salt_buf
[0]),
7610 byte_swap_32 (salt
.salt_buf
[1]),
7611 byte_swap_32 (salt
.salt_buf
[2]),
7612 byte_swap_32 (salt
.salt_buf
[3]),
7613 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7614 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7615 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7616 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7617 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7618 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7619 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7620 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7622 else if (hash_mode
== 9720)
7624 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7626 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7628 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7630 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7631 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7632 byte_swap_32 (salt
.salt_buf
[0]),
7633 byte_swap_32 (salt
.salt_buf
[1]),
7634 byte_swap_32 (salt
.salt_buf
[2]),
7635 byte_swap_32 (salt
.salt_buf
[3]),
7636 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7637 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7638 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7639 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7640 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7641 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7642 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7643 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7650 else if (hash_mode
== 9800)
7652 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7654 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7656 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7657 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7662 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7663 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7664 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7665 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7666 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7667 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7668 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7669 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7670 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7672 else if (hash_mode
== 9810)
7674 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7676 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7678 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7679 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7684 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7685 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7686 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7687 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7688 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7689 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7690 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7691 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7692 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7694 else if (hash_mode
== 9820)
7696 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7698 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7700 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7702 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7703 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7708 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7709 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7710 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7711 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7712 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7713 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7714 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7715 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7716 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7723 else if (hash_mode
== 10000)
7727 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7729 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7731 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7735 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7736 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7737 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7738 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7739 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7740 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7741 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7742 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7743 digest_buf
[8] = 0; // needed for base64_encode ()
7745 char tmp_buf
[64] = { 0 };
7747 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7751 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7753 else if (hash_mode
== 10100)
7755 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7760 byte_swap_32 (salt
.salt_buf
[0]),
7761 byte_swap_32 (salt
.salt_buf
[1]),
7762 byte_swap_32 (salt
.salt_buf
[2]),
7763 byte_swap_32 (salt
.salt_buf
[3]));
7765 else if (hash_mode
== 10200)
7767 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7769 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7773 char challenge
[100] = { 0 };
7775 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7779 char tmp_buf
[100] = { 0 };
7781 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7782 (char *) cram_md5
->user
,
7788 char response
[100] = { 0 };
7790 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7792 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7794 else if (hash_mode
== 10300)
7796 char tmp_buf
[100] = { 0 };
7798 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7799 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7801 uint tmp_len
= 20 + salt
.salt_len
;
7805 char base64_encoded
[100] = { 0 };
7807 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7809 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7811 else if (hash_mode
== 10400)
7813 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7815 pdf_t
*pdf
= &pdfs
[salt_pos
];
7817 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",
7825 byte_swap_32 (pdf
->id_buf
[0]),
7826 byte_swap_32 (pdf
->id_buf
[1]),
7827 byte_swap_32 (pdf
->id_buf
[2]),
7828 byte_swap_32 (pdf
->id_buf
[3]),
7830 byte_swap_32 (pdf
->u_buf
[0]),
7831 byte_swap_32 (pdf
->u_buf
[1]),
7832 byte_swap_32 (pdf
->u_buf
[2]),
7833 byte_swap_32 (pdf
->u_buf
[3]),
7834 byte_swap_32 (pdf
->u_buf
[4]),
7835 byte_swap_32 (pdf
->u_buf
[5]),
7836 byte_swap_32 (pdf
->u_buf
[6]),
7837 byte_swap_32 (pdf
->u_buf
[7]),
7839 byte_swap_32 (pdf
->o_buf
[0]),
7840 byte_swap_32 (pdf
->o_buf
[1]),
7841 byte_swap_32 (pdf
->o_buf
[2]),
7842 byte_swap_32 (pdf
->o_buf
[3]),
7843 byte_swap_32 (pdf
->o_buf
[4]),
7844 byte_swap_32 (pdf
->o_buf
[5]),
7845 byte_swap_32 (pdf
->o_buf
[6]),
7846 byte_swap_32 (pdf
->o_buf
[7])
7849 else if (hash_mode
== 10410)
7851 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7853 pdf_t
*pdf
= &pdfs
[salt_pos
];
7855 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",
7863 byte_swap_32 (pdf
->id_buf
[0]),
7864 byte_swap_32 (pdf
->id_buf
[1]),
7865 byte_swap_32 (pdf
->id_buf
[2]),
7866 byte_swap_32 (pdf
->id_buf
[3]),
7868 byte_swap_32 (pdf
->u_buf
[0]),
7869 byte_swap_32 (pdf
->u_buf
[1]),
7870 byte_swap_32 (pdf
->u_buf
[2]),
7871 byte_swap_32 (pdf
->u_buf
[3]),
7872 byte_swap_32 (pdf
->u_buf
[4]),
7873 byte_swap_32 (pdf
->u_buf
[5]),
7874 byte_swap_32 (pdf
->u_buf
[6]),
7875 byte_swap_32 (pdf
->u_buf
[7]),
7877 byte_swap_32 (pdf
->o_buf
[0]),
7878 byte_swap_32 (pdf
->o_buf
[1]),
7879 byte_swap_32 (pdf
->o_buf
[2]),
7880 byte_swap_32 (pdf
->o_buf
[3]),
7881 byte_swap_32 (pdf
->o_buf
[4]),
7882 byte_swap_32 (pdf
->o_buf
[5]),
7883 byte_swap_32 (pdf
->o_buf
[6]),
7884 byte_swap_32 (pdf
->o_buf
[7])
7887 else if (hash_mode
== 10420)
7889 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7891 pdf_t
*pdf
= &pdfs
[salt_pos
];
7893 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7895 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",
7903 byte_swap_32 (pdf
->id_buf
[0]),
7904 byte_swap_32 (pdf
->id_buf
[1]),
7905 byte_swap_32 (pdf
->id_buf
[2]),
7906 byte_swap_32 (pdf
->id_buf
[3]),
7908 byte_swap_32 (pdf
->u_buf
[0]),
7909 byte_swap_32 (pdf
->u_buf
[1]),
7910 byte_swap_32 (pdf
->u_buf
[2]),
7911 byte_swap_32 (pdf
->u_buf
[3]),
7912 byte_swap_32 (pdf
->u_buf
[4]),
7913 byte_swap_32 (pdf
->u_buf
[5]),
7914 byte_swap_32 (pdf
->u_buf
[6]),
7915 byte_swap_32 (pdf
->u_buf
[7]),
7917 byte_swap_32 (pdf
->o_buf
[0]),
7918 byte_swap_32 (pdf
->o_buf
[1]),
7919 byte_swap_32 (pdf
->o_buf
[2]),
7920 byte_swap_32 (pdf
->o_buf
[3]),
7921 byte_swap_32 (pdf
->o_buf
[4]),
7922 byte_swap_32 (pdf
->o_buf
[5]),
7923 byte_swap_32 (pdf
->o_buf
[6]),
7924 byte_swap_32 (pdf
->o_buf
[7]),
7932 else if (hash_mode
== 10500)
7934 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7936 pdf_t
*pdf
= &pdfs
[salt_pos
];
7938 if (pdf
->id_len
== 32)
7940 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",
7948 byte_swap_32 (pdf
->id_buf
[0]),
7949 byte_swap_32 (pdf
->id_buf
[1]),
7950 byte_swap_32 (pdf
->id_buf
[2]),
7951 byte_swap_32 (pdf
->id_buf
[3]),
7952 byte_swap_32 (pdf
->id_buf
[4]),
7953 byte_swap_32 (pdf
->id_buf
[5]),
7954 byte_swap_32 (pdf
->id_buf
[6]),
7955 byte_swap_32 (pdf
->id_buf
[7]),
7957 byte_swap_32 (pdf
->u_buf
[0]),
7958 byte_swap_32 (pdf
->u_buf
[1]),
7959 byte_swap_32 (pdf
->u_buf
[2]),
7960 byte_swap_32 (pdf
->u_buf
[3]),
7961 byte_swap_32 (pdf
->u_buf
[4]),
7962 byte_swap_32 (pdf
->u_buf
[5]),
7963 byte_swap_32 (pdf
->u_buf
[6]),
7964 byte_swap_32 (pdf
->u_buf
[7]),
7966 byte_swap_32 (pdf
->o_buf
[0]),
7967 byte_swap_32 (pdf
->o_buf
[1]),
7968 byte_swap_32 (pdf
->o_buf
[2]),
7969 byte_swap_32 (pdf
->o_buf
[3]),
7970 byte_swap_32 (pdf
->o_buf
[4]),
7971 byte_swap_32 (pdf
->o_buf
[5]),
7972 byte_swap_32 (pdf
->o_buf
[6]),
7973 byte_swap_32 (pdf
->o_buf
[7])
7978 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",
7986 byte_swap_32 (pdf
->id_buf
[0]),
7987 byte_swap_32 (pdf
->id_buf
[1]),
7988 byte_swap_32 (pdf
->id_buf
[2]),
7989 byte_swap_32 (pdf
->id_buf
[3]),
7991 byte_swap_32 (pdf
->u_buf
[0]),
7992 byte_swap_32 (pdf
->u_buf
[1]),
7993 byte_swap_32 (pdf
->u_buf
[2]),
7994 byte_swap_32 (pdf
->u_buf
[3]),
7995 byte_swap_32 (pdf
->u_buf
[4]),
7996 byte_swap_32 (pdf
->u_buf
[5]),
7997 byte_swap_32 (pdf
->u_buf
[6]),
7998 byte_swap_32 (pdf
->u_buf
[7]),
8000 byte_swap_32 (pdf
->o_buf
[0]),
8001 byte_swap_32 (pdf
->o_buf
[1]),
8002 byte_swap_32 (pdf
->o_buf
[2]),
8003 byte_swap_32 (pdf
->o_buf
[3]),
8004 byte_swap_32 (pdf
->o_buf
[4]),
8005 byte_swap_32 (pdf
->o_buf
[5]),
8006 byte_swap_32 (pdf
->o_buf
[6]),
8007 byte_swap_32 (pdf
->o_buf
[7])
8011 else if (hash_mode
== 10600)
8013 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8015 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8016 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8018 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8020 else if (hash_mode
== 10700)
8022 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8024 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8025 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8027 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8029 else if (hash_mode
== 10900)
8031 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8033 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8034 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8036 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8038 else if (hash_mode
== 11100)
8040 u32 salt_challenge
= salt
.salt_buf
[0];
8042 salt_challenge
= byte_swap_32 (salt_challenge
);
8044 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8046 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8047 SIGNATURE_POSTGRESQL_AUTH
,
8055 else if (hash_mode
== 11200)
8057 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8058 SIGNATURE_MYSQL_AUTH
,
8059 (unsigned char *) salt
.salt_buf
,
8066 else if (hash_mode
== 11300)
8068 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8070 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8072 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8073 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8074 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8076 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8077 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8078 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8080 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8082 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8084 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8087 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8089 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8091 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8094 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8096 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8098 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8101 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8102 SIGNATURE_BITCOIN_WALLET
,
8106 (unsigned char *) salt
.salt_buf
,
8114 free (cry_master_buf
);
8116 free (public_key_buf
);
8118 else if (hash_mode
== 11400)
8120 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8122 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8123 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8125 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8127 else if (hash_mode
== 11600)
8129 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8131 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8133 const uint data_len
= seven_zip
->data_len
;
8135 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8137 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8139 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8141 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8144 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8145 SIGNATURE_SEVEN_ZIP
,
8149 (char *) seven_zip
->salt_buf
,
8151 seven_zip
->iv_buf
[0],
8152 seven_zip
->iv_buf
[1],
8153 seven_zip
->iv_buf
[2],
8154 seven_zip
->iv_buf
[3],
8156 seven_zip
->data_len
,
8157 seven_zip
->unpack_size
,
8162 else if (hash_mode
== 11700)
8164 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8174 else if (hash_mode
== 11800)
8176 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8194 else if (hash_mode
== 11900)
8196 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8198 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8199 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8201 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8203 else if (hash_mode
== 12000)
8205 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8207 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8208 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8210 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8212 else if (hash_mode
== 12100)
8214 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8216 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8217 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8219 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8221 else if (hash_mode
== 12200)
8223 uint
*ptr_digest
= digest_buf
;
8224 uint
*ptr_salt
= salt
.salt_buf
;
8226 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8233 else if (hash_mode
== 12300)
8235 uint
*ptr_digest
= digest_buf
;
8236 uint
*ptr_salt
= salt
.salt_buf
;
8238 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",
8239 ptr_digest
[ 0], ptr_digest
[ 1],
8240 ptr_digest
[ 2], ptr_digest
[ 3],
8241 ptr_digest
[ 4], ptr_digest
[ 5],
8242 ptr_digest
[ 6], ptr_digest
[ 7],
8243 ptr_digest
[ 8], ptr_digest
[ 9],
8244 ptr_digest
[10], ptr_digest
[11],
8245 ptr_digest
[12], ptr_digest
[13],
8246 ptr_digest
[14], ptr_digest
[15],
8252 else if (hash_mode
== 12400)
8254 // encode iteration count
8256 char salt_iter
[5] = { 0 };
8258 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8259 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8260 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8261 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8266 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8267 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8268 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8269 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8274 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8276 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8277 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8279 memcpy (tmp_buf
, digest_buf
, 8);
8281 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8285 // fill the resulting buffer
8287 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8289 else if (hash_mode
== 12500)
8291 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8293 byte_swap_32 (salt
.salt_buf
[0]),
8294 byte_swap_32 (salt
.salt_buf
[1]),
8300 else if (hash_mode
== 12600)
8302 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8303 digest_buf
[0] + salt
.salt_buf_pc
[0],
8304 digest_buf
[1] + salt
.salt_buf_pc
[1],
8305 digest_buf
[2] + salt
.salt_buf_pc
[2],
8306 digest_buf
[3] + salt
.salt_buf_pc
[3],
8307 digest_buf
[4] + salt
.salt_buf_pc
[4],
8308 digest_buf
[5] + salt
.salt_buf_pc
[5],
8309 digest_buf
[6] + salt
.salt_buf_pc
[6],
8310 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8312 else if (hash_mode
== 12700)
8314 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8316 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8317 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8319 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8321 else if (hash_mode
== 12800)
8323 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8325 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",
8338 byte_swap_32 (digest_buf
[0]),
8339 byte_swap_32 (digest_buf
[1]),
8340 byte_swap_32 (digest_buf
[2]),
8341 byte_swap_32 (digest_buf
[3]),
8342 byte_swap_32 (digest_buf
[4]),
8343 byte_swap_32 (digest_buf
[5]),
8344 byte_swap_32 (digest_buf
[6]),
8345 byte_swap_32 (digest_buf
[7])
8348 else if (hash_mode
== 12900)
8350 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",
8359 byte_swap_32 (digest_buf
[0]),
8360 byte_swap_32 (digest_buf
[1]),
8361 byte_swap_32 (digest_buf
[2]),
8362 byte_swap_32 (digest_buf
[3]),
8363 byte_swap_32 (digest_buf
[4]),
8364 byte_swap_32 (digest_buf
[5]),
8365 byte_swap_32 (digest_buf
[6]),
8366 byte_swap_32 (digest_buf
[7]),
8373 else if (hash_mode
== 13000)
8375 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8377 rar5_t
*rar5
= &rar5s
[salt_pos
];
8379 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8389 byte_swap_32 (digest_buf
[0]),
8390 byte_swap_32 (digest_buf
[1])
8393 else if (hash_mode
== 13100)
8395 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8397 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8399 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8400 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8402 char data
[2560 * 4 * 2] = { 0 };
8404 char *ptr_data
= data
;
8406 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8407 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8412 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8413 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8415 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8417 (char *) krb5tgs
->account_info
,
8421 else if (hash_mode
== 13200)
8423 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8437 else if (hash_mode
== 13300)
8439 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8440 SIGNATURE_AXCRYPT_SHA1
,
8446 else if (hash_mode
== 13400)
8448 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8450 keepass_t
*keepass
= &keepasss
[salt_pos
];
8452 u32 version
= (u32
) keepass
->version
;
8453 u32 rounds
= salt
.salt_iter
;
8454 u32 algorithm
= (u32
) keepass
->algorithm
;
8455 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8457 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8458 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8459 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8460 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8461 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8463 /* specific to version 1 */
8467 /* specific to version 2 */
8468 u32 expected_bytes_len
;
8469 u32
*ptr_expected_bytes
;
8471 u32 final_random_seed_len
;
8472 u32 transf_random_seed_len
;
8474 u32 contents_hash_len
;
8476 transf_random_seed_len
= 8;
8478 contents_hash_len
= 8;
8479 final_random_seed_len
= 8;
8482 final_random_seed_len
= 4;
8484 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8490 char *ptr_data
= out_buf
;
8492 ptr_data
+= strlen(out_buf
);
8497 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8498 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8503 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8504 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8509 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8510 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8517 contents_len
= (u32
) keepass
->contents_len
;
8518 ptr_contents
= (u32
*) keepass
->contents
;
8520 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8521 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8533 char ptr_contents_len
[10] = { 0 };
8535 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8537 sprintf (ptr_data
, "%d", contents_len
);
8539 ptr_data
+= strlen(ptr_contents_len
);
8544 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8545 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8547 else if (version
== 2)
8549 expected_bytes_len
= 8;
8550 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8552 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8553 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8558 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8559 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8573 sprintf (ptr_data
, "%d", keyfile_len
);
8580 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8581 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8584 else if (hash_mode
== 13500)
8586 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8588 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8590 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8592 char pstoken_tmp
[1024 + 1] = { 0 };
8594 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8596 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8598 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8601 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8609 else if (hash_mode
== 13600)
8611 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8613 zip2_t
*zip2
= &zip2s
[salt_pos
];
8615 const u32 salt_len
= zip2
->salt_len
;
8617 char salt_tmp
[32 + 1] = { 0 };
8619 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8621 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8623 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8626 const u32 data_len
= zip2
->data_len
;
8628 char data_tmp
[8192 + 1] = { 0 };
8630 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8632 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8634 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8637 const u32 auth_len
= zip2
->auth_len
;
8639 char auth_tmp
[20 + 1] = { 0 };
8641 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8643 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8645 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8648 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8649 SIGNATURE_ZIP2_START
,
8655 zip2
->compress_length
,
8658 SIGNATURE_ZIP2_STOP
);
8660 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8662 snprintf (out_buf
, len
-1, "%s", hashfile
);
8666 if (hash_type
== HASH_TYPE_MD4
)
8668 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8674 else if (hash_type
== HASH_TYPE_MD5
)
8676 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8682 else if (hash_type
== HASH_TYPE_SHA1
)
8684 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8691 else if (hash_type
== HASH_TYPE_SHA256
)
8693 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8703 else if (hash_type
== HASH_TYPE_SHA384
)
8705 uint
*ptr
= digest_buf
;
8707 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8715 else if (hash_type
== HASH_TYPE_SHA512
)
8717 uint
*ptr
= digest_buf
;
8719 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8729 else if (hash_type
== HASH_TYPE_LM
)
8731 snprintf (out_buf
, len
-1, "%08x%08x",
8735 else if (hash_type
== HASH_TYPE_ORACLEH
)
8737 snprintf (out_buf
, len
-1, "%08X%08X",
8741 else if (hash_type
== HASH_TYPE_BCRYPT
)
8743 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8744 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8746 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8748 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8750 else if (hash_type
== HASH_TYPE_KECCAK
)
8752 uint
*ptr
= digest_buf
;
8754 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",
8782 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8784 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8786 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8793 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8795 digest_buf
[ 0] = digest_buf
[ 0];
8796 digest_buf
[ 1] = digest_buf
[ 1];
8797 digest_buf
[ 2] = digest_buf
[ 2];
8798 digest_buf
[ 3] = digest_buf
[ 3];
8799 digest_buf
[ 4] = digest_buf
[ 4];
8800 digest_buf
[ 5] = digest_buf
[ 5];
8801 digest_buf
[ 6] = digest_buf
[ 6];
8802 digest_buf
[ 7] = digest_buf
[ 7];
8803 digest_buf
[ 8] = digest_buf
[ 8];
8804 digest_buf
[ 9] = digest_buf
[ 9];
8805 digest_buf
[10] = digest_buf
[10];
8806 digest_buf
[11] = digest_buf
[11];
8807 digest_buf
[12] = digest_buf
[12];
8808 digest_buf
[13] = digest_buf
[13];
8809 digest_buf
[14] = digest_buf
[14];
8810 digest_buf
[15] = digest_buf
[15];
8812 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8830 else if (hash_type
== HASH_TYPE_GOST
)
8832 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8842 else if (hash_type
== HASH_TYPE_MYSQL
)
8844 snprintf (out_buf
, len
-1, "%08x%08x",
8848 else if (hash_type
== HASH_TYPE_LOTUS5
)
8850 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8856 else if (hash_type
== HASH_TYPE_LOTUS6
)
8858 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8859 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8860 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8861 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8863 char buf
[16] = { 0 };
8865 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8866 memcpy (buf
+ 5, digest_buf
, 9);
8870 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8872 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8875 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8877 else if (hash_type
== HASH_TYPE_LOTUS8
)
8879 char buf
[52] = { 0 };
8883 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8889 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8893 buf
[26] = salt
.salt_buf_pc
[0];
8894 buf
[27] = salt
.salt_buf_pc
[1];
8898 memcpy (buf
+ 28, digest_buf
, 8);
8900 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8904 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8906 else if (hash_type
== HASH_TYPE_CRC32
)
8908 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8912 if (salt_type
== SALT_TYPE_INTERN
)
8914 size_t pos
= strlen (out_buf
);
8916 out_buf
[pos
] = data
.separator
;
8918 char *ptr
= (char *) salt
.salt_buf
;
8920 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8922 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8926 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8928 memset (hccap
, 0, sizeof (hccap_t
));
8930 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8932 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8934 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8935 wpa_t
*wpa
= &wpas
[salt_pos
];
8937 hccap
->keyver
= wpa
->keyver
;
8939 hccap
->eapol_size
= wpa
->eapol_size
;
8941 if (wpa
->keyver
!= 1)
8943 uint eapol_tmp
[64] = { 0 };
8945 for (uint i
= 0; i
< 64; i
++)
8947 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8950 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8954 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8957 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
8958 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
8959 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
8960 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
8962 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8964 uint dgst_size
= data
.dgst_size
;
8966 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8968 if (wpa
->keyver
!= 1)
8970 uint digest_tmp
[4] = { 0 };
8972 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8973 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8974 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8975 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8977 memcpy (hccap
->keymic
, digest_tmp
, 16);
8981 memcpy (hccap
->keymic
, digest_ptr
, 16);
8985 void SuspendThreads ()
8987 if (data
.devices_status
== STATUS_RUNNING
)
8989 hc_timer_set (&data
.timer_paused
);
8991 data
.devices_status
= STATUS_PAUSED
;
8993 log_info ("Paused");
8997 void ResumeThreads ()
8999 if (data
.devices_status
== STATUS_PAUSED
)
9003 hc_timer_get (data
.timer_paused
, ms_paused
);
9005 data
.ms_paused
+= ms_paused
;
9007 data
.devices_status
= STATUS_RUNNING
;
9009 log_info ("Resumed");
9015 if (data
.devices_status
!= STATUS_RUNNING
) return;
9017 data
.devices_status
= STATUS_BYPASS
;
9019 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9022 void stop_at_checkpoint ()
9024 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9026 if (data
.devices_status
!= STATUS_RUNNING
) return;
9029 // this feature only makes sense if --restore-disable was not specified
9031 if (data
.restore_disable
== 1)
9033 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
9038 // check if monitoring of Restore Point updates should be enabled or disabled
9040 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9042 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9044 // save the current restore point value
9046 data
.checkpoint_cur_words
= get_lowest_words_done ();
9048 log_info ("Checkpoint enabled: will quit at next Restore Point update");
9052 data
.devices_status
= STATUS_RUNNING
;
9054 // reset the global value for checkpoint checks
9056 data
.checkpoint_cur_words
= 0;
9058 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9064 if (data
.devices_status
== STATUS_INIT
) return;
9065 if (data
.devices_status
== STATUS_STARTING
) return;
9067 data
.devices_status
= STATUS_ABORTED
;
9072 if (data
.devices_status
== STATUS_INIT
) return;
9073 if (data
.devices_status
== STATUS_STARTING
) return;
9075 data
.devices_status
= STATUS_QUIT
;
9078 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9080 FILE *fp
= fopen (kernel_file
, "rb");
9086 memset (&st
, 0, sizeof (st
));
9088 stat (kernel_file
, &st
);
9090 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9092 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9094 if (num_read
!= (size_t) st
.st_size
)
9096 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9103 buf
[st
.st_size
] = 0;
9105 for (int i
= 0; i
< num_devices
; i
++)
9107 kernel_lengths
[i
] = (size_t) st
.st_size
;
9109 kernel_sources
[i
] = buf
;
9114 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9122 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9124 if (binary_size
> 0)
9126 FILE *fp
= fopen (dst
, "wb");
9129 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9140 restore_data_t
*init_restore (int argc
, char **argv
)
9142 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9144 if (data
.restore_disable
== 0)
9146 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9150 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9154 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9163 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9165 int pidbin_len
= -1;
9168 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9170 FILE *fd
= fopen (pidbin
, "rb");
9174 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9176 pidbin
[pidbin_len
] = 0;
9180 char *argv0_r
= strrchr (argv
[0], '/');
9182 char *pidbin_r
= strrchr (pidbin
, '/');
9184 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9186 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9188 if (strcmp (argv0_r
, pidbin_r
) == 0)
9190 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9197 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9199 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9201 int pidbin2_len
= -1;
9203 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9204 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9206 pidbin
[pidbin_len
] = 0;
9207 pidbin2
[pidbin2_len
] = 0;
9211 if (strcmp (pidbin
, pidbin2
) == 0)
9213 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9226 if (rd
->version_bin
< RESTORE_MIN
)
9228 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9235 memset (rd
, 0, sizeof (restore_data_t
));
9237 rd
->version_bin
= VERSION_BIN
;
9240 rd
->pid
= getpid ();
9242 rd
->pid
= GetCurrentProcessId ();
9245 if (getcwd (rd
->cwd
, 255) == NULL
)
9258 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9260 FILE *fp
= fopen (eff_restore_file
, "rb");
9264 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9269 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9271 log_error ("ERROR: cannot read %s", eff_restore_file
);
9276 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9278 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9280 for (uint i
= 0; i
< rd
->argc
; i
++)
9282 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9284 log_error ("ERROR: cannot read %s", eff_restore_file
);
9289 size_t len
= strlen (buf
);
9291 if (len
) buf
[len
- 1] = 0;
9293 rd
->argv
[i
] = mystrdup (buf
);
9300 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9302 if (chdir (rd
->cwd
))
9304 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9305 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9306 " https://github.com/philsmd/analyze_hc_restore\n"
9307 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9313 u64
get_lowest_words_done ()
9317 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9319 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9321 if (device_param
->skipped
) continue;
9323 const u64 words_done
= device_param
->words_done
;
9325 if (words_done
< words_cur
) words_cur
= words_done
;
9328 // It's possible that a device's workload isn't finished right after a restore-case.
9329 // In that case, this function would return 0 and overwrite the real restore point
9330 // There's also data.words_cur which is set to rd->words_cur but it changes while
9331 // the attack is running therefore we should stick to rd->words_cur.
9332 // Note that -s influences rd->words_cur we should keep a close look on that.
9334 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9339 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9341 u64 words_cur
= get_lowest_words_done ();
9343 rd
->words_cur
= words_cur
;
9345 FILE *fp
= fopen (new_restore_file
, "wb");
9349 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9354 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9356 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9361 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9363 for (uint i
= 0; i
< rd
->argc
; i
++)
9365 fprintf (fp
, "%s", rd
->argv
[i
]);
9371 fsync (fileno (fp
));
9376 void cycle_restore ()
9378 const char *eff_restore_file
= data
.eff_restore_file
;
9379 const char *new_restore_file
= data
.new_restore_file
;
9381 restore_data_t
*rd
= data
.rd
;
9383 write_restore (new_restore_file
, rd
);
9387 memset (&st
, 0, sizeof(st
));
9389 if (stat (eff_restore_file
, &st
) == 0)
9391 if (unlink (eff_restore_file
))
9393 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9397 if (rename (new_restore_file
, eff_restore_file
))
9399 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9403 void check_checkpoint ()
9405 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9407 u64 words_cur
= get_lowest_words_done ();
9409 if (words_cur
!= data
.checkpoint_cur_words
)
9419 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9423 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9425 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9427 myfree (alias
->device_name
);
9428 myfree (alias
->alias_name
);
9431 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9433 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9435 myfree (entry
->device_name
);
9438 myfree (tuning_db
->alias_buf
);
9439 myfree (tuning_db
->entry_buf
);
9444 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9446 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9448 int num_lines
= count_lines (fp
);
9450 // a bit over-allocated
9452 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9453 tuning_db
->alias_cnt
= 0;
9455 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9456 tuning_db
->entry_cnt
= 0;
9461 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9463 FILE *fp
= fopen (tuning_db_file
, "rb");
9467 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9472 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9478 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9482 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9484 if (line_buf
== NULL
) break;
9488 const int line_len
= in_superchop (line_buf
);
9490 if (line_len
== 0) continue;
9492 if (line_buf
[0] == '#') continue;
9496 char *token_ptr
[7] = { NULL
};
9500 char *next
= strtok (line_buf
, "\t ");
9502 token_ptr
[token_cnt
] = next
;
9506 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9508 token_ptr
[token_cnt
] = next
;
9515 char *device_name
= token_ptr
[0];
9516 char *alias_name
= token_ptr
[1];
9518 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9520 alias
->device_name
= mystrdup (device_name
);
9521 alias
->alias_name
= mystrdup (alias_name
);
9523 tuning_db
->alias_cnt
++;
9525 else if (token_cnt
== 6)
9527 if ((token_ptr
[1][0] != '0') &&
9528 (token_ptr
[1][0] != '1') &&
9529 (token_ptr
[1][0] != '3') &&
9530 (token_ptr
[1][0] != '*'))
9532 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9537 if ((token_ptr
[3][0] != '1') &&
9538 (token_ptr
[3][0] != '2') &&
9539 (token_ptr
[3][0] != '4') &&
9540 (token_ptr
[3][0] != '8') &&
9541 (token_ptr
[3][0] != 'N'))
9543 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9548 char *device_name
= token_ptr
[0];
9550 int attack_mode
= -1;
9552 int vector_width
= -1;
9553 int kernel_accel
= -1;
9554 int kernel_loops
= -1;
9556 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9557 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9558 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9560 if (token_ptr
[4][0] != 'A')
9562 kernel_accel
= atoi (token_ptr
[4]);
9564 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9566 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9576 if (token_ptr
[5][0] != 'A')
9578 kernel_loops
= atoi (token_ptr
[5]);
9580 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9582 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9592 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9594 entry
->device_name
= mystrdup (device_name
);
9595 entry
->attack_mode
= attack_mode
;
9596 entry
->hash_type
= hash_type
;
9597 entry
->vector_width
= vector_width
;
9598 entry
->kernel_accel
= kernel_accel
;
9599 entry
->kernel_loops
= kernel_loops
;
9601 tuning_db
->entry_cnt
++;
9605 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9615 // todo: print loaded 'cnt' message
9617 // sort the database
9619 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9620 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9625 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9627 static tuning_db_entry_t s
;
9629 // first we need to convert all spaces in the device_name to underscore
9631 char *device_name_nospace
= strdup (device_param
->device_name
);
9633 int device_name_length
= strlen (device_name_nospace
);
9637 for (i
= 0; i
< device_name_length
; i
++)
9639 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9642 // find out if there's an alias configured
9644 tuning_db_alias_t a
;
9646 a
.device_name
= device_name_nospace
;
9648 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
);
9650 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9652 // attack-mode 6 and 7 are attack-mode 1 basically
9654 if (attack_mode
== 6) attack_mode
= 1;
9655 if (attack_mode
== 7) attack_mode
= 1;
9657 // bsearch is not ideal but fast enough
9659 s
.device_name
= device_name_nospace
;
9660 s
.attack_mode
= attack_mode
;
9661 s
.hash_type
= hash_type
;
9663 tuning_db_entry_t
*entry
= NULL
;
9665 // this will produce all 2^3 combinations required
9667 for (i
= 0; i
< 8; i
++)
9669 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9670 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9671 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9673 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9675 if (entry
!= NULL
) break;
9677 // in non-wildcard mode do some additional checks:
9681 // in case we have an alias-name
9683 if (alias_name
!= NULL
)
9685 s
.device_name
= alias_name
;
9687 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9689 if (entry
!= NULL
) break;
9692 // or by device type
9694 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9696 s
.device_name
= "DEVICE_TYPE_CPU";
9698 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9700 s
.device_name
= "DEVICE_TYPE_GPU";
9702 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9704 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9707 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9709 if (entry
!= NULL
) break;
9713 // free converted device_name
9715 myfree (device_name_nospace
);
9724 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9726 u8 tmp
[256] = { 0 };
9728 if (salt_len
> sizeof (tmp
))
9733 memcpy (tmp
, in
, salt_len
);
9735 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9737 if ((salt_len
% 2) == 0)
9739 u32 new_salt_len
= salt_len
/ 2;
9741 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9746 tmp
[i
] = hex_convert (p1
) << 0;
9747 tmp
[i
] |= hex_convert (p0
) << 4;
9750 salt_len
= new_salt_len
;
9757 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9759 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9762 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9764 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9768 u32
*tmp_uint
= (u32
*) tmp
;
9770 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9771 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9772 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9773 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9774 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9775 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9776 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9777 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9778 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9779 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9781 salt_len
= salt_len
* 2;
9789 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9791 lowercase (tmp
, salt_len
);
9794 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9796 uppercase (tmp
, salt_len
);
9801 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9806 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9811 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9813 u32
*tmp_uint
= (uint
*) tmp
;
9819 for (u32 i
= 0; i
< max
; i
++)
9821 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9824 // Important: we may need to increase the length of memcpy since
9825 // we don't want to "loose" some swapped bytes (could happen if
9826 // they do not perfectly fit in the 4-byte blocks)
9827 // Memcpy does always copy the bytes in the BE order, but since
9828 // we swapped them, some important bytes could be in positions
9829 // we normally skip with the original len
9831 if (len
% 4) len
+= 4 - (len
% 4);
9834 memcpy (out
, tmp
, len
);
9839 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9841 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9843 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9845 u32
*digest
= (u32
*) hash_buf
->digest
;
9847 salt_t
*salt
= hash_buf
->salt
;
9849 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9851 char *iter_pos
= input_buf
+ 4;
9853 salt
->salt_iter
= 1 << atoi (iter_pos
);
9855 char *salt_pos
= strchr (iter_pos
, '$');
9857 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9863 salt
->salt_len
= salt_len
;
9865 u8 tmp_buf
[100] = { 0 };
9867 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9869 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9871 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9873 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9874 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9875 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9876 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9878 char *hash_pos
= salt_pos
+ 22;
9880 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9882 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9884 memcpy (digest
, tmp_buf
, 24);
9886 digest
[0] = byte_swap_32 (digest
[0]);
9887 digest
[1] = byte_swap_32 (digest
[1]);
9888 digest
[2] = byte_swap_32 (digest
[2]);
9889 digest
[3] = byte_swap_32 (digest
[3]);
9890 digest
[4] = byte_swap_32 (digest
[4]);
9891 digest
[5] = byte_swap_32 (digest
[5]);
9893 digest
[5] &= ~0xff; // its just 23 not 24 !
9898 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9900 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9902 u32
*digest
= (u32
*) hash_buf
->digest
;
9904 u8 tmp_buf
[100] = { 0 };
9906 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9908 memcpy (digest
, tmp_buf
, 32);
9910 digest
[0] = byte_swap_32 (digest
[0]);
9911 digest
[1] = byte_swap_32 (digest
[1]);
9912 digest
[2] = byte_swap_32 (digest
[2]);
9913 digest
[3] = byte_swap_32 (digest
[3]);
9914 digest
[4] = byte_swap_32 (digest
[4]);
9915 digest
[5] = byte_swap_32 (digest
[5]);
9916 digest
[6] = byte_swap_32 (digest
[6]);
9917 digest
[7] = byte_swap_32 (digest
[7]);
9919 digest
[0] -= SHA256M_A
;
9920 digest
[1] -= SHA256M_B
;
9921 digest
[2] -= SHA256M_C
;
9922 digest
[3] -= SHA256M_D
;
9923 digest
[4] -= SHA256M_E
;
9924 digest
[5] -= SHA256M_F
;
9925 digest
[6] -= SHA256M_G
;
9926 digest
[7] -= SHA256M_H
;
9931 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9933 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9935 u32
*digest
= (u32
*) hash_buf
->digest
;
9937 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9938 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9940 digest
[0] = byte_swap_32 (digest
[0]);
9941 digest
[1] = byte_swap_32 (digest
[1]);
9945 IP (digest
[0], digest
[1], tt
);
9947 digest
[0] = digest
[0];
9948 digest
[1] = digest
[1];
9955 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9957 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
9959 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
9961 u32
*digest
= (u32
*) hash_buf
->digest
;
9963 salt_t
*salt
= hash_buf
->salt
;
9965 char *hash_pos
= input_buf
+ 10;
9967 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9968 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9969 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9970 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9971 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9973 digest
[0] -= SHA1M_A
;
9974 digest
[1] -= SHA1M_B
;
9975 digest
[2] -= SHA1M_C
;
9976 digest
[3] -= SHA1M_D
;
9977 digest
[4] -= SHA1M_E
;
9981 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9983 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9985 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9987 salt
->salt_len
= salt_len
;
9992 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9994 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9996 u32
*digest
= (u32
*) hash_buf
->digest
;
9998 salt_t
*salt
= hash_buf
->salt
;
10000 char *hash_pos
= input_buf
+ 8;
10002 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10003 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10004 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10005 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10006 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10008 digest
[0] -= SHA1M_A
;
10009 digest
[1] -= SHA1M_B
;
10010 digest
[2] -= SHA1M_C
;
10011 digest
[3] -= SHA1M_D
;
10012 digest
[4] -= SHA1M_E
;
10016 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10018 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10020 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10022 salt
->salt_len
= salt_len
;
10024 return (PARSER_OK
);
10027 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10029 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10031 u64
*digest
= (u64
*) hash_buf
->digest
;
10033 salt_t
*salt
= hash_buf
->salt
;
10035 char *hash_pos
= input_buf
+ 8;
10037 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10038 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10039 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10040 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10041 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10042 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10043 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10044 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10046 digest
[0] -= SHA512M_A
;
10047 digest
[1] -= SHA512M_B
;
10048 digest
[2] -= SHA512M_C
;
10049 digest
[3] -= SHA512M_D
;
10050 digest
[4] -= SHA512M_E
;
10051 digest
[5] -= SHA512M_F
;
10052 digest
[6] -= SHA512M_G
;
10053 digest
[7] -= SHA512M_H
;
10057 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10059 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10061 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10063 salt
->salt_len
= salt_len
;
10065 return (PARSER_OK
);
10068 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10070 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10072 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10076 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10079 u32
*digest
= (u32
*) hash_buf
->digest
;
10081 salt_t
*salt
= hash_buf
->salt
;
10083 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10084 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10085 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10086 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10088 digest
[0] = byte_swap_32 (digest
[0]);
10089 digest
[1] = byte_swap_32 (digest
[1]);
10090 digest
[2] = byte_swap_32 (digest
[2]);
10091 digest
[3] = byte_swap_32 (digest
[3]);
10093 digest
[0] -= MD5M_A
;
10094 digest
[1] -= MD5M_B
;
10095 digest
[2] -= MD5M_C
;
10096 digest
[3] -= MD5M_D
;
10098 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10100 uint salt_len
= input_len
- 32 - 1;
10102 char *salt_buf
= input_buf
+ 32 + 1;
10104 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10106 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10108 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10110 salt
->salt_len
= salt_len
;
10112 return (PARSER_OK
);
10115 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10117 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10119 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10123 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10128 char clean_input_buf
[32] = { 0 };
10130 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10131 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10133 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10137 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10143 clean_input_buf
[k
] = input_buf
[i
];
10151 u32
*digest
= (u32
*) hash_buf
->digest
;
10153 salt_t
*salt
= hash_buf
->salt
;
10155 u32 a
, b
, c
, d
, e
, f
;
10157 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10158 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10159 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10160 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10161 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10162 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10164 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10165 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10167 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10168 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10169 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10170 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10171 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10172 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10174 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10175 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10177 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10178 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10179 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10180 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10181 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10182 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10184 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10185 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10187 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10188 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10189 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10190 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10191 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10192 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10194 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10195 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10197 digest
[0] = byte_swap_32 (digest
[0]);
10198 digest
[1] = byte_swap_32 (digest
[1]);
10199 digest
[2] = byte_swap_32 (digest
[2]);
10200 digest
[3] = byte_swap_32 (digest
[3]);
10202 digest
[0] -= MD5M_A
;
10203 digest
[1] -= MD5M_B
;
10204 digest
[2] -= MD5M_C
;
10205 digest
[3] -= MD5M_D
;
10207 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10209 uint salt_len
= input_len
- 30 - 1;
10211 char *salt_buf
= input_buf
+ 30 + 1;
10213 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10215 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10217 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10218 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10220 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10222 salt
->salt_len
= salt_len
;
10224 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10226 salt
->salt_len
+= 22;
10228 return (PARSER_OK
);
10231 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10233 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10235 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10239 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10242 u32
*digest
= (u32
*) hash_buf
->digest
;
10244 salt_t
*salt
= hash_buf
->salt
;
10246 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10247 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10248 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10249 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10250 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10252 digest
[0] -= SHA1M_A
;
10253 digest
[1] -= SHA1M_B
;
10254 digest
[2] -= SHA1M_C
;
10255 digest
[3] -= SHA1M_D
;
10256 digest
[4] -= SHA1M_E
;
10258 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10260 uint salt_len
= input_len
- 40 - 1;
10262 char *salt_buf
= input_buf
+ 40 + 1;
10264 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10266 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10268 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10270 salt
->salt_len
= salt_len
;
10272 return (PARSER_OK
);
10275 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10277 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10279 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10283 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10286 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10288 char *iter_pos
= input_buf
+ 6;
10290 salt_t
*salt
= hash_buf
->salt
;
10292 uint iter
= atoi (iter_pos
);
10296 iter
= ROUNDS_DCC2
;
10299 salt
->salt_iter
= iter
- 1;
10301 char *salt_pos
= strchr (iter_pos
, '#');
10303 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10307 char *digest_pos
= strchr (salt_pos
, '#');
10309 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10313 uint salt_len
= digest_pos
- salt_pos
- 1;
10315 u32
*digest
= (u32
*) hash_buf
->digest
;
10317 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10318 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10319 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10320 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10322 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10324 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10326 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10328 salt
->salt_len
= salt_len
;
10330 return (PARSER_OK
);
10333 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10335 u32
*digest
= (u32
*) hash_buf
->digest
;
10337 salt_t
*salt
= hash_buf
->salt
;
10339 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10343 memcpy (&in
, input_buf
, input_len
);
10345 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10347 memcpy (digest
, in
.keymic
, 16);
10350 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10351 The phrase "Pairwise key expansion"
10352 Access Point Address (referred to as Authenticator Address AA)
10353 Supplicant Address (referred to as Supplicant Address SA)
10354 Access Point Nonce (referred to as Authenticator Anonce)
10355 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10358 uint salt_len
= strlen (in
.essid
);
10362 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10364 return (PARSER_SALT_LENGTH
);
10367 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10369 salt
->salt_len
= salt_len
;
10371 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10373 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10375 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10377 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10379 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10380 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10384 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10385 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10388 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10390 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10391 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10395 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10396 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10399 for (int i
= 0; i
< 25; i
++)
10401 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10404 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10405 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10406 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10407 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10409 wpa
->keyver
= in
.keyver
;
10411 if (wpa
->keyver
> 255)
10413 log_info ("ATTENTION!");
10414 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10415 log_info (" This could be due to a recent aircrack-ng bug.");
10416 log_info (" The key version was automatically reset to a reasonable value.");
10419 wpa
->keyver
&= 0xff;
10422 wpa
->eapol_size
= in
.eapol_size
;
10424 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10426 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10428 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10430 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10432 if (wpa
->keyver
== 1)
10438 digest
[0] = byte_swap_32 (digest
[0]);
10439 digest
[1] = byte_swap_32 (digest
[1]);
10440 digest
[2] = byte_swap_32 (digest
[2]);
10441 digest
[3] = byte_swap_32 (digest
[3]);
10443 for (int i
= 0; i
< 64; i
++)
10445 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10449 uint32_t *p0
= (uint32_t *) in
.essid
;
10453 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10454 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10456 salt
->salt_buf
[10] = c0
;
10457 salt
->salt_buf
[11] = c1
;
10459 return (PARSER_OK
);
10462 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10464 u32
*digest
= (u32
*) hash_buf
->digest
;
10466 salt_t
*salt
= hash_buf
->salt
;
10468 if (input_len
== 0)
10470 log_error ("Password Safe v2 container not specified");
10475 FILE *fp
= fopen (input_buf
, "rb");
10479 log_error ("%s: %s", input_buf
, strerror (errno
));
10486 memset (&buf
, 0, sizeof (psafe2_hdr
));
10488 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10492 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10494 salt
->salt_buf
[0] = buf
.random
[0];
10495 salt
->salt_buf
[1] = buf
.random
[1];
10497 salt
->salt_len
= 8;
10498 salt
->salt_iter
= 1000;
10500 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10501 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10502 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10503 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10504 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10506 return (PARSER_OK
);
10509 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10511 u32
*digest
= (u32
*) hash_buf
->digest
;
10513 salt_t
*salt
= hash_buf
->salt
;
10515 if (input_len
== 0)
10517 log_error (".psafe3 not specified");
10522 FILE *fp
= fopen (input_buf
, "rb");
10526 log_error ("%s: %s", input_buf
, strerror (errno
));
10533 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10537 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10539 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10541 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10543 salt
->salt_iter
= in
.iterations
+ 1;
10545 salt
->salt_buf
[0] = in
.salt_buf
[0];
10546 salt
->salt_buf
[1] = in
.salt_buf
[1];
10547 salt
->salt_buf
[2] = in
.salt_buf
[2];
10548 salt
->salt_buf
[3] = in
.salt_buf
[3];
10549 salt
->salt_buf
[4] = in
.salt_buf
[4];
10550 salt
->salt_buf
[5] = in
.salt_buf
[5];
10551 salt
->salt_buf
[6] = in
.salt_buf
[6];
10552 salt
->salt_buf
[7] = in
.salt_buf
[7];
10554 salt
->salt_len
= 32;
10556 digest
[0] = in
.hash_buf
[0];
10557 digest
[1] = in
.hash_buf
[1];
10558 digest
[2] = in
.hash_buf
[2];
10559 digest
[3] = in
.hash_buf
[3];
10560 digest
[4] = in
.hash_buf
[4];
10561 digest
[5] = in
.hash_buf
[5];
10562 digest
[6] = in
.hash_buf
[6];
10563 digest
[7] = in
.hash_buf
[7];
10565 digest
[0] = byte_swap_32 (digest
[0]);
10566 digest
[1] = byte_swap_32 (digest
[1]);
10567 digest
[2] = byte_swap_32 (digest
[2]);
10568 digest
[3] = byte_swap_32 (digest
[3]);
10569 digest
[4] = byte_swap_32 (digest
[4]);
10570 digest
[5] = byte_swap_32 (digest
[5]);
10571 digest
[6] = byte_swap_32 (digest
[6]);
10572 digest
[7] = byte_swap_32 (digest
[7]);
10574 return (PARSER_OK
);
10577 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10579 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10581 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10583 u32
*digest
= (u32
*) hash_buf
->digest
;
10585 salt_t
*salt
= hash_buf
->salt
;
10587 char *iter_pos
= input_buf
+ 3;
10589 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10591 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10593 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10595 salt
->salt_iter
= salt_iter
;
10597 char *salt_pos
= iter_pos
+ 1;
10601 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10603 salt
->salt_len
= salt_len
;
10605 char *hash_pos
= salt_pos
+ salt_len
;
10607 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10609 return (PARSER_OK
);
10612 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10614 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10616 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10618 u32
*digest
= (u32
*) hash_buf
->digest
;
10620 salt_t
*salt
= hash_buf
->salt
;
10622 char *salt_pos
= input_buf
+ 3;
10624 uint iterations_len
= 0;
10626 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10630 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10632 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10633 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10637 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10641 iterations_len
+= 8;
10645 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10648 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10650 char *hash_pos
= strchr (salt_pos
, '$');
10652 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10654 uint salt_len
= hash_pos
- salt_pos
;
10656 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10658 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10660 salt
->salt_len
= salt_len
;
10664 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10666 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10668 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10670 return (PARSER_OK
);
10673 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10675 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10677 u32
*digest
= (u32
*) hash_buf
->digest
;
10679 salt_t
*salt
= hash_buf
->salt
;
10681 char *salt_pos
= input_buf
+ 6;
10683 uint iterations_len
= 0;
10685 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10689 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10691 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10692 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10696 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10700 iterations_len
+= 8;
10704 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10707 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10709 char *hash_pos
= strchr (salt_pos
, '$');
10711 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10713 uint salt_len
= hash_pos
- salt_pos
;
10715 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10717 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10719 salt
->salt_len
= salt_len
;
10723 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10725 return (PARSER_OK
);
10728 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10730 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10732 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10734 u32
*digest
= (u32
*) hash_buf
->digest
;
10736 salt_t
*salt
= hash_buf
->salt
;
10738 char *salt_pos
= input_buf
+ 14;
10740 char *hash_pos
= strchr (salt_pos
, '*');
10742 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10746 uint salt_len
= hash_pos
- salt_pos
- 1;
10748 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10750 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10752 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10754 salt
->salt_len
= salt_len
;
10756 u8 tmp_buf
[100] = { 0 };
10758 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10760 memcpy (digest
, tmp_buf
, 20);
10762 digest
[0] = byte_swap_32 (digest
[0]);
10763 digest
[1] = byte_swap_32 (digest
[1]);
10764 digest
[2] = byte_swap_32 (digest
[2]);
10765 digest
[3] = byte_swap_32 (digest
[3]);
10766 digest
[4] = byte_swap_32 (digest
[4]);
10768 digest
[0] -= SHA1M_A
;
10769 digest
[1] -= SHA1M_B
;
10770 digest
[2] -= SHA1M_C
;
10771 digest
[3] -= SHA1M_D
;
10772 digest
[4] -= SHA1M_E
;
10774 return (PARSER_OK
);
10777 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10779 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10781 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10783 if (c12
& 3) return (PARSER_HASH_VALUE
);
10785 u32
*digest
= (u32
*) hash_buf
->digest
;
10787 salt_t
*salt
= hash_buf
->salt
;
10789 // for ascii_digest
10790 salt
->salt_sign
[0] = input_buf
[0];
10791 salt
->salt_sign
[1] = input_buf
[1];
10793 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10794 | itoa64_to_int (input_buf
[1]) << 6;
10796 salt
->salt_len
= 2;
10798 u8 tmp_buf
[100] = { 0 };
10800 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10802 memcpy (digest
, tmp_buf
, 8);
10806 IP (digest
[0], digest
[1], tt
);
10811 return (PARSER_OK
);
10814 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10816 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10818 u32
*digest
= (u32
*) hash_buf
->digest
;
10820 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10821 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10822 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10823 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10825 digest
[0] = byte_swap_32 (digest
[0]);
10826 digest
[1] = byte_swap_32 (digest
[1]);
10827 digest
[2] = byte_swap_32 (digest
[2]);
10828 digest
[3] = byte_swap_32 (digest
[3]);
10830 digest
[0] -= MD4M_A
;
10831 digest
[1] -= MD4M_B
;
10832 digest
[2] -= MD4M_C
;
10833 digest
[3] -= MD4M_D
;
10835 return (PARSER_OK
);
10838 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10840 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10842 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10846 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10849 u32
*digest
= (u32
*) hash_buf
->digest
;
10851 salt_t
*salt
= hash_buf
->salt
;
10853 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10854 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10855 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10856 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10858 digest
[0] = byte_swap_32 (digest
[0]);
10859 digest
[1] = byte_swap_32 (digest
[1]);
10860 digest
[2] = byte_swap_32 (digest
[2]);
10861 digest
[3] = byte_swap_32 (digest
[3]);
10863 digest
[0] -= MD4M_A
;
10864 digest
[1] -= MD4M_B
;
10865 digest
[2] -= MD4M_C
;
10866 digest
[3] -= MD4M_D
;
10868 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10870 uint salt_len
= input_len
- 32 - 1;
10872 char *salt_buf
= input_buf
+ 32 + 1;
10874 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10876 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10878 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10880 salt
->salt_len
= salt_len
;
10882 return (PARSER_OK
);
10885 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10887 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10889 u32
*digest
= (u32
*) hash_buf
->digest
;
10891 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10892 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10893 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10894 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10896 digest
[0] = byte_swap_32 (digest
[0]);
10897 digest
[1] = byte_swap_32 (digest
[1]);
10898 digest
[2] = byte_swap_32 (digest
[2]);
10899 digest
[3] = byte_swap_32 (digest
[3]);
10901 digest
[0] -= MD5M_A
;
10902 digest
[1] -= MD5M_B
;
10903 digest
[2] -= MD5M_C
;
10904 digest
[3] -= MD5M_D
;
10906 return (PARSER_OK
);
10909 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10911 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10913 u32
*digest
= (u32
*) hash_buf
->digest
;
10915 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10916 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10920 digest
[0] = byte_swap_32 (digest
[0]);
10921 digest
[1] = byte_swap_32 (digest
[1]);
10923 return (PARSER_OK
);
10926 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10928 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10930 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10934 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10937 u32
*digest
= (u32
*) hash_buf
->digest
;
10939 salt_t
*salt
= hash_buf
->salt
;
10941 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10942 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10943 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10944 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10946 digest
[0] = byte_swap_32 (digest
[0]);
10947 digest
[1] = byte_swap_32 (digest
[1]);
10948 digest
[2] = byte_swap_32 (digest
[2]);
10949 digest
[3] = byte_swap_32 (digest
[3]);
10951 digest
[0] -= MD5M_A
;
10952 digest
[1] -= MD5M_B
;
10953 digest
[2] -= MD5M_C
;
10954 digest
[3] -= MD5M_D
;
10956 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10958 uint salt_len
= input_len
- 32 - 1;
10960 char *salt_buf
= input_buf
+ 32 + 1;
10962 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10964 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10966 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10968 salt
->salt_len
= salt_len
;
10970 return (PARSER_OK
);
10973 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10975 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10977 u32
*digest
= (u32
*) hash_buf
->digest
;
10979 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10980 | itoa64_to_int (input_buf
[ 1]) << 6
10981 | itoa64_to_int (input_buf
[ 2]) << 12
10982 | itoa64_to_int (input_buf
[ 3]) << 18;
10983 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10984 | itoa64_to_int (input_buf
[ 5]) << 6
10985 | itoa64_to_int (input_buf
[ 6]) << 12
10986 | itoa64_to_int (input_buf
[ 7]) << 18;
10987 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10988 | itoa64_to_int (input_buf
[ 9]) << 6
10989 | itoa64_to_int (input_buf
[10]) << 12
10990 | itoa64_to_int (input_buf
[11]) << 18;
10991 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10992 | itoa64_to_int (input_buf
[13]) << 6
10993 | itoa64_to_int (input_buf
[14]) << 12
10994 | itoa64_to_int (input_buf
[15]) << 18;
10996 digest
[0] -= MD5M_A
;
10997 digest
[1] -= MD5M_B
;
10998 digest
[2] -= MD5M_C
;
10999 digest
[3] -= MD5M_D
;
11001 digest
[0] &= 0x00ffffff;
11002 digest
[1] &= 0x00ffffff;
11003 digest
[2] &= 0x00ffffff;
11004 digest
[3] &= 0x00ffffff;
11006 return (PARSER_OK
);
11009 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11011 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11013 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11017 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11020 u32
*digest
= (u32
*) hash_buf
->digest
;
11022 salt_t
*salt
= hash_buf
->salt
;
11024 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11025 | itoa64_to_int (input_buf
[ 1]) << 6
11026 | itoa64_to_int (input_buf
[ 2]) << 12
11027 | itoa64_to_int (input_buf
[ 3]) << 18;
11028 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11029 | itoa64_to_int (input_buf
[ 5]) << 6
11030 | itoa64_to_int (input_buf
[ 6]) << 12
11031 | itoa64_to_int (input_buf
[ 7]) << 18;
11032 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11033 | itoa64_to_int (input_buf
[ 9]) << 6
11034 | itoa64_to_int (input_buf
[10]) << 12
11035 | itoa64_to_int (input_buf
[11]) << 18;
11036 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11037 | itoa64_to_int (input_buf
[13]) << 6
11038 | itoa64_to_int (input_buf
[14]) << 12
11039 | itoa64_to_int (input_buf
[15]) << 18;
11041 digest
[0] -= MD5M_A
;
11042 digest
[1] -= MD5M_B
;
11043 digest
[2] -= MD5M_C
;
11044 digest
[3] -= MD5M_D
;
11046 digest
[0] &= 0x00ffffff;
11047 digest
[1] &= 0x00ffffff;
11048 digest
[2] &= 0x00ffffff;
11049 digest
[3] &= 0x00ffffff;
11051 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11053 uint salt_len
= input_len
- 16 - 1;
11055 char *salt_buf
= input_buf
+ 16 + 1;
11057 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11059 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11061 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11063 salt
->salt_len
= salt_len
;
11065 return (PARSER_OK
);
11068 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11070 key
[0] = (nthash
[0] >> 0);
11071 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11072 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11073 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11074 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11075 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11076 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11077 key
[7] = (nthash
[6] << 1);
11089 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11091 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11093 u32
*digest
= (u32
*) hash_buf
->digest
;
11095 salt_t
*salt
= hash_buf
->salt
;
11097 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11103 char *user_pos
= input_buf
;
11105 char *unused_pos
= strchr (user_pos
, ':');
11107 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11109 uint user_len
= unused_pos
- user_pos
;
11111 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11115 char *domain_pos
= strchr (unused_pos
, ':');
11117 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11119 uint unused_len
= domain_pos
- unused_pos
;
11121 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11125 char *srvchall_pos
= strchr (domain_pos
, ':');
11127 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11129 uint domain_len
= srvchall_pos
- domain_pos
;
11131 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11135 char *hash_pos
= strchr (srvchall_pos
, ':');
11137 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11139 uint srvchall_len
= hash_pos
- srvchall_pos
;
11141 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11145 char *clichall_pos
= strchr (hash_pos
, ':');
11147 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11149 uint hash_len
= clichall_pos
- hash_pos
;
11151 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11155 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11157 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11160 * store some data for later use
11163 netntlm
->user_len
= user_len
* 2;
11164 netntlm
->domain_len
= domain_len
* 2;
11165 netntlm
->srvchall_len
= srvchall_len
/ 2;
11166 netntlm
->clichall_len
= clichall_len
/ 2;
11168 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11169 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11172 * handle username and domainname
11175 for (uint i
= 0; i
< user_len
; i
++)
11177 *userdomain_ptr
++ = user_pos
[i
];
11178 *userdomain_ptr
++ = 0;
11181 for (uint i
= 0; i
< domain_len
; i
++)
11183 *userdomain_ptr
++ = domain_pos
[i
];
11184 *userdomain_ptr
++ = 0;
11188 * handle server challenge encoding
11191 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11193 const char p0
= srvchall_pos
[i
+ 0];
11194 const char p1
= srvchall_pos
[i
+ 1];
11196 *chall_ptr
++ = hex_convert (p1
) << 0
11197 | hex_convert (p0
) << 4;
11201 * handle client challenge encoding
11204 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11206 const char p0
= clichall_pos
[i
+ 0];
11207 const char p1
= clichall_pos
[i
+ 1];
11209 *chall_ptr
++ = hex_convert (p1
) << 0
11210 | hex_convert (p0
) << 4;
11217 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11219 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11221 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11223 salt
->salt_len
= salt_len
;
11225 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11226 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11227 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11228 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11230 digest
[0] = byte_swap_32 (digest
[0]);
11231 digest
[1] = byte_swap_32 (digest
[1]);
11232 digest
[2] = byte_swap_32 (digest
[2]);
11233 digest
[3] = byte_swap_32 (digest
[3]);
11235 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11237 uint digest_tmp
[2] = { 0 };
11239 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11240 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11242 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11243 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11245 /* special case 2: ESS */
11247 if (srvchall_len
== 48)
11249 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11251 uint w
[16] = { 0 };
11253 w
[ 0] = netntlm
->chall_buf
[6];
11254 w
[ 1] = netntlm
->chall_buf
[7];
11255 w
[ 2] = netntlm
->chall_buf
[0];
11256 w
[ 3] = netntlm
->chall_buf
[1];
11260 uint dgst
[4] = { 0 };
11269 salt
->salt_buf
[0] = dgst
[0];
11270 salt
->salt_buf
[1] = dgst
[1];
11274 /* precompute netntlmv1 exploit start */
11276 for (uint i
= 0; i
< 0x10000; i
++)
11278 uint key_md4
[2] = { i
, 0 };
11279 uint key_des
[2] = { 0, 0 };
11281 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11283 uint Kc
[16] = { 0 };
11284 uint Kd
[16] = { 0 };
11286 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11288 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11290 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11292 if (data3
[0] != digest_tmp
[0]) continue;
11293 if (data3
[1] != digest_tmp
[1]) continue;
11295 salt
->salt_buf
[2] = i
;
11297 salt
->salt_len
= 24;
11302 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11303 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11305 /* precompute netntlmv1 exploit stop */
11309 IP (digest
[0], digest
[1], tt
);
11310 IP (digest
[2], digest
[3], tt
);
11312 digest
[0] = rotr32 (digest
[0], 29);
11313 digest
[1] = rotr32 (digest
[1], 29);
11314 digest
[2] = rotr32 (digest
[2], 29);
11315 digest
[3] = rotr32 (digest
[3], 29);
11317 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11319 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11320 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11322 return (PARSER_OK
);
11325 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11327 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11329 u32
*digest
= (u32
*) hash_buf
->digest
;
11331 salt_t
*salt
= hash_buf
->salt
;
11333 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11339 char *user_pos
= input_buf
;
11341 char *unused_pos
= strchr (user_pos
, ':');
11343 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11345 uint user_len
= unused_pos
- user_pos
;
11347 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11351 char *domain_pos
= strchr (unused_pos
, ':');
11353 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11355 uint unused_len
= domain_pos
- unused_pos
;
11357 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11361 char *srvchall_pos
= strchr (domain_pos
, ':');
11363 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11365 uint domain_len
= srvchall_pos
- domain_pos
;
11367 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11371 char *hash_pos
= strchr (srvchall_pos
, ':');
11373 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11375 uint srvchall_len
= hash_pos
- srvchall_pos
;
11377 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11381 char *clichall_pos
= strchr (hash_pos
, ':');
11383 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11385 uint hash_len
= clichall_pos
- hash_pos
;
11387 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11391 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11393 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11395 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11398 * store some data for later use
11401 netntlm
->user_len
= user_len
* 2;
11402 netntlm
->domain_len
= domain_len
* 2;
11403 netntlm
->srvchall_len
= srvchall_len
/ 2;
11404 netntlm
->clichall_len
= clichall_len
/ 2;
11406 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11407 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11410 * handle username and domainname
11413 for (uint i
= 0; i
< user_len
; i
++)
11415 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11416 *userdomain_ptr
++ = 0;
11419 for (uint i
= 0; i
< domain_len
; i
++)
11421 *userdomain_ptr
++ = domain_pos
[i
];
11422 *userdomain_ptr
++ = 0;
11425 *userdomain_ptr
++ = 0x80;
11428 * handle server challenge encoding
11431 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11433 const char p0
= srvchall_pos
[i
+ 0];
11434 const char p1
= srvchall_pos
[i
+ 1];
11436 *chall_ptr
++ = hex_convert (p1
) << 0
11437 | hex_convert (p0
) << 4;
11441 * handle client challenge encoding
11444 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11446 const char p0
= clichall_pos
[i
+ 0];
11447 const char p1
= clichall_pos
[i
+ 1];
11449 *chall_ptr
++ = hex_convert (p1
) << 0
11450 | hex_convert (p0
) << 4;
11453 *chall_ptr
++ = 0x80;
11456 * handle hash itself
11459 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11460 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11461 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11462 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11464 digest
[0] = byte_swap_32 (digest
[0]);
11465 digest
[1] = byte_swap_32 (digest
[1]);
11466 digest
[2] = byte_swap_32 (digest
[2]);
11467 digest
[3] = byte_swap_32 (digest
[3]);
11470 * reuse challange data as salt_buf, its the buffer that is most likely unique
11473 salt
->salt_buf
[0] = 0;
11474 salt
->salt_buf
[1] = 0;
11475 salt
->salt_buf
[2] = 0;
11476 salt
->salt_buf
[3] = 0;
11477 salt
->salt_buf
[4] = 0;
11478 salt
->salt_buf
[5] = 0;
11479 salt
->salt_buf
[6] = 0;
11480 salt
->salt_buf
[7] = 0;
11484 uptr
= (uint
*) netntlm
->userdomain_buf
;
11486 for (uint i
= 0; i
< 16; i
+= 16)
11488 md5_64 (uptr
, salt
->salt_buf
);
11491 uptr
= (uint
*) netntlm
->chall_buf
;
11493 for (uint i
= 0; i
< 256; i
+= 16)
11495 md5_64 (uptr
, salt
->salt_buf
);
11498 salt
->salt_len
= 16;
11500 return (PARSER_OK
);
11503 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11505 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11507 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11511 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11514 u32
*digest
= (u32
*) hash_buf
->digest
;
11516 salt_t
*salt
= hash_buf
->salt
;
11518 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11519 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11520 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11521 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11523 digest
[0] = byte_swap_32 (digest
[0]);
11524 digest
[1] = byte_swap_32 (digest
[1]);
11525 digest
[2] = byte_swap_32 (digest
[2]);
11526 digest
[3] = byte_swap_32 (digest
[3]);
11528 digest
[0] -= MD5M_A
;
11529 digest
[1] -= MD5M_B
;
11530 digest
[2] -= MD5M_C
;
11531 digest
[3] -= MD5M_D
;
11533 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11535 uint salt_len
= input_len
- 32 - 1;
11537 char *salt_buf
= input_buf
+ 32 + 1;
11539 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11541 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11543 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11545 salt
->salt_len
= salt_len
;
11547 return (PARSER_OK
);
11550 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11552 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11554 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11558 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11561 u32
*digest
= (u32
*) hash_buf
->digest
;
11563 salt_t
*salt
= hash_buf
->salt
;
11565 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11566 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11567 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11568 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11570 digest
[0] = byte_swap_32 (digest
[0]);
11571 digest
[1] = byte_swap_32 (digest
[1]);
11572 digest
[2] = byte_swap_32 (digest
[2]);
11573 digest
[3] = byte_swap_32 (digest
[3]);
11575 digest
[0] -= MD5M_A
;
11576 digest
[1] -= MD5M_B
;
11577 digest
[2] -= MD5M_C
;
11578 digest
[3] -= MD5M_D
;
11580 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11582 uint salt_len
= input_len
- 32 - 1;
11584 char *salt_buf
= input_buf
+ 32 + 1;
11586 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11588 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11590 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11592 salt
->salt_len
= salt_len
;
11594 return (PARSER_OK
);
11597 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11599 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11601 u32
*digest
= (u32
*) hash_buf
->digest
;
11603 salt_t
*salt
= hash_buf
->salt
;
11605 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11606 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11607 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11608 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11610 digest
[0] = byte_swap_32 (digest
[0]);
11611 digest
[1] = byte_swap_32 (digest
[1]);
11612 digest
[2] = byte_swap_32 (digest
[2]);
11613 digest
[3] = byte_swap_32 (digest
[3]);
11615 digest
[0] -= MD5M_A
;
11616 digest
[1] -= MD5M_B
;
11617 digest
[2] -= MD5M_C
;
11618 digest
[3] -= MD5M_D
;
11621 * This is a virtual salt. While the algorithm is basically not salted
11622 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11623 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11626 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11628 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11630 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11632 salt
->salt_len
= salt_len
;
11634 return (PARSER_OK
);
11637 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11639 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11641 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11645 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11648 u32
*digest
= (u32
*) hash_buf
->digest
;
11650 salt_t
*salt
= hash_buf
->salt
;
11652 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11653 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11654 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11655 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11657 digest
[0] = byte_swap_32 (digest
[0]);
11658 digest
[1] = byte_swap_32 (digest
[1]);
11659 digest
[2] = byte_swap_32 (digest
[2]);
11660 digest
[3] = byte_swap_32 (digest
[3]);
11662 digest
[0] -= MD5M_A
;
11663 digest
[1] -= MD5M_B
;
11664 digest
[2] -= MD5M_C
;
11665 digest
[3] -= MD5M_D
;
11667 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11669 uint salt_len
= input_len
- 32 - 1;
11671 char *salt_buf
= input_buf
+ 32 + 1;
11673 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11675 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11677 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11679 salt
->salt_len
= salt_len
;
11681 return (PARSER_OK
);
11684 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11686 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11688 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11692 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11695 u32
*digest
= (u32
*) hash_buf
->digest
;
11697 salt_t
*salt
= hash_buf
->salt
;
11699 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11700 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11701 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11702 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11704 digest
[0] = byte_swap_32 (digest
[0]);
11705 digest
[1] = byte_swap_32 (digest
[1]);
11706 digest
[2] = byte_swap_32 (digest
[2]);
11707 digest
[3] = byte_swap_32 (digest
[3]);
11709 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11711 uint salt_len
= input_len
- 32 - 1;
11713 char *salt_buf
= input_buf
+ 32 + 1;
11715 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11717 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11719 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11721 salt
->salt_len
= salt_len
;
11723 return (PARSER_OK
);
11726 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11728 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11730 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11734 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11737 u32
*digest
= (u32
*) hash_buf
->digest
;
11739 salt_t
*salt
= hash_buf
->salt
;
11741 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11742 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11743 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11744 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11746 digest
[0] = byte_swap_32 (digest
[0]);
11747 digest
[1] = byte_swap_32 (digest
[1]);
11748 digest
[2] = byte_swap_32 (digest
[2]);
11749 digest
[3] = byte_swap_32 (digest
[3]);
11751 digest
[0] -= MD4M_A
;
11752 digest
[1] -= MD4M_B
;
11753 digest
[2] -= MD4M_C
;
11754 digest
[3] -= MD4M_D
;
11756 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11758 uint salt_len
= input_len
- 32 - 1;
11760 char *salt_buf
= input_buf
+ 32 + 1;
11762 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11764 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11766 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11768 salt
->salt_len
= salt_len
;
11770 return (PARSER_OK
);
11773 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11775 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11777 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11781 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11784 u32
*digest
= (u32
*) hash_buf
->digest
;
11786 salt_t
*salt
= hash_buf
->salt
;
11788 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11789 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11790 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11791 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11793 digest
[0] = byte_swap_32 (digest
[0]);
11794 digest
[1] = byte_swap_32 (digest
[1]);
11795 digest
[2] = byte_swap_32 (digest
[2]);
11796 digest
[3] = byte_swap_32 (digest
[3]);
11798 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11800 uint salt_len
= input_len
- 32 - 1;
11802 char *salt_buf
= input_buf
+ 32 + 1;
11804 uint salt_pc_block
[16] = { 0 };
11806 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11808 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11810 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11812 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11814 salt_pc_block
[14] = salt_len
* 8;
11816 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11818 md5_64 (salt_pc_block
, salt_pc_digest
);
11820 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11821 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11822 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11823 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11825 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11827 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11829 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11831 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11832 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11833 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11834 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11836 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11838 return (PARSER_OK
);
11841 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11843 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11845 u32
*digest
= (u32
*) hash_buf
->digest
;
11847 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11848 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11849 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11850 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11851 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11853 digest
[0] -= SHA1M_A
;
11854 digest
[1] -= SHA1M_B
;
11855 digest
[2] -= SHA1M_C
;
11856 digest
[3] -= SHA1M_D
;
11857 digest
[4] -= SHA1M_E
;
11859 return (PARSER_OK
);
11862 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11864 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11866 u32
*digest
= (u32
*) hash_buf
->digest
;
11868 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11869 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11870 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11871 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11872 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11874 return (PARSER_OK
);
11877 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11879 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11881 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11883 u32
*digest
= (u32
*) hash_buf
->digest
;
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]);
11891 digest
[4] = 0x00000000;
11893 return (PARSER_OK
);
11896 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11898 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11900 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11904 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11907 u32
*digest
= (u32
*) hash_buf
->digest
;
11909 salt_t
*salt
= hash_buf
->salt
;
11911 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11912 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11913 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11914 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11915 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11917 digest
[0] -= SHA1M_A
;
11918 digest
[1] -= SHA1M_B
;
11919 digest
[2] -= SHA1M_C
;
11920 digest
[3] -= SHA1M_D
;
11921 digest
[4] -= SHA1M_E
;
11923 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11925 uint salt_len
= input_len
- 40 - 1;
11927 char *salt_buf
= input_buf
+ 40 + 1;
11929 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11931 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11933 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11935 salt
->salt_len
= salt_len
;
11937 return (PARSER_OK
);
11940 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11942 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
11944 u32
*digest
= (u32
*) hash_buf
->digest
;
11946 salt_t
*salt
= hash_buf
->salt
;
11948 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
11950 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11951 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11952 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11953 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11954 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11956 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11958 uint salt_len
= input_len
- 40 - 1;
11960 char *salt_buf
= input_buf
+ 40 + 1;
11962 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
11964 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
11966 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
11968 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
11971 pstoken
->salt_len
= salt_len
/ 2;
11973 /* some fake salt for the sorting mechanisms */
11975 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
11976 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
11977 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
11978 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
11979 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
11980 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
11981 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
11982 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
11984 salt
->salt_len
= 32;
11986 /* we need to check if we can precompute some of the data --
11987 this is possible since the scheme is badly designed */
11989 pstoken
->pc_digest
[0] = SHA1M_A
;
11990 pstoken
->pc_digest
[1] = SHA1M_B
;
11991 pstoken
->pc_digest
[2] = SHA1M_C
;
11992 pstoken
->pc_digest
[3] = SHA1M_D
;
11993 pstoken
->pc_digest
[4] = SHA1M_E
;
11995 pstoken
->pc_offset
= 0;
11997 for (int i
= 0; i
< (int) pstoken
->salt_len
- 64; i
+= 64)
12001 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12002 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12003 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12004 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12005 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12006 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12007 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12008 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12009 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12010 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12011 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12012 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12013 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12014 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12015 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12016 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12018 sha1_64 (w
, pstoken
->pc_digest
);
12020 pstoken
->pc_offset
+= 16;
12023 return (PARSER_OK
);
12026 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12028 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12030 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12032 u32
*digest
= (u32
*) hash_buf
->digest
;
12034 u8 tmp_buf
[100] = { 0 };
12036 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12038 memcpy (digest
, tmp_buf
, 20);
12040 digest
[0] = byte_swap_32 (digest
[0]);
12041 digest
[1] = byte_swap_32 (digest
[1]);
12042 digest
[2] = byte_swap_32 (digest
[2]);
12043 digest
[3] = byte_swap_32 (digest
[3]);
12044 digest
[4] = byte_swap_32 (digest
[4]);
12046 digest
[0] -= SHA1M_A
;
12047 digest
[1] -= SHA1M_B
;
12048 digest
[2] -= SHA1M_C
;
12049 digest
[3] -= SHA1M_D
;
12050 digest
[4] -= SHA1M_E
;
12052 return (PARSER_OK
);
12055 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12057 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12059 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12061 u32
*digest
= (u32
*) hash_buf
->digest
;
12063 salt_t
*salt
= hash_buf
->salt
;
12065 u8 tmp_buf
[100] = { 0 };
12067 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12069 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12071 memcpy (digest
, tmp_buf
, 20);
12073 int salt_len
= tmp_len
- 20;
12075 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12077 salt
->salt_len
= salt_len
;
12079 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12081 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12083 char *ptr
= (char *) salt
->salt_buf
;
12085 ptr
[salt
->salt_len
] = 0x80;
12088 digest
[0] = byte_swap_32 (digest
[0]);
12089 digest
[1] = byte_swap_32 (digest
[1]);
12090 digest
[2] = byte_swap_32 (digest
[2]);
12091 digest
[3] = byte_swap_32 (digest
[3]);
12092 digest
[4] = byte_swap_32 (digest
[4]);
12094 digest
[0] -= SHA1M_A
;
12095 digest
[1] -= SHA1M_B
;
12096 digest
[2] -= SHA1M_C
;
12097 digest
[3] -= SHA1M_D
;
12098 digest
[4] -= SHA1M_E
;
12100 return (PARSER_OK
);
12103 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12105 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12107 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12109 u32
*digest
= (u32
*) hash_buf
->digest
;
12111 salt_t
*salt
= hash_buf
->salt
;
12113 char *salt_buf
= input_buf
+ 6;
12117 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12119 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12121 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12123 salt
->salt_len
= salt_len
;
12125 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12127 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12128 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12129 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12130 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12131 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12133 digest
[0] -= SHA1M_A
;
12134 digest
[1] -= SHA1M_B
;
12135 digest
[2] -= SHA1M_C
;
12136 digest
[3] -= SHA1M_D
;
12137 digest
[4] -= SHA1M_E
;
12139 return (PARSER_OK
);
12142 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12144 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12146 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12148 u32
*digest
= (u32
*) hash_buf
->digest
;
12150 salt_t
*salt
= hash_buf
->salt
;
12152 char *salt_buf
= input_buf
+ 6;
12156 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12158 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12160 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12162 salt
->salt_len
= salt_len
;
12164 char *hash_pos
= input_buf
+ 6 + 8;
12166 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12167 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12168 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12169 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12170 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12172 digest
[0] -= SHA1M_A
;
12173 digest
[1] -= SHA1M_B
;
12174 digest
[2] -= SHA1M_C
;
12175 digest
[3] -= SHA1M_D
;
12176 digest
[4] -= SHA1M_E
;
12178 return (PARSER_OK
);
12181 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12183 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12185 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12187 u64
*digest
= (u64
*) hash_buf
->digest
;
12189 salt_t
*salt
= hash_buf
->salt
;
12191 char *salt_buf
= input_buf
+ 6;
12195 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12197 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12199 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12201 salt
->salt_len
= salt_len
;
12203 char *hash_pos
= input_buf
+ 6 + 8;
12205 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12206 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12207 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12208 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12209 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12210 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12211 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12212 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12214 digest
[0] -= SHA512M_A
;
12215 digest
[1] -= SHA512M_B
;
12216 digest
[2] -= SHA512M_C
;
12217 digest
[3] -= SHA512M_D
;
12218 digest
[4] -= SHA512M_E
;
12219 digest
[5] -= SHA512M_F
;
12220 digest
[6] -= SHA512M_G
;
12221 digest
[7] -= SHA512M_H
;
12223 return (PARSER_OK
);
12226 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12228 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12230 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12234 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12237 u32
*digest
= (u32
*) hash_buf
->digest
;
12239 salt_t
*salt
= hash_buf
->salt
;
12241 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12242 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12246 digest
[0] = byte_swap_32 (digest
[0]);
12247 digest
[1] = byte_swap_32 (digest
[1]);
12249 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12251 uint salt_len
= input_len
- 16 - 1;
12253 char *salt_buf
= input_buf
+ 16 + 1;
12255 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12257 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12259 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12261 salt
->salt_len
= salt_len
;
12263 return (PARSER_OK
);
12266 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12268 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12270 u32
*digest
= (u32
*) hash_buf
->digest
;
12272 salt_t
*salt
= hash_buf
->salt
;
12274 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12275 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12276 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12277 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12278 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12280 digest
[0] -= SHA1M_A
;
12281 digest
[1] -= SHA1M_B
;
12282 digest
[2] -= SHA1M_C
;
12283 digest
[3] -= SHA1M_D
;
12284 digest
[4] -= SHA1M_E
;
12286 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12288 uint salt_len
= input_len
- 40 - 1;
12290 char *salt_buf
= input_buf
+ 40 + 1;
12292 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12294 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12296 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12298 salt
->salt_len
= salt_len
;
12300 return (PARSER_OK
);
12303 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12305 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12307 u32
*digest
= (u32
*) hash_buf
->digest
;
12309 salt_t
*salt
= hash_buf
->salt
;
12311 char *hash_pos
= input_buf
;
12313 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12314 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12315 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12316 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12317 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12318 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12319 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12320 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12321 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12322 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12323 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12324 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12325 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12326 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12327 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12328 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12330 char *salt_pos
= input_buf
+ 128;
12332 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12333 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12334 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12335 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12337 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12338 salt
->salt_len
= 16;
12340 return (PARSER_OK
);
12343 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12345 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12347 u32
*digest
= (u32
*) hash_buf
->digest
;
12349 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12350 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12351 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12352 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12353 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12354 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12355 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12356 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12358 digest
[0] -= SHA256M_A
;
12359 digest
[1] -= SHA256M_B
;
12360 digest
[2] -= SHA256M_C
;
12361 digest
[3] -= SHA256M_D
;
12362 digest
[4] -= SHA256M_E
;
12363 digest
[5] -= SHA256M_F
;
12364 digest
[6] -= SHA256M_G
;
12365 digest
[7] -= SHA256M_H
;
12367 return (PARSER_OK
);
12370 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12372 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12374 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12378 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12381 u32
*digest
= (u32
*) hash_buf
->digest
;
12383 salt_t
*salt
= hash_buf
->salt
;
12385 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12386 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12387 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12388 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12389 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12390 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12391 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12392 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12394 digest
[0] -= SHA256M_A
;
12395 digest
[1] -= SHA256M_B
;
12396 digest
[2] -= SHA256M_C
;
12397 digest
[3] -= SHA256M_D
;
12398 digest
[4] -= SHA256M_E
;
12399 digest
[5] -= SHA256M_F
;
12400 digest
[6] -= SHA256M_G
;
12401 digest
[7] -= SHA256M_H
;
12403 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12405 uint salt_len
= input_len
- 64 - 1;
12407 char *salt_buf
= input_buf
+ 64 + 1;
12409 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12411 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12413 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12415 salt
->salt_len
= salt_len
;
12417 return (PARSER_OK
);
12420 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12422 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12424 u64
*digest
= (u64
*) hash_buf
->digest
;
12426 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12427 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12428 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12429 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12430 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12431 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12435 digest
[0] -= SHA384M_A
;
12436 digest
[1] -= SHA384M_B
;
12437 digest
[2] -= SHA384M_C
;
12438 digest
[3] -= SHA384M_D
;
12439 digest
[4] -= SHA384M_E
;
12440 digest
[5] -= SHA384M_F
;
12444 return (PARSER_OK
);
12447 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12449 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12451 u64
*digest
= (u64
*) hash_buf
->digest
;
12453 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12454 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12455 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12456 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12457 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12458 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12459 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12460 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12462 digest
[0] -= SHA512M_A
;
12463 digest
[1] -= SHA512M_B
;
12464 digest
[2] -= SHA512M_C
;
12465 digest
[3] -= SHA512M_D
;
12466 digest
[4] -= SHA512M_E
;
12467 digest
[5] -= SHA512M_F
;
12468 digest
[6] -= SHA512M_G
;
12469 digest
[7] -= SHA512M_H
;
12471 return (PARSER_OK
);
12474 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12476 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12478 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12482 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12485 u64
*digest
= (u64
*) hash_buf
->digest
;
12487 salt_t
*salt
= hash_buf
->salt
;
12489 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12490 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12491 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12492 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12493 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12494 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12495 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12496 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12498 digest
[0] -= SHA512M_A
;
12499 digest
[1] -= SHA512M_B
;
12500 digest
[2] -= SHA512M_C
;
12501 digest
[3] -= SHA512M_D
;
12502 digest
[4] -= SHA512M_E
;
12503 digest
[5] -= SHA512M_F
;
12504 digest
[6] -= SHA512M_G
;
12505 digest
[7] -= SHA512M_H
;
12507 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12509 uint salt_len
= input_len
- 128 - 1;
12511 char *salt_buf
= input_buf
+ 128 + 1;
12513 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12515 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12517 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12519 salt
->salt_len
= salt_len
;
12521 return (PARSER_OK
);
12524 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12526 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12528 u64
*digest
= (u64
*) hash_buf
->digest
;
12530 salt_t
*salt
= hash_buf
->salt
;
12532 char *salt_pos
= input_buf
+ 3;
12534 uint iterations_len
= 0;
12536 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12540 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12542 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12543 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12547 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12551 iterations_len
+= 8;
12555 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12558 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12560 char *hash_pos
= strchr (salt_pos
, '$');
12562 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12564 uint salt_len
= hash_pos
- salt_pos
;
12566 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12568 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12570 salt
->salt_len
= salt_len
;
12574 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12576 return (PARSER_OK
);
12579 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12581 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12583 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12585 u64
*digest
= (u64
*) hash_buf
->digest
;
12587 salt_t
*salt
= hash_buf
->salt
;
12589 uint keccak_mdlen
= input_len
/ 2;
12591 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12593 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12595 digest
[i
] = byte_swap_64 (digest
[i
]);
12598 salt
->keccak_mdlen
= keccak_mdlen
;
12600 return (PARSER_OK
);
12603 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12605 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12607 u32
*digest
= (u32
*) hash_buf
->digest
;
12609 salt_t
*salt
= hash_buf
->salt
;
12611 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12614 * Parse that strange long line
12619 size_t in_len
[9] = { 0 };
12621 in_off
[0] = strtok (input_buf
, ":");
12623 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12625 in_len
[0] = strlen (in_off
[0]);
12629 for (i
= 1; i
< 9; i
++)
12631 in_off
[i
] = strtok (NULL
, ":");
12633 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12635 in_len
[i
] = strlen (in_off
[i
]);
12638 char *ptr
= (char *) ikepsk
->msg_buf
;
12640 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12641 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12642 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12643 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12644 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12645 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12649 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12651 ptr
= (char *) ikepsk
->nr_buf
;
12653 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12654 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12658 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12661 * Store to database
12666 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12667 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12668 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12669 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12671 digest
[0] = byte_swap_32 (digest
[0]);
12672 digest
[1] = byte_swap_32 (digest
[1]);
12673 digest
[2] = byte_swap_32 (digest
[2]);
12674 digest
[3] = byte_swap_32 (digest
[3]);
12676 salt
->salt_len
= 32;
12678 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12679 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12680 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12681 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12682 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12683 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12684 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12685 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12687 return (PARSER_OK
);
12690 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12692 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12694 u32
*digest
= (u32
*) hash_buf
->digest
;
12696 salt_t
*salt
= hash_buf
->salt
;
12698 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12701 * Parse that strange long line
12706 size_t in_len
[9] = { 0 };
12708 in_off
[0] = strtok (input_buf
, ":");
12710 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12712 in_len
[0] = strlen (in_off
[0]);
12716 for (i
= 1; i
< 9; i
++)
12718 in_off
[i
] = strtok (NULL
, ":");
12720 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12722 in_len
[i
] = strlen (in_off
[i
]);
12725 char *ptr
= (char *) ikepsk
->msg_buf
;
12727 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12728 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12729 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12730 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12731 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12732 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12736 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12738 ptr
= (char *) ikepsk
->nr_buf
;
12740 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12741 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12745 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12748 * Store to database
12753 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12754 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12755 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12756 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12757 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12759 salt
->salt_len
= 32;
12761 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12762 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12763 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12764 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12765 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12766 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12767 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12768 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12770 return (PARSER_OK
);
12773 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12775 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12777 u32
*digest
= (u32
*) hash_buf
->digest
;
12779 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12780 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12781 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12782 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12783 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12785 digest
[0] = byte_swap_32 (digest
[0]);
12786 digest
[1] = byte_swap_32 (digest
[1]);
12787 digest
[2] = byte_swap_32 (digest
[2]);
12788 digest
[3] = byte_swap_32 (digest
[3]);
12789 digest
[4] = byte_swap_32 (digest
[4]);
12791 return (PARSER_OK
);
12794 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12796 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12798 u32
*digest
= (u32
*) hash_buf
->digest
;
12800 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12801 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12802 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12803 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12804 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12805 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12806 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12807 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12808 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12809 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12810 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12811 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12812 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12813 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12814 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12815 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12817 return (PARSER_OK
);
12820 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12822 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12824 u32
*digest
= (u32
*) hash_buf
->digest
;
12826 salt_t
*salt
= hash_buf
->salt
;
12828 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12829 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12830 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12831 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12832 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12834 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12836 uint salt_len
= input_len
- 40 - 1;
12838 char *salt_buf
= input_buf
+ 40 + 1;
12840 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12842 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12844 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12846 salt
->salt_len
= salt_len
;
12848 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12850 return (PARSER_OK
);
12853 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12855 u32
*digest
= (u32
*) hash_buf
->digest
;
12857 salt_t
*salt
= hash_buf
->salt
;
12859 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12861 if (input_len
== 0)
12863 log_error ("TrueCrypt container not specified");
12868 FILE *fp
= fopen (input_buf
, "rb");
12872 log_error ("%s: %s", input_buf
, strerror (errno
));
12877 char buf
[512] = { 0 };
12879 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12883 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12885 memcpy (tc
->salt_buf
, buf
, 64);
12887 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12889 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12891 salt
->salt_len
= 4;
12893 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
12895 tc
->signature
= 0x45555254; // "TRUE"
12897 digest
[0] = tc
->data_buf
[0];
12899 return (PARSER_OK
);
12902 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12904 u32
*digest
= (u32
*) hash_buf
->digest
;
12906 salt_t
*salt
= hash_buf
->salt
;
12908 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12910 if (input_len
== 0)
12912 log_error ("TrueCrypt container not specified");
12917 FILE *fp
= fopen (input_buf
, "rb");
12921 log_error ("%s: %s", input_buf
, strerror (errno
));
12926 char buf
[512] = { 0 };
12928 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12932 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12934 memcpy (tc
->salt_buf
, buf
, 64);
12936 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12938 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12940 salt
->salt_len
= 4;
12942 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
12944 tc
->signature
= 0x45555254; // "TRUE"
12946 digest
[0] = tc
->data_buf
[0];
12948 return (PARSER_OK
);
12951 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12953 u32
*digest
= (u32
*) hash_buf
->digest
;
12955 salt_t
*salt
= hash_buf
->salt
;
12957 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12959 if (input_len
== 0)
12961 log_error ("VeraCrypt container not specified");
12966 FILE *fp
= fopen (input_buf
, "rb");
12970 log_error ("%s: %s", input_buf
, strerror (errno
));
12975 char buf
[512] = { 0 };
12977 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12981 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
12983 memcpy (tc
->salt_buf
, buf
, 64);
12985 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12987 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12989 salt
->salt_len
= 4;
12991 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
12993 tc
->signature
= 0x41524556; // "VERA"
12995 digest
[0] = tc
->data_buf
[0];
12997 return (PARSER_OK
);
13000 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13002 u32
*digest
= (u32
*) hash_buf
->digest
;
13004 salt_t
*salt
= hash_buf
->salt
;
13006 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13008 if (input_len
== 0)
13010 log_error ("VeraCrypt container not specified");
13015 FILE *fp
= fopen (input_buf
, "rb");
13019 log_error ("%s: %s", input_buf
, strerror (errno
));
13024 char buf
[512] = { 0 };
13026 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13030 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13032 memcpy (tc
->salt_buf
, buf
, 64);
13034 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13036 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13038 salt
->salt_len
= 4;
13040 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13042 tc
->signature
= 0x41524556; // "VERA"
13044 digest
[0] = tc
->data_buf
[0];
13046 return (PARSER_OK
);
13049 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13051 u32
*digest
= (u32
*) hash_buf
->digest
;
13053 salt_t
*salt
= hash_buf
->salt
;
13055 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13057 if (input_len
== 0)
13059 log_error ("VeraCrypt container not specified");
13064 FILE *fp
= fopen (input_buf
, "rb");
13068 log_error ("%s: %s", input_buf
, strerror (errno
));
13073 char buf
[512] = { 0 };
13075 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13079 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13081 memcpy (tc
->salt_buf
, buf
, 64);
13083 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13085 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13087 salt
->salt_len
= 4;
13089 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13091 tc
->signature
= 0x41524556; // "VERA"
13093 digest
[0] = tc
->data_buf
[0];
13095 return (PARSER_OK
);
13098 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13100 u32
*digest
= (u32
*) hash_buf
->digest
;
13102 salt_t
*salt
= hash_buf
->salt
;
13104 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13106 if (input_len
== 0)
13108 log_error ("VeraCrypt container not specified");
13113 FILE *fp
= fopen (input_buf
, "rb");
13117 log_error ("%s: %s", input_buf
, strerror (errno
));
13122 char buf
[512] = { 0 };
13124 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13128 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13130 memcpy (tc
->salt_buf
, buf
, 64);
13132 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13134 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13136 salt
->salt_len
= 4;
13138 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13140 tc
->signature
= 0x41524556; // "VERA"
13142 digest
[0] = tc
->data_buf
[0];
13144 return (PARSER_OK
);
13147 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13149 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13151 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13153 u32
*digest
= (u32
*) hash_buf
->digest
;
13155 salt_t
*salt
= hash_buf
->salt
;
13157 char *salt_pos
= input_buf
+ 6;
13159 char *hash_pos
= strchr (salt_pos
, '$');
13161 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13163 uint salt_len
= hash_pos
- salt_pos
;
13165 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13167 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13169 salt
->salt_len
= salt_len
;
13171 salt
->salt_iter
= 1000;
13175 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13177 return (PARSER_OK
);
13180 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13182 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13184 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13186 u32
*digest
= (u32
*) hash_buf
->digest
;
13188 salt_t
*salt
= hash_buf
->salt
;
13190 char *iter_pos
= input_buf
+ 7;
13192 char *salt_pos
= strchr (iter_pos
, '$');
13194 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13198 char *hash_pos
= strchr (salt_pos
, '$');
13200 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13202 uint salt_len
= hash_pos
- salt_pos
;
13204 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13206 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13208 salt
->salt_len
= salt_len
;
13210 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13212 salt
->salt_sign
[0] = atoi (salt_iter
);
13214 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13218 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13220 digest
[0] = byte_swap_32 (digest
[0]);
13221 digest
[1] = byte_swap_32 (digest
[1]);
13222 digest
[2] = byte_swap_32 (digest
[2]);
13223 digest
[3] = byte_swap_32 (digest
[3]);
13224 digest
[4] = byte_swap_32 (digest
[4]);
13226 return (PARSER_OK
);
13229 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13231 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13233 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13235 u32
*digest
= (u32
*) hash_buf
->digest
;
13237 salt_t
*salt
= hash_buf
->salt
;
13239 char *iter_pos
= input_buf
+ 9;
13241 char *salt_pos
= strchr (iter_pos
, '$');
13243 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13247 char *hash_pos
= strchr (salt_pos
, '$');
13249 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13251 uint salt_len
= hash_pos
- salt_pos
;
13253 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13255 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13257 salt
->salt_len
= salt_len
;
13259 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13261 salt
->salt_sign
[0] = atoi (salt_iter
);
13263 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13267 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13269 digest
[0] = byte_swap_32 (digest
[0]);
13270 digest
[1] = byte_swap_32 (digest
[1]);
13271 digest
[2] = byte_swap_32 (digest
[2]);
13272 digest
[3] = byte_swap_32 (digest
[3]);
13273 digest
[4] = byte_swap_32 (digest
[4]);
13274 digest
[5] = byte_swap_32 (digest
[5]);
13275 digest
[6] = byte_swap_32 (digest
[6]);
13276 digest
[7] = byte_swap_32 (digest
[7]);
13278 return (PARSER_OK
);
13281 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13283 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13285 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13287 u64
*digest
= (u64
*) hash_buf
->digest
;
13289 salt_t
*salt
= hash_buf
->salt
;
13291 char *iter_pos
= input_buf
+ 9;
13293 char *salt_pos
= strchr (iter_pos
, '$');
13295 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13299 char *hash_pos
= strchr (salt_pos
, '$');
13301 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13303 uint salt_len
= hash_pos
- salt_pos
;
13305 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13307 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13309 salt
->salt_len
= salt_len
;
13311 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13313 salt
->salt_sign
[0] = atoi (salt_iter
);
13315 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13319 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13321 digest
[0] = byte_swap_64 (digest
[0]);
13322 digest
[1] = byte_swap_64 (digest
[1]);
13323 digest
[2] = byte_swap_64 (digest
[2]);
13324 digest
[3] = byte_swap_64 (digest
[3]);
13325 digest
[4] = byte_swap_64 (digest
[4]);
13326 digest
[5] = byte_swap_64 (digest
[5]);
13327 digest
[6] = byte_swap_64 (digest
[6]);
13328 digest
[7] = byte_swap_64 (digest
[7]);
13330 return (PARSER_OK
);
13333 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13335 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13337 u32
*digest
= (u32
*) hash_buf
->digest
;
13339 salt_t
*salt
= hash_buf
->salt
;
13341 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13347 char *iterations_pos
= input_buf
;
13349 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13351 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13353 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13355 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13359 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13361 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13363 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13365 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13367 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13369 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13374 * pbkdf2 iterations
13377 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13380 * handle salt encoding
13383 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13385 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13387 const char p0
= saltbuf_pos
[i
+ 0];
13388 const char p1
= saltbuf_pos
[i
+ 1];
13390 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13391 | hex_convert (p0
) << 4;
13394 salt
->salt_len
= saltbuf_len
/ 2;
13397 * handle cipher encoding
13400 uint
*tmp
= (uint
*) mymalloc (32);
13402 char *cipherbuf_ptr
= (char *) tmp
;
13404 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13406 const char p0
= cipherbuf_pos
[i
+ 0];
13407 const char p1
= cipherbuf_pos
[i
+ 1];
13409 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13410 | hex_convert (p0
) << 4;
13413 // iv is stored at salt_buf 4 (length 16)
13414 // data is stored at salt_buf 8 (length 16)
13416 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13417 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13418 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13419 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13421 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13422 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13423 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13424 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13428 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13430 const char p0
= cipherbuf_pos
[j
+ 0];
13431 const char p1
= cipherbuf_pos
[j
+ 1];
13433 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13434 | hex_convert (p0
) << 4;
13441 digest
[0] = 0x10101010;
13442 digest
[1] = 0x10101010;
13443 digest
[2] = 0x10101010;
13444 digest
[3] = 0x10101010;
13446 return (PARSER_OK
);
13449 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13451 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13453 u32
*digest
= (u32
*) hash_buf
->digest
;
13455 salt_t
*salt
= hash_buf
->salt
;
13457 char *hashbuf_pos
= input_buf
;
13459 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13461 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13463 uint hash_len
= iterations_pos
- hashbuf_pos
;
13465 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13469 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13471 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13473 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13477 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13479 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13481 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13483 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13485 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13487 salt
->salt_len
= salt_len
;
13489 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13491 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13492 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13493 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13494 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13496 return (PARSER_OK
);
13499 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13501 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13503 u32
*digest
= (u32
*) hash_buf
->digest
;
13505 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13506 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13507 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13508 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13509 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13510 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13511 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13512 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13514 digest
[0] = byte_swap_32 (digest
[0]);
13515 digest
[1] = byte_swap_32 (digest
[1]);
13516 digest
[2] = byte_swap_32 (digest
[2]);
13517 digest
[3] = byte_swap_32 (digest
[3]);
13518 digest
[4] = byte_swap_32 (digest
[4]);
13519 digest
[5] = byte_swap_32 (digest
[5]);
13520 digest
[6] = byte_swap_32 (digest
[6]);
13521 digest
[7] = byte_swap_32 (digest
[7]);
13523 return (PARSER_OK
);
13526 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13528 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13530 u32
*digest
= (u32
*) hash_buf
->digest
;
13532 salt_t
*salt
= hash_buf
->salt
;
13534 char *salt_pos
= input_buf
+ 3;
13536 uint iterations_len
= 0;
13538 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13542 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13544 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13545 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13549 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13553 iterations_len
+= 8;
13557 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13560 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13562 char *hash_pos
= strchr (salt_pos
, '$');
13564 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13566 uint salt_len
= hash_pos
- salt_pos
;
13568 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13570 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13572 salt
->salt_len
= salt_len
;
13576 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13578 return (PARSER_OK
);
13581 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13583 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13585 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13587 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13589 u64
*digest
= (u64
*) hash_buf
->digest
;
13591 salt_t
*salt
= hash_buf
->salt
;
13593 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13595 char *iter_pos
= input_buf
+ 4;
13597 char *salt_pos
= strchr (iter_pos
, '$');
13599 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13603 char *hash_pos
= strchr (salt_pos
, '$');
13605 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13607 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13611 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13612 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13613 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13614 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13615 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13616 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13617 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13618 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13620 uint salt_len
= hash_pos
- salt_pos
- 1;
13622 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13624 salt
->salt_len
= salt_len
/ 2;
13626 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13627 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13628 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13629 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13630 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13631 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13632 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13633 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13635 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13636 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13637 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13638 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13639 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13640 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13641 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13642 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13643 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13644 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13646 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13648 salt
->salt_iter
= atoi (iter_pos
) - 1;
13650 return (PARSER_OK
);
13653 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13655 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13657 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13659 u32
*digest
= (u32
*) hash_buf
->digest
;
13661 salt_t
*salt
= hash_buf
->salt
;
13663 char *salt_pos
= input_buf
+ 14;
13665 char *hash_pos
= strchr (salt_pos
, '*');
13667 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13671 uint salt_len
= hash_pos
- salt_pos
- 1;
13673 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13675 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13677 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13679 salt
->salt_len
= salt_len
;
13681 u8 tmp_buf
[100] = { 0 };
13683 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13685 memcpy (digest
, tmp_buf
, 32);
13687 digest
[0] = byte_swap_32 (digest
[0]);
13688 digest
[1] = byte_swap_32 (digest
[1]);
13689 digest
[2] = byte_swap_32 (digest
[2]);
13690 digest
[3] = byte_swap_32 (digest
[3]);
13691 digest
[4] = byte_swap_32 (digest
[4]);
13692 digest
[5] = byte_swap_32 (digest
[5]);
13693 digest
[6] = byte_swap_32 (digest
[6]);
13694 digest
[7] = byte_swap_32 (digest
[7]);
13696 digest
[0] -= SHA256M_A
;
13697 digest
[1] -= SHA256M_B
;
13698 digest
[2] -= SHA256M_C
;
13699 digest
[3] -= SHA256M_D
;
13700 digest
[4] -= SHA256M_E
;
13701 digest
[5] -= SHA256M_F
;
13702 digest
[6] -= SHA256M_G
;
13703 digest
[7] -= SHA256M_H
;
13705 return (PARSER_OK
);
13708 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13710 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13712 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13714 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13716 u64
*digest
= (u64
*) hash_buf
->digest
;
13718 salt_t
*salt
= hash_buf
->salt
;
13720 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13722 char *iter_pos
= input_buf
+ 19;
13724 char *salt_pos
= strchr (iter_pos
, '.');
13726 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13730 char *hash_pos
= strchr (salt_pos
, '.');
13732 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13734 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13738 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13739 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13740 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13741 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13742 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13743 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13744 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13745 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13747 uint salt_len
= hash_pos
- salt_pos
- 1;
13751 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13755 for (i
= 0; i
< salt_len
; i
++)
13757 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13760 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13761 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13763 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13765 salt
->salt_len
= salt_len
;
13767 salt
->salt_iter
= atoi (iter_pos
) - 1;
13769 return (PARSER_OK
);
13772 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13774 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13776 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13778 u64
*digest
= (u64
*) hash_buf
->digest
;
13780 salt_t
*salt
= hash_buf
->salt
;
13782 u8 tmp_buf
[120] = { 0 };
13784 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13786 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13788 memcpy (digest
, tmp_buf
, 64);
13790 digest
[0] = byte_swap_64 (digest
[0]);
13791 digest
[1] = byte_swap_64 (digest
[1]);
13792 digest
[2] = byte_swap_64 (digest
[2]);
13793 digest
[3] = byte_swap_64 (digest
[3]);
13794 digest
[4] = byte_swap_64 (digest
[4]);
13795 digest
[5] = byte_swap_64 (digest
[5]);
13796 digest
[6] = byte_swap_64 (digest
[6]);
13797 digest
[7] = byte_swap_64 (digest
[7]);
13799 digest
[0] -= SHA512M_A
;
13800 digest
[1] -= SHA512M_B
;
13801 digest
[2] -= SHA512M_C
;
13802 digest
[3] -= SHA512M_D
;
13803 digest
[4] -= SHA512M_E
;
13804 digest
[5] -= SHA512M_F
;
13805 digest
[6] -= SHA512M_G
;
13806 digest
[7] -= SHA512M_H
;
13808 int salt_len
= tmp_len
- 64;
13810 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13812 salt
->salt_len
= salt_len
;
13814 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13816 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13818 char *ptr
= (char *) salt
->salt_buf
;
13820 ptr
[salt
->salt_len
] = 0x80;
13823 return (PARSER_OK
);
13826 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13828 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13830 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13834 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13837 u32
*digest
= (u32
*) hash_buf
->digest
;
13839 salt_t
*salt
= hash_buf
->salt
;
13841 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13842 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13843 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13844 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13846 digest
[0] = byte_swap_32 (digest
[0]);
13847 digest
[1] = byte_swap_32 (digest
[1]);
13848 digest
[2] = byte_swap_32 (digest
[2]);
13849 digest
[3] = byte_swap_32 (digest
[3]);
13851 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13853 uint salt_len
= input_len
- 32 - 1;
13855 char *salt_buf
= input_buf
+ 32 + 1;
13857 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13859 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13861 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13863 salt
->salt_len
= salt_len
;
13865 return (PARSER_OK
);
13868 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13870 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13872 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13876 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13879 u32
*digest
= (u32
*) hash_buf
->digest
;
13881 salt_t
*salt
= hash_buf
->salt
;
13883 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13884 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13885 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13886 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13887 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13889 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13891 uint salt_len
= input_len
- 40 - 1;
13893 char *salt_buf
= input_buf
+ 40 + 1;
13895 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13897 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13899 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13901 salt
->salt_len
= salt_len
;
13903 return (PARSER_OK
);
13906 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13908 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13910 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13914 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13917 u32
*digest
= (u32
*) hash_buf
->digest
;
13919 salt_t
*salt
= hash_buf
->salt
;
13921 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13922 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13923 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13924 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13925 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13926 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13927 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13928 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13930 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13932 uint salt_len
= input_len
- 64 - 1;
13934 char *salt_buf
= input_buf
+ 64 + 1;
13936 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13938 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13940 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13942 salt
->salt_len
= salt_len
;
13944 return (PARSER_OK
);
13947 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13949 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13951 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13955 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13958 u64
*digest
= (u64
*) hash_buf
->digest
;
13960 salt_t
*salt
= hash_buf
->salt
;
13962 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13963 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13964 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13965 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13966 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13967 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13968 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13969 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13971 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13973 uint salt_len
= input_len
- 128 - 1;
13975 char *salt_buf
= input_buf
+ 128 + 1;
13977 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13979 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13981 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13983 salt
->salt_len
= salt_len
;
13985 return (PARSER_OK
);
13988 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13990 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13992 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13994 u32
*digest
= (u32
*) hash_buf
->digest
;
13996 salt_t
*salt
= hash_buf
->salt
;
13998 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14004 char *user_pos
= input_buf
+ 10 + 1;
14006 char *realm_pos
= strchr (user_pos
, '$');
14008 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14010 uint user_len
= realm_pos
- user_pos
;
14012 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14016 char *salt_pos
= strchr (realm_pos
, '$');
14018 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14020 uint realm_len
= salt_pos
- realm_pos
;
14022 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14026 char *data_pos
= strchr (salt_pos
, '$');
14028 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14030 uint salt_len
= data_pos
- salt_pos
;
14032 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14036 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14038 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14044 memcpy (krb5pa
->user
, user_pos
, user_len
);
14045 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14046 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14048 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14050 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14052 const char p0
= data_pos
[i
+ 0];
14053 const char p1
= data_pos
[i
+ 1];
14055 *timestamp_ptr
++ = hex_convert (p1
) << 0
14056 | hex_convert (p0
) << 4;
14059 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14061 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14063 const char p0
= data_pos
[i
+ 0];
14064 const char p1
= data_pos
[i
+ 1];
14066 *checksum_ptr
++ = hex_convert (p1
) << 0
14067 | hex_convert (p0
) << 4;
14071 * copy some data to generic buffers to make sorting happy
14074 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14075 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14076 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14077 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14078 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14079 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14080 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14081 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14082 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14084 salt
->salt_len
= 36;
14086 digest
[0] = krb5pa
->checksum
[0];
14087 digest
[1] = krb5pa
->checksum
[1];
14088 digest
[2] = krb5pa
->checksum
[2];
14089 digest
[3] = krb5pa
->checksum
[3];
14091 return (PARSER_OK
);
14094 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14096 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14098 u32
*digest
= (u32
*) hash_buf
->digest
;
14100 salt_t
*salt
= hash_buf
->salt
;
14106 char *salt_pos
= input_buf
;
14108 char *hash_pos
= strchr (salt_pos
, '$');
14110 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14112 uint salt_len
= hash_pos
- salt_pos
;
14114 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14118 uint hash_len
= input_len
- 1 - salt_len
;
14120 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14128 for (uint i
= 0; i
< salt_len
; i
++)
14130 if (salt_pos
[i
] == ' ') continue;
14135 // SAP user names cannot be longer than 12 characters
14136 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14138 // SAP user name cannot start with ! or ?
14139 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14145 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14147 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14149 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14151 salt
->salt_len
= salt_len
;
14153 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14154 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14158 digest
[0] = byte_swap_32 (digest
[0]);
14159 digest
[1] = byte_swap_32 (digest
[1]);
14161 return (PARSER_OK
);
14164 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14166 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14168 u32
*digest
= (u32
*) hash_buf
->digest
;
14170 salt_t
*salt
= hash_buf
->salt
;
14176 char *salt_pos
= input_buf
;
14178 char *hash_pos
= strchr (salt_pos
, '$');
14180 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14182 uint salt_len
= hash_pos
- salt_pos
;
14184 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14188 uint hash_len
= input_len
- 1 - salt_len
;
14190 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14198 for (uint i
= 0; i
< salt_len
; i
++)
14200 if (salt_pos
[i
] == ' ') continue;
14205 // SAP user names cannot be longer than 12 characters
14206 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14207 // so far nobody complained so we stay with this because it helps in optimization
14208 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14210 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14212 // SAP user name cannot start with ! or ?
14213 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14219 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14221 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14223 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14225 salt
->salt_len
= salt_len
;
14227 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14228 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14229 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14230 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14231 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14233 return (PARSER_OK
);
14236 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14238 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14240 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14242 u64
*digest
= (u64
*) hash_buf
->digest
;
14244 salt_t
*salt
= hash_buf
->salt
;
14246 char *iter_pos
= input_buf
+ 3;
14248 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14250 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14252 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14254 salt
->salt_iter
= salt_iter
;
14256 char *salt_pos
= iter_pos
+ 1;
14260 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14262 salt
->salt_len
= salt_len
;
14264 char *hash_pos
= salt_pos
+ salt_len
;
14266 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14270 char *tmp
= (char *) salt
->salt_buf_pc
;
14272 tmp
[0] = hash_pos
[42];
14276 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14277 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14278 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14279 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14285 return (PARSER_OK
);
14288 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14290 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14292 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14294 u32
*digest
= (u32
*) hash_buf
->digest
;
14296 salt_t
*salt
= hash_buf
->salt
;
14298 char *salt_buf
= input_buf
+ 6;
14300 uint salt_len
= 16;
14302 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14304 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14306 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14308 salt
->salt_len
= salt_len
;
14310 char *hash_pos
= input_buf
+ 6 + 16;
14312 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14313 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14314 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14315 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14316 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14317 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14318 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14319 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14321 return (PARSER_OK
);
14324 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14326 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14328 u32
*digest
= (u32
*) hash_buf
->digest
;
14330 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14331 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14335 return (PARSER_OK
);
14338 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14340 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14342 u32
*digest
= (u32
*) hash_buf
->digest
;
14344 salt_t
*salt
= hash_buf
->salt
;
14346 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14348 char *saltbuf_pos
= input_buf
;
14350 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14352 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14354 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14356 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14357 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14359 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14363 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14365 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14367 char *salt_ptr
= (char *) saltbuf_pos
;
14368 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14373 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14375 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14378 rakp_ptr
[j
] = 0x80;
14380 rakp
->salt_len
= j
;
14382 for (i
= 0; i
< 64; i
++)
14384 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14387 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14388 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14389 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14390 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14391 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14392 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14393 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14394 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14396 salt
->salt_len
= 32; // muss min. 32 haben
14398 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14399 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14400 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14401 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14402 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14404 return (PARSER_OK
);
14407 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14409 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14411 u32
*digest
= (u32
*) hash_buf
->digest
;
14413 salt_t
*salt
= hash_buf
->salt
;
14415 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14417 char *salt_pos
= input_buf
+ 1;
14419 memcpy (salt
->salt_buf
, salt_pos
, 8);
14421 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14422 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14424 salt
->salt_len
= 8;
14426 char *hash_pos
= salt_pos
+ 8;
14428 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14429 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14430 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14431 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14432 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14434 digest
[0] -= SHA1M_A
;
14435 digest
[1] -= SHA1M_B
;
14436 digest
[2] -= SHA1M_C
;
14437 digest
[3] -= SHA1M_D
;
14438 digest
[4] -= SHA1M_E
;
14440 return (PARSER_OK
);
14443 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14445 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14447 u32
*digest
= (u32
*) hash_buf
->digest
;
14449 salt_t
*salt
= hash_buf
->salt
;
14451 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14452 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14453 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14454 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14456 digest
[0] = byte_swap_32 (digest
[0]);
14457 digest
[1] = byte_swap_32 (digest
[1]);
14458 digest
[2] = byte_swap_32 (digest
[2]);
14459 digest
[3] = byte_swap_32 (digest
[3]);
14461 digest
[0] -= MD5M_A
;
14462 digest
[1] -= MD5M_B
;
14463 digest
[2] -= MD5M_C
;
14464 digest
[3] -= MD5M_D
;
14466 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14468 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14470 u32
*salt_buf
= salt
->salt_buf
;
14472 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14473 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14474 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14475 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14477 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14478 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14479 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14480 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14482 salt
->salt_len
= 16 + 1;
14484 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14486 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14488 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14490 return (PARSER_OK
);
14493 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14495 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14497 u32
*digest
= (u32
*) hash_buf
->digest
;
14499 salt_t
*salt
= hash_buf
->salt
;
14501 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14507 char *hashbuf_pos
= input_buf
;
14509 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14511 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14513 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14515 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14519 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14521 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14523 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14525 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14529 char *databuf_pos
= strchr (iteration_pos
, ':');
14531 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14533 const uint iteration_len
= databuf_pos
- iteration_pos
;
14535 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14536 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14538 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14540 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14541 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14547 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14548 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14549 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14550 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14551 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14552 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14553 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14554 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14558 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14560 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14562 const char p0
= saltbuf_pos
[i
+ 0];
14563 const char p1
= saltbuf_pos
[i
+ 1];
14565 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14566 | hex_convert (p0
) << 4;
14569 salt
->salt_buf
[4] = 0x01000000;
14570 salt
->salt_buf
[5] = 0x80;
14572 salt
->salt_len
= saltbuf_len
/ 2;
14576 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14580 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14582 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14584 const char p0
= databuf_pos
[i
+ 0];
14585 const char p1
= databuf_pos
[i
+ 1];
14587 *databuf_ptr
++ = hex_convert (p1
) << 0
14588 | hex_convert (p0
) << 4;
14591 *databuf_ptr
++ = 0x80;
14593 for (uint i
= 0; i
< 512; i
++)
14595 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14598 cloudkey
->data_len
= databuf_len
/ 2;
14600 return (PARSER_OK
);
14603 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14605 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14607 u32
*digest
= (u32
*) hash_buf
->digest
;
14609 salt_t
*salt
= hash_buf
->salt
;
14615 char *hashbuf_pos
= input_buf
;
14617 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14619 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14621 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14623 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14627 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14629 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14631 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14633 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14635 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14639 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14641 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14643 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14645 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14647 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14651 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14653 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14654 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14656 // ok, the plan for this algorithm is the following:
14657 // we have 2 salts here, the domain-name and a random salt
14658 // while both are used in the initial transformation,
14659 // only the random salt is used in the following iterations
14660 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14661 // and one that includes only the real salt (stored into salt_buf[]).
14662 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14664 u8 tmp_buf
[100] = { 0 };
14666 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14668 memcpy (digest
, tmp_buf
, 20);
14670 digest
[0] = byte_swap_32 (digest
[0]);
14671 digest
[1] = byte_swap_32 (digest
[1]);
14672 digest
[2] = byte_swap_32 (digest
[2]);
14673 digest
[3] = byte_swap_32 (digest
[3]);
14674 digest
[4] = byte_swap_32 (digest
[4]);
14678 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14680 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14682 char *len_ptr
= NULL
;
14684 for (uint i
= 0; i
< domainbuf_len
; i
++)
14686 if (salt_buf_pc_ptr
[i
] == '.')
14688 len_ptr
= &salt_buf_pc_ptr
[i
];
14698 salt
->salt_buf_pc
[7] = domainbuf_len
;
14702 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14704 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14706 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14708 salt
->salt_len
= salt_len
;
14712 salt
->salt_iter
= atoi (iteration_pos
);
14714 return (PARSER_OK
);
14717 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14719 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14721 u32
*digest
= (u32
*) hash_buf
->digest
;
14723 salt_t
*salt
= hash_buf
->salt
;
14725 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14726 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14727 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14728 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14729 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14731 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14733 uint salt_len
= input_len
- 40 - 1;
14735 char *salt_buf
= input_buf
+ 40 + 1;
14737 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14739 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14741 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14743 salt
->salt_len
= salt_len
;
14745 return (PARSER_OK
);
14748 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14750 const u8 ascii_to_ebcdic
[] =
14752 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14753 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14754 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14755 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14756 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14757 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14758 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14759 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14760 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14761 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14762 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14763 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14764 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14765 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14766 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14767 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14770 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14772 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14774 u32
*digest
= (u32
*) hash_buf
->digest
;
14776 salt_t
*salt
= hash_buf
->salt
;
14778 char *salt_pos
= input_buf
+ 6 + 1;
14780 char *digest_pos
= strchr (salt_pos
, '*');
14782 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14784 uint salt_len
= digest_pos
- salt_pos
;
14786 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14788 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14790 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14794 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14795 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14797 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14799 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14801 salt
->salt_len
= salt_len
;
14803 for (uint i
= 0; i
< salt_len
; i
++)
14805 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14807 for (uint i
= salt_len
; i
< 8; i
++)
14809 salt_buf_pc_ptr
[i
] = 0x40;
14814 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14816 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14817 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14819 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14820 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14822 digest
[0] = byte_swap_32 (digest
[0]);
14823 digest
[1] = byte_swap_32 (digest
[1]);
14825 IP (digest
[0], digest
[1], tt
);
14827 digest
[0] = rotr32 (digest
[0], 29);
14828 digest
[1] = rotr32 (digest
[1], 29);
14832 return (PARSER_OK
);
14835 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14837 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14839 u32
*digest
= (u32
*) hash_buf
->digest
;
14841 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14842 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14843 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14844 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14846 digest
[0] = byte_swap_32 (digest
[0]);
14847 digest
[1] = byte_swap_32 (digest
[1]);
14848 digest
[2] = byte_swap_32 (digest
[2]);
14849 digest
[3] = byte_swap_32 (digest
[3]);
14851 return (PARSER_OK
);
14854 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14856 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14858 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14860 u32
*digest
= (u32
*) hash_buf
->digest
;
14862 salt_t
*salt
= hash_buf
->salt
;
14864 u8 tmp_buf
[120] = { 0 };
14866 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14868 tmp_buf
[3] += -4; // dont ask!
14870 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14872 salt
->salt_len
= 5;
14874 memcpy (digest
, tmp_buf
+ 5, 9);
14876 // yes, only 9 byte are needed to crack, but 10 to display
14878 salt
->salt_buf_pc
[7] = input_buf
[20];
14880 return (PARSER_OK
);
14883 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14885 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14887 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14889 u32
*digest
= (u32
*) hash_buf
->digest
;
14891 salt_t
*salt
= hash_buf
->salt
;
14893 u8 tmp_buf
[120] = { 0 };
14895 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14897 tmp_buf
[3] += -4; // dont ask!
14901 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14903 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)
14907 char tmp_iter_buf
[11] = { 0 };
14909 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14911 tmp_iter_buf
[10] = 0;
14913 salt
->salt_iter
= atoi (tmp_iter_buf
);
14915 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14917 return (PARSER_SALT_ITERATION
);
14920 salt
->salt_iter
--; // first round in init
14922 // 2 additional bytes for display only
14924 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14925 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14929 memcpy (digest
, tmp_buf
+ 28, 8);
14931 digest
[0] = byte_swap_32 (digest
[0]);
14932 digest
[1] = byte_swap_32 (digest
[1]);
14936 return (PARSER_OK
);
14939 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14941 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14943 u32
*digest
= (u32
*) hash_buf
->digest
;
14945 salt_t
*salt
= hash_buf
->salt
;
14947 char *salt_buf_pos
= input_buf
;
14949 char *hash_buf_pos
= salt_buf_pos
+ 6;
14951 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14952 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14953 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14954 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14955 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14956 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14957 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14958 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14960 digest
[0] -= SHA256M_A
;
14961 digest
[1] -= SHA256M_B
;
14962 digest
[2] -= SHA256M_C
;
14963 digest
[3] -= SHA256M_D
;
14964 digest
[4] -= SHA256M_E
;
14965 digest
[5] -= SHA256M_F
;
14966 digest
[6] -= SHA256M_G
;
14967 digest
[7] -= SHA256M_H
;
14969 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14971 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14973 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14975 salt
->salt_len
= salt_len
;
14977 return (PARSER_OK
);
14980 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14982 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14984 u32
*digest
= (u32
*) hash_buf
->digest
;
14986 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14988 salt_t
*salt
= hash_buf
->salt
;
14990 char *salt_buf
= input_buf
+ 6;
14992 char *digest_buf
= strchr (salt_buf
, '$');
14994 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14996 uint salt_len
= digest_buf
- salt_buf
;
14998 digest_buf
++; // skip the '$' symbol
15000 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15002 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15004 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15006 salt
->salt_len
= salt_len
;
15008 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15009 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15010 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15011 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15013 digest
[0] = byte_swap_32 (digest
[0]);
15014 digest
[1] = byte_swap_32 (digest
[1]);
15015 digest
[2] = byte_swap_32 (digest
[2]);
15016 digest
[3] = byte_swap_32 (digest
[3]);
15018 digest
[0] -= MD5M_A
;
15019 digest
[1] -= MD5M_B
;
15020 digest
[2] -= MD5M_C
;
15021 digest
[3] -= MD5M_D
;
15023 return (PARSER_OK
);
15026 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15028 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15030 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15032 u32
*digest
= (u32
*) hash_buf
->digest
;
15034 salt_t
*salt
= hash_buf
->salt
;
15036 char *salt_buf
= input_buf
+ 3;
15038 char *digest_buf
= strchr (salt_buf
, '$');
15040 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15042 uint salt_len
= digest_buf
- salt_buf
;
15044 digest_buf
++; // skip the '$' symbol
15046 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15048 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15050 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15052 salt_buf_ptr
[salt_len
] = 0x2d;
15054 salt
->salt_len
= salt_len
+ 1;
15056 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15057 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15058 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15059 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15061 digest
[0] = byte_swap_32 (digest
[0]);
15062 digest
[1] = byte_swap_32 (digest
[1]);
15063 digest
[2] = byte_swap_32 (digest
[2]);
15064 digest
[3] = byte_swap_32 (digest
[3]);
15066 digest
[0] -= MD5M_A
;
15067 digest
[1] -= MD5M_B
;
15068 digest
[2] -= MD5M_C
;
15069 digest
[3] -= MD5M_D
;
15071 return (PARSER_OK
);
15074 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15076 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15078 u32
*digest
= (u32
*) hash_buf
->digest
;
15080 salt_t
*salt
= hash_buf
->salt
;
15082 u8 tmp_buf
[100] = { 0 };
15084 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15086 memcpy (digest
, tmp_buf
, 20);
15088 digest
[0] = byte_swap_32 (digest
[0]);
15089 digest
[1] = byte_swap_32 (digest
[1]);
15090 digest
[2] = byte_swap_32 (digest
[2]);
15091 digest
[3] = byte_swap_32 (digest
[3]);
15092 digest
[4] = byte_swap_32 (digest
[4]);
15094 digest
[0] -= SHA1M_A
;
15095 digest
[1] -= SHA1M_B
;
15096 digest
[2] -= SHA1M_C
;
15097 digest
[3] -= SHA1M_D
;
15098 digest
[4] -= SHA1M_E
;
15100 salt
->salt_buf
[0] = 0x80;
15102 salt
->salt_len
= 0;
15104 return (PARSER_OK
);
15107 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15109 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15111 u32
*digest
= (u32
*) hash_buf
->digest
;
15113 salt_t
*salt
= hash_buf
->salt
;
15115 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15116 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15117 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15118 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15120 digest
[0] = byte_swap_32 (digest
[0]);
15121 digest
[1] = byte_swap_32 (digest
[1]);
15122 digest
[2] = byte_swap_32 (digest
[2]);
15123 digest
[3] = byte_swap_32 (digest
[3]);
15125 digest
[0] -= MD5M_A
;
15126 digest
[1] -= MD5M_B
;
15127 digest
[2] -= MD5M_C
;
15128 digest
[3] -= MD5M_D
;
15130 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15132 uint salt_len
= input_len
- 32 - 1;
15134 char *salt_buf
= input_buf
+ 32 + 1;
15136 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15138 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15140 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15143 * add static "salt" part
15146 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15150 salt
->salt_len
= salt_len
;
15152 return (PARSER_OK
);
15155 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15157 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15159 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15161 u32
*digest
= (u32
*) hash_buf
->digest
;
15163 salt_t
*salt
= hash_buf
->salt
;
15165 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15171 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15173 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15175 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15177 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15179 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15183 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15185 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15187 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15189 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15193 char *keybuf_pos
= strchr (keylen_pos
, '$');
15195 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15197 uint keylen_len
= keybuf_pos
- keylen_pos
;
15199 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15203 char *databuf_pos
= strchr (keybuf_pos
, '$');
15205 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15207 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15209 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15213 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15215 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15221 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15222 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15223 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15224 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15226 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15227 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15228 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15229 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15231 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15232 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15233 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15234 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15236 salt
->salt_len
= 16;
15237 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15239 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15241 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15244 return (PARSER_OK
);
15247 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15249 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15251 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15253 u32
*digest
= (u32
*) hash_buf
->digest
;
15255 salt_t
*salt
= hash_buf
->salt
;
15261 // first is the N salt parameter
15263 char *N_pos
= input_buf
+ 6;
15265 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15269 salt
->scrypt_N
= atoi (N_pos
);
15273 char *r_pos
= strchr (N_pos
, ':');
15275 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15279 salt
->scrypt_r
= atoi (r_pos
);
15283 char *p_pos
= strchr (r_pos
, ':');
15285 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15289 salt
->scrypt_p
= atoi (p_pos
);
15293 char *saltbuf_pos
= strchr (p_pos
, ':');
15295 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15299 char *hash_pos
= strchr (saltbuf_pos
, ':');
15301 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15307 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15309 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15311 u8 tmp_buf
[33] = { 0 };
15313 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15315 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15317 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15319 salt
->salt_len
= tmp_len
;
15320 salt
->salt_iter
= 1;
15322 // digest - base64 decode
15324 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15326 tmp_len
= input_len
- (hash_pos
- input_buf
);
15328 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15330 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15332 memcpy (digest
, tmp_buf
, 32);
15334 return (PARSER_OK
);
15337 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15339 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15341 u32
*digest
= (u32
*) hash_buf
->digest
;
15343 salt_t
*salt
= hash_buf
->salt
;
15349 char decrypted
[76] = { 0 }; // iv + hash
15351 juniper_decrypt_hash (input_buf
, decrypted
);
15353 char *md5crypt_hash
= decrypted
+ 12;
15355 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15357 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15359 char *salt_pos
= md5crypt_hash
+ 3;
15361 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15363 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15365 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15369 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15371 return (PARSER_OK
);
15374 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15376 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15378 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15380 u32
*digest
= (u32
*) hash_buf
->digest
;
15382 salt_t
*salt
= hash_buf
->salt
;
15384 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15390 // first is *raw* salt
15392 char *salt_pos
= input_buf
+ 3;
15394 char *hash_pos
= strchr (salt_pos
, '$');
15396 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15398 uint salt_len
= hash_pos
- salt_pos
;
15400 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15404 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15406 memcpy (salt_buf_ptr
, salt_pos
, 14);
15408 salt_buf_ptr
[17] = 0x01;
15409 salt_buf_ptr
[18] = 0x80;
15411 // add some stuff to normal salt to make sorted happy
15413 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15414 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15415 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15416 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15418 salt
->salt_len
= salt_len
;
15419 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15421 // base64 decode hash
15423 u8 tmp_buf
[100] = { 0 };
15425 uint hash_len
= input_len
- 3 - salt_len
- 1;
15427 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15429 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15431 memcpy (digest
, tmp_buf
, 32);
15433 digest
[0] = byte_swap_32 (digest
[0]);
15434 digest
[1] = byte_swap_32 (digest
[1]);
15435 digest
[2] = byte_swap_32 (digest
[2]);
15436 digest
[3] = byte_swap_32 (digest
[3]);
15437 digest
[4] = byte_swap_32 (digest
[4]);
15438 digest
[5] = byte_swap_32 (digest
[5]);
15439 digest
[6] = byte_swap_32 (digest
[6]);
15440 digest
[7] = byte_swap_32 (digest
[7]);
15442 return (PARSER_OK
);
15445 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15447 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15449 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15451 u32
*digest
= (u32
*) hash_buf
->digest
;
15453 salt_t
*salt
= hash_buf
->salt
;
15459 // first is *raw* salt
15461 char *salt_pos
= input_buf
+ 3;
15463 char *hash_pos
= strchr (salt_pos
, '$');
15465 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15467 uint salt_len
= hash_pos
- salt_pos
;
15469 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15471 salt
->salt_len
= salt_len
;
15474 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15476 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15477 salt_buf_ptr
[salt_len
] = 0;
15479 // base64 decode hash
15481 u8 tmp_buf
[100] = { 0 };
15483 uint hash_len
= input_len
- 3 - salt_len
- 1;
15485 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15487 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15489 memcpy (digest
, tmp_buf
, 32);
15492 salt
->scrypt_N
= 16384;
15493 salt
->scrypt_r
= 1;
15494 salt
->scrypt_p
= 1;
15495 salt
->salt_iter
= 1;
15497 return (PARSER_OK
);
15500 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15502 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15504 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15506 u32
*digest
= (u32
*) hash_buf
->digest
;
15508 salt_t
*salt
= hash_buf
->salt
;
15510 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15516 char *version_pos
= input_buf
+ 8 + 1;
15518 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15520 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15522 u32 version_len
= verifierHashSize_pos
- version_pos
;
15524 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15526 verifierHashSize_pos
++;
15528 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15530 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15532 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15534 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15538 char *saltSize_pos
= strchr (keySize_pos
, '*');
15540 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15542 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15544 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15548 char *osalt_pos
= strchr (saltSize_pos
, '*');
15550 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15552 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15554 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15558 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15560 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15562 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15564 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15566 encryptedVerifier_pos
++;
15568 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15570 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15572 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15574 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15576 encryptedVerifierHash_pos
++;
15578 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;
15580 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15582 const uint version
= atoi (version_pos
);
15584 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15586 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15588 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15590 const uint keySize
= atoi (keySize_pos
);
15592 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15594 office2007
->keySize
= keySize
;
15596 const uint saltSize
= atoi (saltSize_pos
);
15598 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15604 salt
->salt_len
= 16;
15605 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15607 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15608 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15609 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15610 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15616 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15617 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15618 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15619 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15621 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15622 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15623 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15624 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15625 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15631 digest
[0] = office2007
->encryptedVerifierHash
[0];
15632 digest
[1] = office2007
->encryptedVerifierHash
[1];
15633 digest
[2] = office2007
->encryptedVerifierHash
[2];
15634 digest
[3] = office2007
->encryptedVerifierHash
[3];
15636 return (PARSER_OK
);
15639 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15641 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15643 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15645 u32
*digest
= (u32
*) hash_buf
->digest
;
15647 salt_t
*salt
= hash_buf
->salt
;
15649 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15655 char *version_pos
= input_buf
+ 8 + 1;
15657 char *spinCount_pos
= strchr (version_pos
, '*');
15659 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15661 u32 version_len
= spinCount_pos
- version_pos
;
15663 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15667 char *keySize_pos
= strchr (spinCount_pos
, '*');
15669 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15671 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15673 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15677 char *saltSize_pos
= strchr (keySize_pos
, '*');
15679 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15681 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15683 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15687 char *osalt_pos
= strchr (saltSize_pos
, '*');
15689 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15691 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15693 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15697 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15699 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15701 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15703 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15705 encryptedVerifier_pos
++;
15707 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15709 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15711 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15713 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15715 encryptedVerifierHash_pos
++;
15717 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;
15719 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15721 const uint version
= atoi (version_pos
);
15723 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15725 const uint spinCount
= atoi (spinCount_pos
);
15727 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15729 const uint keySize
= atoi (keySize_pos
);
15731 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15733 const uint saltSize
= atoi (saltSize_pos
);
15735 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15741 salt
->salt_len
= 16;
15742 salt
->salt_iter
= spinCount
;
15744 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15745 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15746 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15747 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15753 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15754 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15755 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15756 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15758 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15759 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15760 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15761 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15762 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15763 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15764 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15765 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15771 digest
[0] = office2010
->encryptedVerifierHash
[0];
15772 digest
[1] = office2010
->encryptedVerifierHash
[1];
15773 digest
[2] = office2010
->encryptedVerifierHash
[2];
15774 digest
[3] = office2010
->encryptedVerifierHash
[3];
15776 return (PARSER_OK
);
15779 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15781 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15783 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15785 u32
*digest
= (u32
*) hash_buf
->digest
;
15787 salt_t
*salt
= hash_buf
->salt
;
15789 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15795 char *version_pos
= input_buf
+ 8 + 1;
15797 char *spinCount_pos
= strchr (version_pos
, '*');
15799 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15801 u32 version_len
= spinCount_pos
- version_pos
;
15803 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15807 char *keySize_pos
= strchr (spinCount_pos
, '*');
15809 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15811 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15813 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15817 char *saltSize_pos
= strchr (keySize_pos
, '*');
15819 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15821 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15823 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15827 char *osalt_pos
= strchr (saltSize_pos
, '*');
15829 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15831 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15833 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15837 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15839 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15841 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15843 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15845 encryptedVerifier_pos
++;
15847 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15849 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15851 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15853 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15855 encryptedVerifierHash_pos
++;
15857 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;
15859 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15861 const uint version
= atoi (version_pos
);
15863 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15865 const uint spinCount
= atoi (spinCount_pos
);
15867 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15869 const uint keySize
= atoi (keySize_pos
);
15871 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15873 const uint saltSize
= atoi (saltSize_pos
);
15875 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15881 salt
->salt_len
= 16;
15882 salt
->salt_iter
= spinCount
;
15884 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15885 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15886 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15887 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15893 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15894 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15895 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15896 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15898 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15899 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15900 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15901 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15902 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15903 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15904 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15905 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15911 digest
[0] = office2013
->encryptedVerifierHash
[0];
15912 digest
[1] = office2013
->encryptedVerifierHash
[1];
15913 digest
[2] = office2013
->encryptedVerifierHash
[2];
15914 digest
[3] = office2013
->encryptedVerifierHash
[3];
15916 return (PARSER_OK
);
15919 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15921 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15923 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15925 u32
*digest
= (u32
*) hash_buf
->digest
;
15927 salt_t
*salt
= hash_buf
->salt
;
15929 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15935 char *version_pos
= input_buf
+ 11;
15937 char *osalt_pos
= strchr (version_pos
, '*');
15939 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15941 u32 version_len
= osalt_pos
- version_pos
;
15943 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15947 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15949 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15951 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15953 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15955 encryptedVerifier_pos
++;
15957 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15959 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15961 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15963 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15965 encryptedVerifierHash_pos
++;
15967 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15969 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15971 const uint version
= *version_pos
- 0x30;
15973 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15979 oldoffice01
->version
= version
;
15981 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15982 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15983 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15984 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15986 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15987 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15988 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15989 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15991 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15992 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15993 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15994 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15996 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15997 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15998 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15999 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16005 salt
->salt_len
= 16;
16007 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16008 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16009 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16010 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16012 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16013 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16014 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16015 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16017 // this is a workaround as office produces multiple documents with the same salt
16019 salt
->salt_len
+= 32;
16021 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16022 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16023 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16024 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16025 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16026 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16027 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16028 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16034 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16035 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16036 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16037 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16039 return (PARSER_OK
);
16042 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16044 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16047 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16049 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16051 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16053 u32
*digest
= (u32
*) hash_buf
->digest
;
16055 salt_t
*salt
= hash_buf
->salt
;
16057 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16063 char *version_pos
= input_buf
+ 11;
16065 char *osalt_pos
= strchr (version_pos
, '*');
16067 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16069 u32 version_len
= osalt_pos
- version_pos
;
16071 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16075 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16077 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16079 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16081 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16083 encryptedVerifier_pos
++;
16085 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16087 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16089 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16091 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16093 encryptedVerifierHash_pos
++;
16095 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16097 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16099 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16101 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16105 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16107 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16109 const uint version
= *version_pos
- 0x30;
16111 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16117 oldoffice01
->version
= version
;
16119 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16120 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16121 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16122 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16124 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16125 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16126 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16127 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16129 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16130 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16131 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16132 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16134 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16135 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16136 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16137 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16139 oldoffice01
->rc4key
[1] = 0;
16140 oldoffice01
->rc4key
[0] = 0;
16142 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16143 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16144 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16145 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16146 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16147 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16148 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16149 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16150 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16151 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16153 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16154 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16160 salt
->salt_len
= 16;
16162 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16163 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16164 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16165 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16167 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16168 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16169 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16170 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16172 // this is a workaround as office produces multiple documents with the same salt
16174 salt
->salt_len
+= 32;
16176 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16177 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16178 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16179 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16180 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16181 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16182 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16183 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16189 digest
[0] = oldoffice01
->rc4key
[0];
16190 digest
[1] = oldoffice01
->rc4key
[1];
16194 return (PARSER_OK
);
16197 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16199 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16201 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16203 u32
*digest
= (u32
*) hash_buf
->digest
;
16205 salt_t
*salt
= hash_buf
->salt
;
16207 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16213 char *version_pos
= input_buf
+ 11;
16215 char *osalt_pos
= strchr (version_pos
, '*');
16217 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16219 u32 version_len
= osalt_pos
- version_pos
;
16221 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16225 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16227 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16229 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16231 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16233 encryptedVerifier_pos
++;
16235 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16237 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16239 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16241 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16243 encryptedVerifierHash_pos
++;
16245 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16247 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16249 const uint version
= *version_pos
- 0x30;
16251 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16257 oldoffice34
->version
= version
;
16259 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16260 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16261 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16262 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16264 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16265 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16266 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16267 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16269 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16270 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16271 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16272 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16273 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16275 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16276 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16277 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16278 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16279 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16285 salt
->salt_len
= 16;
16287 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16288 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16289 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16290 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16292 // this is a workaround as office produces multiple documents with the same salt
16294 salt
->salt_len
+= 32;
16296 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16297 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16298 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16299 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16300 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16301 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16302 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16303 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16309 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16310 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16311 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16312 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16314 return (PARSER_OK
);
16317 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16319 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16321 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16324 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16326 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16328 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16330 u32
*digest
= (u32
*) hash_buf
->digest
;
16332 salt_t
*salt
= hash_buf
->salt
;
16334 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16340 char *version_pos
= input_buf
+ 11;
16342 char *osalt_pos
= strchr (version_pos
, '*');
16344 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16346 u32 version_len
= osalt_pos
- version_pos
;
16348 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16352 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16354 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16356 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16358 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16360 encryptedVerifier_pos
++;
16362 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16364 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16366 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16368 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16370 encryptedVerifierHash_pos
++;
16372 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16374 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16376 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16378 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16382 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16384 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16386 const uint version
= *version_pos
- 0x30;
16388 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16394 oldoffice34
->version
= version
;
16396 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16397 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16398 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16399 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16401 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16402 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16403 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16404 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16406 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16407 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16408 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16409 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16410 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16412 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16413 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16414 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16415 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16416 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16418 oldoffice34
->rc4key
[1] = 0;
16419 oldoffice34
->rc4key
[0] = 0;
16421 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16422 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16423 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16424 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16425 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16426 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16427 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16428 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16429 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16430 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16432 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16433 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16439 salt
->salt_len
= 16;
16441 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16442 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16443 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16444 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16446 // this is a workaround as office produces multiple documents with the same salt
16448 salt
->salt_len
+= 32;
16450 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16451 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16452 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16453 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16454 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16455 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16456 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16457 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16463 digest
[0] = oldoffice34
->rc4key
[0];
16464 digest
[1] = oldoffice34
->rc4key
[1];
16468 return (PARSER_OK
);
16471 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16473 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16475 u32
*digest
= (u32
*) hash_buf
->digest
;
16477 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16478 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16479 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16480 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16482 digest
[0] = byte_swap_32 (digest
[0]);
16483 digest
[1] = byte_swap_32 (digest
[1]);
16484 digest
[2] = byte_swap_32 (digest
[2]);
16485 digest
[3] = byte_swap_32 (digest
[3]);
16487 return (PARSER_OK
);
16490 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16492 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16494 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16496 u32
*digest
= (u32
*) hash_buf
->digest
;
16498 salt_t
*salt
= hash_buf
->salt
;
16500 char *signature_pos
= input_buf
;
16502 char *salt_pos
= strchr (signature_pos
, '$');
16504 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16506 u32 signature_len
= salt_pos
- signature_pos
;
16508 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16512 char *hash_pos
= strchr (salt_pos
, '$');
16514 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16516 u32 salt_len
= hash_pos
- salt_pos
;
16518 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16522 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16524 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16526 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16527 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16528 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16529 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16530 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16532 digest
[0] -= SHA1M_A
;
16533 digest
[1] -= SHA1M_B
;
16534 digest
[2] -= SHA1M_C
;
16535 digest
[3] -= SHA1M_D
;
16536 digest
[4] -= SHA1M_E
;
16538 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16540 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16542 salt
->salt_len
= salt_len
;
16544 return (PARSER_OK
);
16547 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16549 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16551 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16553 u32
*digest
= (u32
*) hash_buf
->digest
;
16555 salt_t
*salt
= hash_buf
->salt
;
16557 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16563 char *iter_pos
= input_buf
+ 14;
16565 const int iter
= atoi (iter_pos
);
16567 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16569 salt
->salt_iter
= iter
- 1;
16571 char *salt_pos
= strchr (iter_pos
, '$');
16573 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16577 char *hash_pos
= strchr (salt_pos
, '$');
16579 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16581 const uint salt_len
= hash_pos
- salt_pos
;
16585 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16587 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16589 salt
->salt_len
= salt_len
;
16591 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16592 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16594 // add some stuff to normal salt to make sorted happy
16596 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16597 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16598 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16599 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16600 salt
->salt_buf
[4] = salt
->salt_iter
;
16602 // base64 decode hash
16604 u8 tmp_buf
[100] = { 0 };
16606 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16608 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16610 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16612 memcpy (digest
, tmp_buf
, 32);
16614 digest
[0] = byte_swap_32 (digest
[0]);
16615 digest
[1] = byte_swap_32 (digest
[1]);
16616 digest
[2] = byte_swap_32 (digest
[2]);
16617 digest
[3] = byte_swap_32 (digest
[3]);
16618 digest
[4] = byte_swap_32 (digest
[4]);
16619 digest
[5] = byte_swap_32 (digest
[5]);
16620 digest
[6] = byte_swap_32 (digest
[6]);
16621 digest
[7] = byte_swap_32 (digest
[7]);
16623 return (PARSER_OK
);
16626 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16628 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16630 u32
*digest
= (u32
*) hash_buf
->digest
;
16632 salt_t
*salt
= hash_buf
->salt
;
16634 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16635 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16639 digest
[0] = byte_swap_32 (digest
[0]);
16640 digest
[1] = byte_swap_32 (digest
[1]);
16642 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16643 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16644 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16646 char iter_c
= input_buf
[17];
16647 char iter_d
= input_buf
[19];
16649 // atm only defaults, let's see if there's more request
16650 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16651 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16653 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16655 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16656 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16657 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16658 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16660 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16661 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16662 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16663 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16665 salt
->salt_len
= 16;
16667 return (PARSER_OK
);
16670 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16672 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16674 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16676 u32
*digest
= (u32
*) hash_buf
->digest
;
16678 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16680 salt_t
*salt
= hash_buf
->salt
;
16682 char *salt_pos
= input_buf
+ 10;
16684 char *hash_pos
= strchr (salt_pos
, '$');
16686 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16688 uint salt_len
= hash_pos
- salt_pos
;
16692 uint hash_len
= input_len
- 10 - salt_len
- 1;
16694 // base64 decode salt
16696 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16698 u8 tmp_buf
[100] = { 0 };
16700 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16702 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16704 tmp_buf
[salt_len
] = 0x80;
16706 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16708 salt
->salt_len
= salt_len
;
16710 // base64 decode hash
16712 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16714 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16716 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16718 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16720 uint user_len
= hash_len
- 32;
16722 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16724 user_len
--; // skip the trailing space
16726 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16727 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16728 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16729 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16731 digest
[0] = byte_swap_32 (digest
[0]);
16732 digest
[1] = byte_swap_32 (digest
[1]);
16733 digest
[2] = byte_swap_32 (digest
[2]);
16734 digest
[3] = byte_swap_32 (digest
[3]);
16736 // store username for host only (output hash if cracked)
16738 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16739 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16741 return (PARSER_OK
);
16744 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16746 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16748 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16750 u32
*digest
= (u32
*) hash_buf
->digest
;
16752 salt_t
*salt
= hash_buf
->salt
;
16754 char *iter_pos
= input_buf
+ 10;
16756 u32 iter
= atoi (iter_pos
);
16760 return (PARSER_SALT_ITERATION
);
16763 iter
--; // first iteration is special
16765 salt
->salt_iter
= iter
;
16767 char *base64_pos
= strchr (iter_pos
, '}');
16769 if (base64_pos
== NULL
)
16771 return (PARSER_SIGNATURE_UNMATCHED
);
16776 // base64 decode salt
16778 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16780 u8 tmp_buf
[100] = { 0 };
16782 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16784 if (decoded_len
< 24)
16786 return (PARSER_SALT_LENGTH
);
16791 uint salt_len
= decoded_len
- 20;
16793 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16794 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16796 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16798 salt
->salt_len
= salt_len
;
16802 u32
*digest_ptr
= (u32
*) tmp_buf
;
16804 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16805 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16806 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16807 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16808 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16810 return (PARSER_OK
);
16813 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16815 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16817 u32
*digest
= (u32
*) hash_buf
->digest
;
16819 salt_t
*salt
= hash_buf
->salt
;
16821 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16822 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16823 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16824 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16825 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16827 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16829 uint salt_len
= input_len
- 40 - 1;
16831 char *salt_buf
= input_buf
+ 40 + 1;
16833 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16835 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16837 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16839 salt
->salt_len
= salt_len
;
16841 return (PARSER_OK
);
16844 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16846 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16848 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16850 u32
*digest
= (u32
*) hash_buf
->digest
;
16852 salt_t
*salt
= hash_buf
->salt
;
16854 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16860 char *V_pos
= input_buf
+ 5;
16862 char *R_pos
= strchr (V_pos
, '*');
16864 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16866 u32 V_len
= R_pos
- V_pos
;
16870 char *bits_pos
= strchr (R_pos
, '*');
16872 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16874 u32 R_len
= bits_pos
- R_pos
;
16878 char *P_pos
= strchr (bits_pos
, '*');
16880 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16882 u32 bits_len
= P_pos
- bits_pos
;
16886 char *enc_md_pos
= strchr (P_pos
, '*');
16888 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16890 u32 P_len
= enc_md_pos
- P_pos
;
16894 char *id_len_pos
= strchr (enc_md_pos
, '*');
16896 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16898 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16902 char *id_buf_pos
= strchr (id_len_pos
, '*');
16904 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16906 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16910 char *u_len_pos
= strchr (id_buf_pos
, '*');
16912 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16914 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16916 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16920 char *u_buf_pos
= strchr (u_len_pos
, '*');
16922 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16924 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16928 char *o_len_pos
= strchr (u_buf_pos
, '*');
16930 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16932 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16934 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16938 char *o_buf_pos
= strchr (o_len_pos
, '*');
16940 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16942 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16946 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;
16948 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16952 const int V
= atoi (V_pos
);
16953 const int R
= atoi (R_pos
);
16954 const int P
= atoi (P_pos
);
16956 if (V
!= 1) return (PARSER_SALT_VALUE
);
16957 if (R
!= 2) return (PARSER_SALT_VALUE
);
16959 const int enc_md
= atoi (enc_md_pos
);
16961 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16963 const int id_len
= atoi (id_len_pos
);
16964 const int u_len
= atoi (u_len_pos
);
16965 const int o_len
= atoi (o_len_pos
);
16967 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16968 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16969 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16971 const int bits
= atoi (bits_pos
);
16973 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16975 // copy data to esalt
16981 pdf
->enc_md
= enc_md
;
16983 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16984 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16985 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16986 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16987 pdf
->id_len
= id_len
;
16989 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16990 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16991 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16992 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16993 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16994 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16995 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16996 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16997 pdf
->u_len
= u_len
;
16999 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17000 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17001 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17002 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17003 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17004 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17005 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17006 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17007 pdf
->o_len
= o_len
;
17009 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17010 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17011 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17012 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17014 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17015 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17016 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17017 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17018 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17019 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17020 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17021 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17023 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17024 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17025 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17026 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17027 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17028 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17029 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17030 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17032 // we use ID for salt, maybe needs to change, we will see...
17034 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17035 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17036 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17037 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17038 salt
->salt_len
= pdf
->id_len
;
17040 digest
[0] = pdf
->u_buf
[0];
17041 digest
[1] = pdf
->u_buf
[1];
17042 digest
[2] = pdf
->u_buf
[2];
17043 digest
[3] = pdf
->u_buf
[3];
17045 return (PARSER_OK
);
17048 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17050 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17053 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17055 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17057 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17059 u32
*digest
= (u32
*) hash_buf
->digest
;
17061 salt_t
*salt
= hash_buf
->salt
;
17063 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17069 char *V_pos
= input_buf
+ 5;
17071 char *R_pos
= strchr (V_pos
, '*');
17073 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17075 u32 V_len
= R_pos
- V_pos
;
17079 char *bits_pos
= strchr (R_pos
, '*');
17081 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17083 u32 R_len
= bits_pos
- R_pos
;
17087 char *P_pos
= strchr (bits_pos
, '*');
17089 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17091 u32 bits_len
= P_pos
- bits_pos
;
17095 char *enc_md_pos
= strchr (P_pos
, '*');
17097 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17099 u32 P_len
= enc_md_pos
- P_pos
;
17103 char *id_len_pos
= strchr (enc_md_pos
, '*');
17105 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17107 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17111 char *id_buf_pos
= strchr (id_len_pos
, '*');
17113 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17115 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17119 char *u_len_pos
= strchr (id_buf_pos
, '*');
17121 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17123 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17125 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17129 char *u_buf_pos
= strchr (u_len_pos
, '*');
17131 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17133 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17137 char *o_len_pos
= strchr (u_buf_pos
, '*');
17139 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17141 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17143 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17147 char *o_buf_pos
= strchr (o_len_pos
, '*');
17149 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17151 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17155 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17157 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17159 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17161 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17165 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;
17167 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17171 const int V
= atoi (V_pos
);
17172 const int R
= atoi (R_pos
);
17173 const int P
= atoi (P_pos
);
17175 if (V
!= 1) return (PARSER_SALT_VALUE
);
17176 if (R
!= 2) return (PARSER_SALT_VALUE
);
17178 const int enc_md
= atoi (enc_md_pos
);
17180 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17182 const int id_len
= atoi (id_len_pos
);
17183 const int u_len
= atoi (u_len_pos
);
17184 const int o_len
= atoi (o_len_pos
);
17186 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17187 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17188 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17190 const int bits
= atoi (bits_pos
);
17192 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17194 // copy data to esalt
17200 pdf
->enc_md
= enc_md
;
17202 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17203 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17204 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17205 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17206 pdf
->id_len
= id_len
;
17208 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17209 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17210 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17211 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17212 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17213 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17214 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17215 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17216 pdf
->u_len
= u_len
;
17218 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17219 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17220 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17221 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17222 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17223 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17224 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17225 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17226 pdf
->o_len
= o_len
;
17228 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17229 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17230 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17231 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17233 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17234 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17235 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17236 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17237 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17238 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17239 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17240 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17242 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17243 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17244 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17245 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17246 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17247 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17248 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17249 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17251 pdf
->rc4key
[1] = 0;
17252 pdf
->rc4key
[0] = 0;
17254 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17255 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17256 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17257 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17258 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17259 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17260 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17261 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17262 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17263 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17265 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17266 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17268 // we use ID for salt, maybe needs to change, we will see...
17270 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17271 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17272 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17273 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17274 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17275 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17276 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17277 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17278 salt
->salt_len
= pdf
->id_len
+ 16;
17280 digest
[0] = pdf
->rc4key
[0];
17281 digest
[1] = pdf
->rc4key
[1];
17285 return (PARSER_OK
);
17288 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17290 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17292 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17294 u32
*digest
= (u32
*) hash_buf
->digest
;
17296 salt_t
*salt
= hash_buf
->salt
;
17298 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17304 char *V_pos
= input_buf
+ 5;
17306 char *R_pos
= strchr (V_pos
, '*');
17308 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17310 u32 V_len
= R_pos
- V_pos
;
17314 char *bits_pos
= strchr (R_pos
, '*');
17316 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17318 u32 R_len
= bits_pos
- R_pos
;
17322 char *P_pos
= strchr (bits_pos
, '*');
17324 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17326 u32 bits_len
= P_pos
- bits_pos
;
17330 char *enc_md_pos
= strchr (P_pos
, '*');
17332 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17334 u32 P_len
= enc_md_pos
- P_pos
;
17338 char *id_len_pos
= strchr (enc_md_pos
, '*');
17340 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17342 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17346 char *id_buf_pos
= strchr (id_len_pos
, '*');
17348 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17350 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17354 char *u_len_pos
= strchr (id_buf_pos
, '*');
17356 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17358 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17360 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17364 char *u_buf_pos
= strchr (u_len_pos
, '*');
17366 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17368 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17372 char *o_len_pos
= strchr (u_buf_pos
, '*');
17374 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17376 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17378 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17382 char *o_buf_pos
= strchr (o_len_pos
, '*');
17384 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17386 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17390 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;
17392 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17396 const int V
= atoi (V_pos
);
17397 const int R
= atoi (R_pos
);
17398 const int P
= atoi (P_pos
);
17402 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17403 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17405 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17407 const int id_len
= atoi (id_len_pos
);
17408 const int u_len
= atoi (u_len_pos
);
17409 const int o_len
= atoi (o_len_pos
);
17411 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17413 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17414 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17416 const int bits
= atoi (bits_pos
);
17418 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17424 enc_md
= atoi (enc_md_pos
);
17427 // copy data to esalt
17433 pdf
->enc_md
= enc_md
;
17435 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17436 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17437 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17438 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17442 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17443 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17444 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17445 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17448 pdf
->id_len
= id_len
;
17450 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17451 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17452 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17453 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17454 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17455 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17456 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17457 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17458 pdf
->u_len
= u_len
;
17460 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17461 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17462 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17463 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17464 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17465 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17466 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17467 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17468 pdf
->o_len
= o_len
;
17470 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17471 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17472 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17473 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17477 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17478 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17479 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17480 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17483 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17484 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17485 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17486 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17487 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17488 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17489 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17490 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17492 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17493 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17494 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17495 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17496 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17497 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17498 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17499 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17501 // precompute rc4 data for later use
17517 uint salt_pc_block
[32] = { 0 };
17519 char *salt_pc_ptr
= (char *) salt_pc_block
;
17521 memcpy (salt_pc_ptr
, padding
, 32);
17522 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17524 uint salt_pc_digest
[4] = { 0 };
17526 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17528 pdf
->rc4data
[0] = salt_pc_digest
[0];
17529 pdf
->rc4data
[1] = salt_pc_digest
[1];
17531 // we use ID for salt, maybe needs to change, we will see...
17533 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17534 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17535 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17536 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17537 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17538 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17539 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17540 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17541 salt
->salt_len
= pdf
->id_len
+ 16;
17543 salt
->salt_iter
= ROUNDS_PDF14
;
17545 digest
[0] = pdf
->u_buf
[0];
17546 digest
[1] = pdf
->u_buf
[1];
17550 return (PARSER_OK
);
17553 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17555 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17557 if (ret
!= PARSER_OK
)
17562 u32
*digest
= (u32
*) hash_buf
->digest
;
17564 salt_t
*salt
= hash_buf
->salt
;
17566 digest
[0] -= SHA256M_A
;
17567 digest
[1] -= SHA256M_B
;
17568 digest
[2] -= SHA256M_C
;
17569 digest
[3] -= SHA256M_D
;
17570 digest
[4] -= SHA256M_E
;
17571 digest
[5] -= SHA256M_F
;
17572 digest
[6] -= SHA256M_G
;
17573 digest
[7] -= SHA256M_H
;
17575 salt
->salt_buf
[2] = 0x80;
17577 return (PARSER_OK
);
17580 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17582 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17584 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17586 u32
*digest
= (u32
*) hash_buf
->digest
;
17588 salt_t
*salt
= hash_buf
->salt
;
17590 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17596 char *V_pos
= input_buf
+ 5;
17598 char *R_pos
= strchr (V_pos
, '*');
17600 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17602 u32 V_len
= R_pos
- V_pos
;
17606 char *bits_pos
= strchr (R_pos
, '*');
17608 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17610 u32 R_len
= bits_pos
- R_pos
;
17614 char *P_pos
= strchr (bits_pos
, '*');
17616 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17618 u32 bits_len
= P_pos
- bits_pos
;
17622 char *enc_md_pos
= strchr (P_pos
, '*');
17624 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17626 u32 P_len
= enc_md_pos
- P_pos
;
17630 char *id_len_pos
= strchr (enc_md_pos
, '*');
17632 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17634 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17638 char *id_buf_pos
= strchr (id_len_pos
, '*');
17640 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17642 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17646 char *u_len_pos
= strchr (id_buf_pos
, '*');
17648 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17650 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17654 char *u_buf_pos
= strchr (u_len_pos
, '*');
17656 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17658 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17662 char *o_len_pos
= strchr (u_buf_pos
, '*');
17664 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17666 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17670 char *o_buf_pos
= strchr (o_len_pos
, '*');
17672 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17674 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17678 char *last
= strchr (o_buf_pos
, '*');
17680 if (last
== NULL
) last
= input_buf
+ input_len
;
17682 u32 o_buf_len
= last
- o_buf_pos
;
17686 const int V
= atoi (V_pos
);
17687 const int R
= atoi (R_pos
);
17691 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17692 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17694 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17696 const int bits
= atoi (bits_pos
);
17698 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17700 int enc_md
= atoi (enc_md_pos
);
17702 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17704 const uint id_len
= atoi (id_len_pos
);
17705 const uint u_len
= atoi (u_len_pos
);
17706 const uint o_len
= atoi (o_len_pos
);
17708 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17709 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17710 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17711 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17712 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17713 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17714 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17715 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17717 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17718 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17719 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17721 // copy data to esalt
17723 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17725 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17727 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17730 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17731 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17733 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17734 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17736 salt
->salt_len
= 8;
17737 salt
->salt_iter
= ROUNDS_PDF17L8
;
17739 digest
[0] = pdf
->u_buf
[0];
17740 digest
[1] = pdf
->u_buf
[1];
17741 digest
[2] = pdf
->u_buf
[2];
17742 digest
[3] = pdf
->u_buf
[3];
17743 digest
[4] = pdf
->u_buf
[4];
17744 digest
[5] = pdf
->u_buf
[5];
17745 digest
[6] = pdf
->u_buf
[6];
17746 digest
[7] = pdf
->u_buf
[7];
17748 return (PARSER_OK
);
17751 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17753 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17755 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17757 u32
*digest
= (u32
*) hash_buf
->digest
;
17759 salt_t
*salt
= hash_buf
->salt
;
17761 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17769 char *iter_pos
= input_buf
+ 7;
17771 u32 iter
= atoi (iter_pos
);
17773 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17774 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17776 // first is *raw* salt
17778 char *salt_pos
= strchr (iter_pos
, ':');
17780 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17784 char *hash_pos
= strchr (salt_pos
, ':');
17786 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17788 u32 salt_len
= hash_pos
- salt_pos
;
17790 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17794 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17796 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17800 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17802 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17804 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17806 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17807 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17809 salt
->salt_len
= salt_len
;
17810 salt
->salt_iter
= iter
- 1;
17814 u8 tmp_buf
[100] = { 0 };
17816 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17818 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17820 memcpy (digest
, tmp_buf
, 16);
17822 digest
[0] = byte_swap_32 (digest
[0]);
17823 digest
[1] = byte_swap_32 (digest
[1]);
17824 digest
[2] = byte_swap_32 (digest
[2]);
17825 digest
[3] = byte_swap_32 (digest
[3]);
17827 // add some stuff to normal salt to make sorted happy
17829 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17830 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17831 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17832 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17833 salt
->salt_buf
[4] = salt
->salt_iter
;
17835 return (PARSER_OK
);
17838 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17840 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17842 u32
*digest
= (u32
*) hash_buf
->digest
;
17844 salt_t
*salt
= hash_buf
->salt
;
17846 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17847 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17848 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17849 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17851 digest
[0] = byte_swap_32 (digest
[0]);
17852 digest
[1] = byte_swap_32 (digest
[1]);
17853 digest
[2] = byte_swap_32 (digest
[2]);
17854 digest
[3] = byte_swap_32 (digest
[3]);
17856 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17858 uint salt_len
= input_len
- 32 - 1;
17860 char *salt_buf
= input_buf
+ 32 + 1;
17862 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17864 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17866 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17868 salt
->salt_len
= salt_len
;
17870 return (PARSER_OK
);
17873 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17875 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17877 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17879 u32
*digest
= (u32
*) hash_buf
->digest
;
17881 salt_t
*salt
= hash_buf
->salt
;
17883 char *user_pos
= input_buf
+ 10;
17885 char *salt_pos
= strchr (user_pos
, '*');
17887 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17891 char *hash_pos
= strchr (salt_pos
, '*');
17895 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17897 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17899 uint user_len
= salt_pos
- user_pos
- 1;
17901 uint salt_len
= hash_pos
- salt_pos
- 1;
17903 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17909 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17910 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17911 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17912 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17914 digest
[0] = byte_swap_32 (digest
[0]);
17915 digest
[1] = byte_swap_32 (digest
[1]);
17916 digest
[2] = byte_swap_32 (digest
[2]);
17917 digest
[3] = byte_swap_32 (digest
[3]);
17919 digest
[0] -= MD5M_A
;
17920 digest
[1] -= MD5M_B
;
17921 digest
[2] -= MD5M_C
;
17922 digest
[3] -= MD5M_D
;
17928 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17930 // first 4 bytes are the "challenge"
17932 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17933 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17934 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17935 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17937 // append the user name
17939 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17941 salt
->salt_len
= 4 + user_len
;
17943 return (PARSER_OK
);
17946 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17948 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17950 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17952 u32
*digest
= (u32
*) hash_buf
->digest
;
17954 salt_t
*salt
= hash_buf
->salt
;
17956 char *salt_pos
= input_buf
+ 9;
17958 char *hash_pos
= strchr (salt_pos
, '*');
17960 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17964 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17966 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17968 uint salt_len
= hash_pos
- salt_pos
- 1;
17970 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17976 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17977 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17978 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17979 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17980 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17986 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17988 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17990 salt
->salt_len
= salt_len
;
17992 return (PARSER_OK
);
17995 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17997 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17999 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18001 u32
*digest
= (u32
*) hash_buf
->digest
;
18003 salt_t
*salt
= hash_buf
->salt
;
18005 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18011 char *cry_master_len_pos
= input_buf
+ 9;
18013 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18015 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18017 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18019 cry_master_buf_pos
++;
18021 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18023 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18025 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18027 cry_salt_len_pos
++;
18029 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18031 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18033 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18035 cry_salt_buf_pos
++;
18037 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18039 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18041 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18045 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18047 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18049 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18053 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18055 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18057 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18061 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18063 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18065 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18067 public_key_len_pos
++;
18069 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18071 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18073 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18075 public_key_buf_pos
++;
18077 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;
18079 const uint cry_master_len
= atoi (cry_master_len_pos
);
18080 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18081 const uint ckey_len
= atoi (ckey_len_pos
);
18082 const uint public_key_len
= atoi (public_key_len_pos
);
18084 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18085 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18086 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18087 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18089 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18091 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18093 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18096 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18098 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18100 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18103 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18105 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18107 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18110 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18111 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18112 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18115 * store digest (should be unique enought, hopefully)
18118 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18119 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18120 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18121 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18127 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18129 const uint cry_rounds
= atoi (cry_rounds_pos
);
18131 salt
->salt_iter
= cry_rounds
- 1;
18133 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18135 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18137 salt
->salt_len
= salt_len
;
18139 return (PARSER_OK
);
18142 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18144 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18146 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18148 u32
*digest
= (u32
*) hash_buf
->digest
;
18150 salt_t
*salt
= hash_buf
->salt
;
18152 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18154 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18156 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18158 memcpy (temp_input_buf
, input_buf
, input_len
);
18162 char *URI_server_pos
= temp_input_buf
+ 6;
18164 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18166 if (URI_client_pos
== NULL
)
18168 myfree (temp_input_buf
);
18170 return (PARSER_SEPARATOR_UNMATCHED
);
18173 URI_client_pos
[0] = 0;
18176 uint URI_server_len
= strlen (URI_server_pos
);
18178 if (URI_server_len
> 512)
18180 myfree (temp_input_buf
);
18182 return (PARSER_SALT_LENGTH
);
18187 char *user_pos
= strchr (URI_client_pos
, '*');
18189 if (user_pos
== NULL
)
18191 myfree (temp_input_buf
);
18193 return (PARSER_SEPARATOR_UNMATCHED
);
18199 uint URI_client_len
= strlen (URI_client_pos
);
18201 if (URI_client_len
> 512)
18203 myfree (temp_input_buf
);
18205 return (PARSER_SALT_LENGTH
);
18210 char *realm_pos
= strchr (user_pos
, '*');
18212 if (realm_pos
== NULL
)
18214 myfree (temp_input_buf
);
18216 return (PARSER_SEPARATOR_UNMATCHED
);
18222 uint user_len
= strlen (user_pos
);
18224 if (user_len
> 116)
18226 myfree (temp_input_buf
);
18228 return (PARSER_SALT_LENGTH
);
18233 char *method_pos
= strchr (realm_pos
, '*');
18235 if (method_pos
== NULL
)
18237 myfree (temp_input_buf
);
18239 return (PARSER_SEPARATOR_UNMATCHED
);
18245 uint realm_len
= strlen (realm_pos
);
18247 if (realm_len
> 116)
18249 myfree (temp_input_buf
);
18251 return (PARSER_SALT_LENGTH
);
18256 char *URI_prefix_pos
= strchr (method_pos
, '*');
18258 if (URI_prefix_pos
== NULL
)
18260 myfree (temp_input_buf
);
18262 return (PARSER_SEPARATOR_UNMATCHED
);
18265 URI_prefix_pos
[0] = 0;
18268 uint method_len
= strlen (method_pos
);
18270 if (method_len
> 246)
18272 myfree (temp_input_buf
);
18274 return (PARSER_SALT_LENGTH
);
18279 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18281 if (URI_resource_pos
== NULL
)
18283 myfree (temp_input_buf
);
18285 return (PARSER_SEPARATOR_UNMATCHED
);
18288 URI_resource_pos
[0] = 0;
18289 URI_resource_pos
++;
18291 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18293 if (URI_prefix_len
> 245)
18295 myfree (temp_input_buf
);
18297 return (PARSER_SALT_LENGTH
);
18302 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18304 if (URI_suffix_pos
== NULL
)
18306 myfree (temp_input_buf
);
18308 return (PARSER_SEPARATOR_UNMATCHED
);
18311 URI_suffix_pos
[0] = 0;
18314 uint URI_resource_len
= strlen (URI_resource_pos
);
18316 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18318 myfree (temp_input_buf
);
18320 return (PARSER_SALT_LENGTH
);
18325 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18327 if (nonce_pos
== NULL
)
18329 myfree (temp_input_buf
);
18331 return (PARSER_SEPARATOR_UNMATCHED
);
18337 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18339 if (URI_suffix_len
> 245)
18341 myfree (temp_input_buf
);
18343 return (PARSER_SALT_LENGTH
);
18348 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18350 if (nonce_client_pos
== NULL
)
18352 myfree (temp_input_buf
);
18354 return (PARSER_SEPARATOR_UNMATCHED
);
18357 nonce_client_pos
[0] = 0;
18358 nonce_client_pos
++;
18360 uint nonce_len
= strlen (nonce_pos
);
18362 if (nonce_len
< 1 || nonce_len
> 50)
18364 myfree (temp_input_buf
);
18366 return (PARSER_SALT_LENGTH
);
18371 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18373 if (nonce_count_pos
== NULL
)
18375 myfree (temp_input_buf
);
18377 return (PARSER_SEPARATOR_UNMATCHED
);
18380 nonce_count_pos
[0] = 0;
18383 uint nonce_client_len
= strlen (nonce_client_pos
);
18385 if (nonce_client_len
> 50)
18387 myfree (temp_input_buf
);
18389 return (PARSER_SALT_LENGTH
);
18394 char *qop_pos
= strchr (nonce_count_pos
, '*');
18396 if (qop_pos
== NULL
)
18398 myfree (temp_input_buf
);
18400 return (PARSER_SEPARATOR_UNMATCHED
);
18406 uint nonce_count_len
= strlen (nonce_count_pos
);
18408 if (nonce_count_len
> 50)
18410 myfree (temp_input_buf
);
18412 return (PARSER_SALT_LENGTH
);
18417 char *directive_pos
= strchr (qop_pos
, '*');
18419 if (directive_pos
== NULL
)
18421 myfree (temp_input_buf
);
18423 return (PARSER_SEPARATOR_UNMATCHED
);
18426 directive_pos
[0] = 0;
18429 uint qop_len
= strlen (qop_pos
);
18433 myfree (temp_input_buf
);
18435 return (PARSER_SALT_LENGTH
);
18440 char *digest_pos
= strchr (directive_pos
, '*');
18442 if (digest_pos
== NULL
)
18444 myfree (temp_input_buf
);
18446 return (PARSER_SEPARATOR_UNMATCHED
);
18452 uint directive_len
= strlen (directive_pos
);
18454 if (directive_len
!= 3)
18456 myfree (temp_input_buf
);
18458 return (PARSER_SALT_LENGTH
);
18461 if (memcmp (directive_pos
, "MD5", 3))
18463 log_info ("ERROR: only the MD5 directive is currently supported\n");
18465 myfree (temp_input_buf
);
18467 return (PARSER_SIP_AUTH_DIRECTIVE
);
18471 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18476 uint md5_max_len
= 4 * 64;
18478 uint md5_remaining_len
= md5_max_len
;
18480 uint tmp_md5_buf
[64] = { 0 };
18482 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18484 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18486 md5_len
+= method_len
+ 1;
18487 tmp_md5_ptr
+= method_len
+ 1;
18489 if (URI_prefix_len
> 0)
18491 md5_remaining_len
= md5_max_len
- md5_len
;
18493 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18495 md5_len
+= URI_prefix_len
+ 1;
18496 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18499 md5_remaining_len
= md5_max_len
- md5_len
;
18501 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18503 md5_len
+= URI_resource_len
;
18504 tmp_md5_ptr
+= URI_resource_len
;
18506 if (URI_suffix_len
> 0)
18508 md5_remaining_len
= md5_max_len
- md5_len
;
18510 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18512 md5_len
+= 1 + URI_suffix_len
;
18515 uint tmp_digest
[4] = { 0 };
18517 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18519 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18520 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18521 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18522 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18528 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18530 uint esalt_len
= 0;
18532 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18534 // there are 2 possibilities for the esalt:
18536 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18538 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18540 if (esalt_len
> max_esalt_len
)
18542 myfree (temp_input_buf
);
18544 return (PARSER_SALT_LENGTH
);
18547 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18559 esalt_len
= 1 + nonce_len
+ 1 + 32;
18561 if (esalt_len
> max_esalt_len
)
18563 myfree (temp_input_buf
);
18565 return (PARSER_SALT_LENGTH
);
18568 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18576 // add 0x80 to esalt
18578 esalt_buf_ptr
[esalt_len
] = 0x80;
18580 sip
->esalt_len
= esalt_len
;
18586 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18588 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18590 uint max_salt_len
= 119;
18592 if (salt_len
> max_salt_len
)
18594 myfree (temp_input_buf
);
18596 return (PARSER_SALT_LENGTH
);
18599 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18601 sip
->salt_len
= salt_len
;
18604 * fake salt (for sorting)
18607 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18611 uint fake_salt_len
= salt_len
;
18613 if (fake_salt_len
> max_salt_len
)
18615 fake_salt_len
= max_salt_len
;
18618 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18620 salt
->salt_len
= fake_salt_len
;
18626 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18627 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18628 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18629 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18631 digest
[0] = byte_swap_32 (digest
[0]);
18632 digest
[1] = byte_swap_32 (digest
[1]);
18633 digest
[2] = byte_swap_32 (digest
[2]);
18634 digest
[3] = byte_swap_32 (digest
[3]);
18636 myfree (temp_input_buf
);
18638 return (PARSER_OK
);
18641 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18643 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18645 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18647 u32
*digest
= (u32
*) hash_buf
->digest
;
18649 salt_t
*salt
= hash_buf
->salt
;
18653 char *digest_pos
= input_buf
;
18655 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18662 char *salt_buf
= input_buf
+ 8 + 1;
18666 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18668 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18670 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18672 salt
->salt_len
= salt_len
;
18674 return (PARSER_OK
);
18677 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18679 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18681 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18683 u32
*digest
= (u32
*) hash_buf
->digest
;
18685 salt_t
*salt
= hash_buf
->salt
;
18687 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18693 char *p_buf_pos
= input_buf
+ 4;
18695 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18697 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18699 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18701 NumCyclesPower_pos
++;
18703 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18705 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18707 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18711 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18713 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18715 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18719 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18721 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18723 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18727 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18729 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18731 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18735 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18737 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18739 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18743 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18745 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18747 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18751 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18753 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18755 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18759 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18761 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18763 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18767 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;
18769 const uint iter
= atoi (NumCyclesPower_pos
);
18770 const uint crc
= atoi (crc_buf_pos
);
18771 const uint p_buf
= atoi (p_buf_pos
);
18772 const uint salt_len
= atoi (salt_len_pos
);
18773 const uint iv_len
= atoi (iv_len_pos
);
18774 const uint unpack_size
= atoi (unpack_size_pos
);
18775 const uint data_len
= atoi (data_len_pos
);
18781 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18782 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18784 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18786 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18788 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18794 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18795 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18796 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18797 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18799 seven_zip
->iv_len
= iv_len
;
18801 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18803 seven_zip
->salt_len
= 0;
18805 seven_zip
->crc
= crc
;
18807 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18809 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18811 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18814 seven_zip
->data_len
= data_len
;
18816 seven_zip
->unpack_size
= unpack_size
;
18820 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18821 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18822 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18823 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18825 salt
->salt_len
= 16;
18827 salt
->salt_sign
[0] = iter
;
18829 salt
->salt_iter
= 1 << iter
;
18840 return (PARSER_OK
);
18843 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18845 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18847 u32
*digest
= (u32
*) hash_buf
->digest
;
18849 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18850 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18851 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18852 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18853 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18854 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18855 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18856 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18858 digest
[0] = byte_swap_32 (digest
[0]);
18859 digest
[1] = byte_swap_32 (digest
[1]);
18860 digest
[2] = byte_swap_32 (digest
[2]);
18861 digest
[3] = byte_swap_32 (digest
[3]);
18862 digest
[4] = byte_swap_32 (digest
[4]);
18863 digest
[5] = byte_swap_32 (digest
[5]);
18864 digest
[6] = byte_swap_32 (digest
[6]);
18865 digest
[7] = byte_swap_32 (digest
[7]);
18867 return (PARSER_OK
);
18870 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18872 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18874 u32
*digest
= (u32
*) hash_buf
->digest
;
18876 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18877 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18878 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18879 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18880 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18881 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18882 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18883 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18884 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18885 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18886 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18887 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18888 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18889 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18890 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18891 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18893 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18894 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18895 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18896 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18897 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18898 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18899 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18900 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18901 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18902 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18903 digest
[10] = byte_swap_32 (digest
[10]);
18904 digest
[11] = byte_swap_32 (digest
[11]);
18905 digest
[12] = byte_swap_32 (digest
[12]);
18906 digest
[13] = byte_swap_32 (digest
[13]);
18907 digest
[14] = byte_swap_32 (digest
[14]);
18908 digest
[15] = byte_swap_32 (digest
[15]);
18910 return (PARSER_OK
);
18913 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18915 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18917 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18919 u32
*digest
= (u32
*) hash_buf
->digest
;
18921 salt_t
*salt
= hash_buf
->salt
;
18923 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18931 char *iter_pos
= input_buf
+ 4;
18933 u32 iter
= atoi (iter_pos
);
18935 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18936 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18938 // first is *raw* salt
18940 char *salt_pos
= strchr (iter_pos
, ':');
18942 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18946 char *hash_pos
= strchr (salt_pos
, ':');
18948 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18950 u32 salt_len
= hash_pos
- salt_pos
;
18952 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18956 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18958 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18962 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18964 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18966 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18968 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18969 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18971 salt
->salt_len
= salt_len
;
18972 salt
->salt_iter
= iter
- 1;
18976 u8 tmp_buf
[100] = { 0 };
18978 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18980 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18982 memcpy (digest
, tmp_buf
, 16);
18984 // add some stuff to normal salt to make sorted happy
18986 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18987 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18988 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18989 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18990 salt
->salt_buf
[4] = salt
->salt_iter
;
18992 return (PARSER_OK
);
18995 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18997 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18999 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19001 u32
*digest
= (u32
*) hash_buf
->digest
;
19003 salt_t
*salt
= hash_buf
->salt
;
19005 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19013 char *iter_pos
= input_buf
+ 5;
19015 u32 iter
= atoi (iter_pos
);
19017 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19018 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19020 // first is *raw* salt
19022 char *salt_pos
= strchr (iter_pos
, ':');
19024 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19028 char *hash_pos
= strchr (salt_pos
, ':');
19030 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19032 u32 salt_len
= hash_pos
- salt_pos
;
19034 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19038 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19040 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19044 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19046 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19048 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19050 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19051 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19053 salt
->salt_len
= salt_len
;
19054 salt
->salt_iter
= iter
- 1;
19058 u8 tmp_buf
[100] = { 0 };
19060 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19062 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19064 memcpy (digest
, tmp_buf
, 16);
19066 digest
[0] = byte_swap_32 (digest
[0]);
19067 digest
[1] = byte_swap_32 (digest
[1]);
19068 digest
[2] = byte_swap_32 (digest
[2]);
19069 digest
[3] = byte_swap_32 (digest
[3]);
19071 // add some stuff to normal salt to make sorted happy
19073 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19074 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19075 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19076 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19077 salt
->salt_buf
[4] = salt
->salt_iter
;
19079 return (PARSER_OK
);
19082 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19084 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19086 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19088 u64
*digest
= (u64
*) hash_buf
->digest
;
19090 salt_t
*salt
= hash_buf
->salt
;
19092 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19100 char *iter_pos
= input_buf
+ 7;
19102 u32 iter
= atoi (iter_pos
);
19104 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19105 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19107 // first is *raw* salt
19109 char *salt_pos
= strchr (iter_pos
, ':');
19111 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19115 char *hash_pos
= strchr (salt_pos
, ':');
19117 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19119 u32 salt_len
= hash_pos
- salt_pos
;
19121 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19125 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19127 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19131 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19133 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19135 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19137 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19138 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19140 salt
->salt_len
= salt_len
;
19141 salt
->salt_iter
= iter
- 1;
19145 u8 tmp_buf
[100] = { 0 };
19147 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19149 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19151 memcpy (digest
, tmp_buf
, 64);
19153 digest
[0] = byte_swap_64 (digest
[0]);
19154 digest
[1] = byte_swap_64 (digest
[1]);
19155 digest
[2] = byte_swap_64 (digest
[2]);
19156 digest
[3] = byte_swap_64 (digest
[3]);
19157 digest
[4] = byte_swap_64 (digest
[4]);
19158 digest
[5] = byte_swap_64 (digest
[5]);
19159 digest
[6] = byte_swap_64 (digest
[6]);
19160 digest
[7] = byte_swap_64 (digest
[7]);
19162 // add some stuff to normal salt to make sorted happy
19164 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19165 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19166 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19167 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19168 salt
->salt_buf
[4] = salt
->salt_iter
;
19170 return (PARSER_OK
);
19173 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19175 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19177 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19179 uint
*digest
= (uint
*) hash_buf
->digest
;
19181 salt_t
*salt
= hash_buf
->salt
;
19187 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19189 char *hash_pos
= strchr (salt_pos
, '$');
19191 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19193 u32 salt_len
= hash_pos
- salt_pos
;
19195 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19199 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19201 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19205 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19206 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19224 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19225 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19227 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19228 salt
->salt_len
= 8;
19230 return (PARSER_OK
);
19233 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19235 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19237 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19239 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19241 if (c19
& 3) return (PARSER_HASH_VALUE
);
19243 salt_t
*salt
= hash_buf
->salt
;
19245 u32
*digest
= (u32
*) hash_buf
->digest
;
19249 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19250 | itoa64_to_int (input_buf
[2]) << 6
19251 | itoa64_to_int (input_buf
[3]) << 12
19252 | itoa64_to_int (input_buf
[4]) << 18;
19256 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19257 | itoa64_to_int (input_buf
[6]) << 6
19258 | itoa64_to_int (input_buf
[7]) << 12
19259 | itoa64_to_int (input_buf
[8]) << 18;
19261 salt
->salt_len
= 4;
19263 u8 tmp_buf
[100] = { 0 };
19265 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19267 memcpy (digest
, tmp_buf
, 8);
19271 IP (digest
[0], digest
[1], tt
);
19273 digest
[0] = rotr32 (digest
[0], 31);
19274 digest
[1] = rotr32 (digest
[1], 31);
19278 return (PARSER_OK
);
19281 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19283 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19285 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19287 u32
*digest
= (u32
*) hash_buf
->digest
;
19289 salt_t
*salt
= hash_buf
->salt
;
19295 char *type_pos
= input_buf
+ 6 + 1;
19297 char *salt_pos
= strchr (type_pos
, '*');
19299 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19301 u32 type_len
= salt_pos
- type_pos
;
19303 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19307 char *crypted_pos
= strchr (salt_pos
, '*');
19309 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19311 u32 salt_len
= crypted_pos
- salt_pos
;
19313 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19317 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19319 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19325 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19326 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19328 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19329 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19331 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19332 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19333 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19334 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19336 salt
->salt_len
= 24;
19337 salt
->salt_iter
= ROUNDS_RAR3
;
19339 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19340 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19342 digest
[0] = 0xc43d7b00;
19343 digest
[1] = 0x40070000;
19347 return (PARSER_OK
);
19350 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19352 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19354 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19356 u32
*digest
= (u32
*) hash_buf
->digest
;
19358 salt_t
*salt
= hash_buf
->salt
;
19360 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19366 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19368 char *param1_pos
= strchr (param0_pos
, '$');
19370 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19372 u32 param0_len
= param1_pos
- param0_pos
;
19376 char *param2_pos
= strchr (param1_pos
, '$');
19378 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19380 u32 param1_len
= param2_pos
- param1_pos
;
19384 char *param3_pos
= strchr (param2_pos
, '$');
19386 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19388 u32 param2_len
= param3_pos
- param2_pos
;
19392 char *param4_pos
= strchr (param3_pos
, '$');
19394 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19396 u32 param3_len
= param4_pos
- param3_pos
;
19400 char *param5_pos
= strchr (param4_pos
, '$');
19402 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19404 u32 param4_len
= param5_pos
- param4_pos
;
19408 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19410 char *salt_buf
= param1_pos
;
19411 char *iv
= param3_pos
;
19412 char *pswcheck
= param5_pos
;
19414 const uint salt_len
= atoi (param0_pos
);
19415 const uint iterations
= atoi (param2_pos
);
19416 const uint pswcheck_len
= atoi (param4_pos
);
19422 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19423 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19424 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19426 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19427 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19428 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19434 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19435 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19436 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19437 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19439 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19440 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19441 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19442 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19444 salt
->salt_len
= 16;
19446 salt
->salt_sign
[0] = iterations
;
19448 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19454 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19455 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19459 return (PARSER_OK
);
19462 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19464 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19466 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19468 u32
*digest
= (u32
*) hash_buf
->digest
;
19470 salt_t
*salt
= hash_buf
->salt
;
19472 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19479 char *account_pos
= input_buf
+ 11 + 1;
19485 if (account_pos
[0] == '*')
19489 data_pos
= strchr (account_pos
, '*');
19494 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19496 uint account_len
= data_pos
- account_pos
+ 1;
19498 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19503 data_len
= input_len
- 11 - 1 - account_len
- 2;
19505 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19509 /* assume $krb5tgs$23$checksum$edata2 */
19510 data_pos
= account_pos
;
19512 memcpy (krb5tgs
->account_info
, "**", 3);
19514 data_len
= input_len
- 11 - 1 - 1;
19517 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19519 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19521 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19523 const char p0
= data_pos
[i
+ 0];
19524 const char p1
= data_pos
[i
+ 1];
19526 *checksum_ptr
++ = hex_convert (p1
) << 0
19527 | hex_convert (p0
) << 4;
19530 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19532 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19535 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19537 const char p0
= data_pos
[i
+ 0];
19538 const char p1
= data_pos
[i
+ 1];
19539 *edata_ptr
++ = hex_convert (p1
) << 0
19540 | hex_convert (p0
) << 4;
19543 /* this is needed for hmac_md5 */
19544 *edata_ptr
++ = 0x80;
19546 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19547 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19548 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19549 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19551 salt
->salt_len
= 32;
19553 digest
[0] = krb5tgs
->checksum
[0];
19554 digest
[1] = krb5tgs
->checksum
[1];
19555 digest
[2] = krb5tgs
->checksum
[2];
19556 digest
[3] = krb5tgs
->checksum
[3];
19558 return (PARSER_OK
);
19561 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19563 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19565 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19567 u32
*digest
= (u32
*) hash_buf
->digest
;
19569 salt_t
*salt
= hash_buf
->salt
;
19576 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19580 char *wrapped_key_pos
;
19584 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19586 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19588 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19590 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19595 data_pos
= salt_pos
;
19597 wrapped_key_pos
= strchr (salt_pos
, '*');
19599 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19601 uint salt_len
= wrapped_key_pos
- salt_pos
;
19603 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19608 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19610 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19612 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19613 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19614 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19615 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19619 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19620 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19621 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19622 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19623 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19624 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19626 salt
->salt_len
= 40;
19628 digest
[0] = salt
->salt_buf
[0];
19629 digest
[1] = salt
->salt_buf
[1];
19630 digest
[2] = salt
->salt_buf
[2];
19631 digest
[3] = salt
->salt_buf
[3];
19633 return (PARSER_OK
);
19636 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19638 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19640 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19642 u32
*digest
= (u32
*) hash_buf
->digest
;
19644 salt_t
*salt
= hash_buf
->salt
;
19646 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19656 char *algorithm_pos
;
19658 char *final_random_seed_pos
;
19659 u32 final_random_seed_len
;
19661 char *transf_random_seed_pos
;
19662 u32 transf_random_seed_len
;
19667 /* default is no keyfile provided */
19668 char *keyfile_len_pos
;
19669 u32 keyfile_len
= 0;
19670 u32 is_keyfile_present
= 0;
19671 char *keyfile_inline_pos
;
19674 /* specific to version 1 */
19675 char *contents_len_pos
;
19677 char *contents_pos
;
19679 /* specific to version 2 */
19680 char *expected_bytes_pos
;
19681 u32 expected_bytes_len
;
19683 char *contents_hash_pos
;
19684 u32 contents_hash_len
;
19686 version_pos
= input_buf
+ 8 + 1 + 1;
19688 keepass
->version
= atoi (version_pos
);
19690 rounds_pos
= strchr (version_pos
, '*');
19692 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19696 salt
->salt_iter
= (atoi (rounds_pos
));
19698 algorithm_pos
= strchr (rounds_pos
, '*');
19700 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19704 keepass
->algorithm
= atoi (algorithm_pos
);
19706 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19708 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19710 final_random_seed_pos
++;
19712 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19713 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19714 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19715 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19717 if (keepass
->version
== 2)
19719 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19720 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19721 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19722 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19725 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19727 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19729 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19731 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19732 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19734 transf_random_seed_pos
++;
19736 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19737 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19738 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19739 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19740 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19741 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19742 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19743 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19745 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19747 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19749 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19751 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19755 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19756 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19757 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19758 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19760 if (keepass
->version
== 1)
19762 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19764 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19766 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19768 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19770 contents_hash_pos
++;
19772 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19773 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19774 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19775 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19776 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19777 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19778 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19779 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19781 /* get length of contents following */
19782 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19784 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19786 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19788 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19792 u32 inline_flag
= atoi (inline_flag_pos
);
19794 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19796 contents_len_pos
= strchr (inline_flag_pos
, '*');
19798 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19800 contents_len_pos
++;
19802 contents_len
= atoi (contents_len_pos
);
19804 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19806 contents_pos
= strchr (contents_len_pos
, '*');
19808 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19814 keepass
->contents_len
= contents_len
;
19816 contents_len
= contents_len
/ 4;
19818 keyfile_inline_pos
= strchr (contents_pos
, '*');
19820 u32 real_contents_len
;
19822 if (keyfile_inline_pos
== NULL
)
19823 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19826 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19827 keyfile_inline_pos
++;
19828 is_keyfile_present
= 1;
19831 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19833 for (i
= 0; i
< contents_len
; i
++)
19834 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19836 else if (keepass
->version
== 2)
19838 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19840 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19842 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19844 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19846 expected_bytes_pos
++;
19848 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19849 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19850 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19851 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19852 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19853 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19854 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19855 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19857 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19859 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19861 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19863 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19865 contents_hash_pos
++;
19867 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19868 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19869 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19870 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19871 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19872 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19873 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19874 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19876 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19878 if (keyfile_inline_pos
== NULL
)
19879 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19882 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19883 keyfile_inline_pos
++;
19884 is_keyfile_present
= 1;
19886 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19889 if (is_keyfile_present
!= 0)
19891 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19895 keyfile_len
= atoi (keyfile_len_pos
);
19897 keepass
->keyfile_len
= keyfile_len
;
19899 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19901 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19903 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19907 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19909 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19911 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19912 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19913 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19914 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19915 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19916 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19917 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19918 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19921 digest
[0] = keepass
->enc_iv
[0];
19922 digest
[1] = keepass
->enc_iv
[1];
19923 digest
[2] = keepass
->enc_iv
[2];
19924 digest
[3] = keepass
->enc_iv
[3];
19926 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19927 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19928 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19929 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19930 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19931 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19932 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19933 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19935 return (PARSER_OK
);
19938 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19940 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19942 u32
*digest
= (u32
*) hash_buf
->digest
;
19944 salt_t
*salt
= hash_buf
->salt
;
19946 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19947 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19948 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19949 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19950 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19951 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19952 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19953 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19955 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19957 uint salt_len
= input_len
- 64 - 1;
19959 char *salt_buf
= input_buf
+ 64 + 1;
19961 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
19963 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
19965 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19967 salt
->salt_len
= salt_len
;
19970 * we can precompute the first sha256 transform
19973 uint w
[16] = { 0 };
19975 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
19976 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
19977 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
19978 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
19979 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
19980 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
19981 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
19982 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
19983 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
19984 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
19985 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
19986 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
19987 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
19988 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
19989 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
19990 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
19992 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
19994 sha256_64 (w
, pc256
);
19996 salt
->salt_buf_pc
[0] = pc256
[0];
19997 salt
->salt_buf_pc
[1] = pc256
[1];
19998 salt
->salt_buf_pc
[2] = pc256
[2];
19999 salt
->salt_buf_pc
[3] = pc256
[3];
20000 salt
->salt_buf_pc
[4] = pc256
[4];
20001 salt
->salt_buf_pc
[5] = pc256
[5];
20002 salt
->salt_buf_pc
[6] = pc256
[6];
20003 salt
->salt_buf_pc
[7] = pc256
[7];
20005 digest
[0] -= pc256
[0];
20006 digest
[1] -= pc256
[1];
20007 digest
[2] -= pc256
[2];
20008 digest
[3] -= pc256
[3];
20009 digest
[4] -= pc256
[4];
20010 digest
[5] -= pc256
[5];
20011 digest
[6] -= pc256
[6];
20012 digest
[7] -= pc256
[7];
20014 return (PARSER_OK
);
20017 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20019 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20021 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20023 u32
*digest
= (u32
*) hash_buf
->digest
;
20025 salt_t
*salt
= hash_buf
->salt
;
20031 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20033 char *data_buf_pos
= strchr (data_len_pos
, '$');
20035 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20037 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20039 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20040 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20044 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20046 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20048 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20050 u32 data_len
= atoi (data_len_pos
);
20052 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20058 char *salt_pos
= data_buf_pos
;
20060 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20061 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20062 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20063 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20065 // this is actually the CT, which is also the hash later (if matched)
20067 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20068 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20069 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20070 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20072 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20074 salt
->salt_iter
= 10 - 1;
20080 digest
[0] = salt
->salt_buf
[4];
20081 digest
[1] = salt
->salt_buf
[5];
20082 digest
[2] = salt
->salt_buf
[6];
20083 digest
[3] = salt
->salt_buf
[7];
20085 return (PARSER_OK
);
20088 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20090 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20092 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20094 u32
*digest
= (u32
*) hash_buf
->digest
;
20096 salt_t
*salt
= hash_buf
->salt
;
20102 char *salt_pos
= input_buf
+ 11 + 1;
20104 char *iter_pos
= strchr (salt_pos
, ',');
20106 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20108 u32 salt_len
= iter_pos
- salt_pos
;
20110 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20114 char *hash_pos
= strchr (iter_pos
, ',');
20116 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20118 u32 iter_len
= hash_pos
- iter_pos
;
20120 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20124 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20126 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20132 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20133 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20134 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20135 salt
->salt_buf
[3] = 0x00018000;
20137 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20138 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20139 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20140 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20142 salt
->salt_len
= salt_len
/ 2;
20144 salt
->salt_iter
= atoi (iter_pos
) - 1;
20150 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20151 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20152 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20153 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20154 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20155 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20156 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20157 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20159 return (PARSER_OK
);
20162 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20164 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20166 u32
*digest
= (u32
*) hash_buf
->digest
;
20168 salt_t
*salt
= hash_buf
->salt
;
20174 char *hash_pos
= input_buf
+ 64;
20175 char *salt1_pos
= input_buf
+ 128;
20176 char *salt2_pos
= input_buf
;
20182 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20183 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20184 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20185 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20187 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20188 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20189 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20190 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20192 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20193 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20194 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20195 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20197 salt
->salt_len
= 48;
20199 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20205 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20206 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20207 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20208 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20209 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20210 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20211 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20212 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20214 return (PARSER_OK
);
20217 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20219 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20221 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20222 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20224 u32
*digest
= (u32
*) hash_buf
->digest
;
20226 salt_t
*salt
= hash_buf
->salt
;
20228 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20234 char *param0_pos
= input_buf
+ 6 + 1;
20236 char *param1_pos
= strchr (param0_pos
, '*');
20238 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20240 u32 param0_len
= param1_pos
- param0_pos
;
20244 char *param2_pos
= strchr (param1_pos
, '*');
20246 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20248 u32 param1_len
= param2_pos
- param1_pos
;
20252 char *param3_pos
= strchr (param2_pos
, '*');
20254 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20256 u32 param2_len
= param3_pos
- param2_pos
;
20260 char *param4_pos
= strchr (param3_pos
, '*');
20262 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20264 u32 param3_len
= param4_pos
- param3_pos
;
20268 char *param5_pos
= strchr (param4_pos
, '*');
20270 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20272 u32 param4_len
= param5_pos
- param4_pos
;
20276 char *param6_pos
= strchr (param5_pos
, '*');
20278 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20280 u32 param5_len
= param6_pos
- param5_pos
;
20284 char *param7_pos
= strchr (param6_pos
, '*');
20286 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20288 u32 param6_len
= param7_pos
- param6_pos
;
20292 char *param8_pos
= strchr (param7_pos
, '*');
20294 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20296 u32 param7_len
= param8_pos
- param7_pos
;
20300 const uint type
= atoi (param0_pos
);
20301 const uint mode
= atoi (param1_pos
);
20302 const uint magic
= atoi (param2_pos
);
20304 char *salt_buf
= param3_pos
;
20306 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20308 const uint compress_length
= atoi (param5_pos
);
20310 char *data_buf
= param6_pos
;
20311 char *auth
= param7_pos
;
20317 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20319 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20321 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20323 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20325 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20327 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20329 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20331 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20333 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20335 if (type
!= 0) return (PARSER_SALT_VALUE
);
20337 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20339 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20341 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20349 zip2
->magic
= magic
;
20353 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20354 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20355 zip2
->salt_buf
[2] = 0;
20356 zip2
->salt_buf
[3] = 0;
20358 zip2
->salt_len
= 8;
20360 else if (mode
== 2)
20362 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20363 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20364 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20365 zip2
->salt_buf
[3] = 0;
20367 zip2
->salt_len
= 12;
20369 else if (mode
== 3)
20371 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20372 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20373 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20374 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20376 zip2
->salt_len
= 16;
20379 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20380 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20381 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20382 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20384 zip2
->verify_bytes
= verify_bytes
;
20386 zip2
->compress_length
= compress_length
;
20388 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20390 for (uint i
= 0; i
< param6_len
; i
+= 2)
20392 const char p0
= data_buf
[i
+ 0];
20393 const char p1
= data_buf
[i
+ 1];
20395 *data_buf_ptr
++ = hex_convert (p1
) << 0
20396 | hex_convert (p0
) << 4;
20401 *data_buf_ptr
= 0x80;
20403 char *auth_ptr
= (char *) zip2
->auth_buf
;
20405 for (uint i
= 0; i
< param7_len
; i
+= 2)
20407 const char p0
= auth
[i
+ 0];
20408 const char p1
= auth
[i
+ 1];
20410 *auth_ptr
++ = hex_convert (p1
) << 0
20411 | hex_convert (p0
) << 4;
20420 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20421 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20422 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20423 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20424 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20425 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20426 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20427 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20429 salt
->salt_len
= 32;
20431 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20434 * digest buf (fake)
20437 digest
[0] = zip2
->auth_buf
[0];
20438 digest
[1] = zip2
->auth_buf
[1];
20439 digest
[2] = zip2
->auth_buf
[2];
20440 digest
[3] = zip2
->auth_buf
[3];
20442 return (PARSER_OK
);
20446 * parallel running threads
20451 BOOL WINAPI
sigHandler_default (DWORD sig
)
20455 case CTRL_CLOSE_EVENT
:
20458 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20459 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20460 * function otherwise it is too late (e.g. after returning from this function)
20465 SetConsoleCtrlHandler (NULL
, TRUE
);
20472 case CTRL_LOGOFF_EVENT
:
20473 case CTRL_SHUTDOWN_EVENT
:
20477 SetConsoleCtrlHandler (NULL
, TRUE
);
20485 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20489 case CTRL_CLOSE_EVENT
:
20493 SetConsoleCtrlHandler (NULL
, TRUE
);
20500 case CTRL_LOGOFF_EVENT
:
20501 case CTRL_SHUTDOWN_EVENT
:
20505 SetConsoleCtrlHandler (NULL
, TRUE
);
20513 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20515 if (callback
== NULL
)
20517 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20521 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20527 void sigHandler_default (int sig
)
20531 signal (sig
, NULL
);
20534 void sigHandler_benchmark (int sig
)
20538 signal (sig
, NULL
);
20541 void hc_signal (void (callback
) (int))
20543 if (callback
== NULL
) callback
= SIG_DFL
;
20545 signal (SIGINT
, callback
);
20546 signal (SIGTERM
, callback
);
20547 signal (SIGABRT
, callback
);
20552 void status_display ();
20554 void *thread_keypress (void *p
)
20556 int benchmark
= *((int *) p
);
20558 uint quiet
= data
.quiet
;
20562 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20564 int ch
= tty_getchar();
20566 if (ch
== -1) break;
20568 if (ch
== 0) continue;
20570 //https://github.com/hashcat/hashcat/issues/302
20575 hc_thread_mutex_lock (mux_display
);
20591 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20592 if (quiet
== 0) fflush (stdout
);
20604 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20605 if (quiet
== 0) fflush (stdout
);
20617 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20618 if (quiet
== 0) fflush (stdout
);
20630 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20631 if (quiet
== 0) fflush (stdout
);
20639 if (benchmark
== 1) break;
20641 stop_at_checkpoint ();
20645 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20646 if (quiet
== 0) fflush (stdout
);
20654 if (benchmark
== 1)
20666 //https://github.com/hashcat/hashcat/issues/302
20671 hc_thread_mutex_unlock (mux_display
);
20683 bool class_num (const u8 c
)
20685 return ((c
>= '0') && (c
<= '9'));
20688 bool class_lower (const u8 c
)
20690 return ((c
>= 'a') && (c
<= 'z'));
20693 bool class_upper (const u8 c
)
20695 return ((c
>= 'A') && (c
<= 'Z'));
20698 bool class_alpha (const u8 c
)
20700 return (class_lower (c
) || class_upper (c
));
20703 int conv_ctoi (const u8 c
)
20709 else if (class_upper (c
))
20711 return c
- 'A' + 10;
20717 int conv_itoc (const u8 c
)
20725 return c
+ 'A' - 10;
20735 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20736 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20737 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20738 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20739 #define MAX_KERNEL_RULES 255
20740 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20741 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20742 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20744 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20745 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20746 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20747 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20749 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20754 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20756 switch (rule_buf
[rule_pos
])
20762 case RULE_OP_MANGLE_NOOP
:
20763 SET_NAME (rule
, rule_buf
[rule_pos
]);
20766 case RULE_OP_MANGLE_LREST
:
20767 SET_NAME (rule
, rule_buf
[rule_pos
]);
20770 case RULE_OP_MANGLE_UREST
:
20771 SET_NAME (rule
, rule_buf
[rule_pos
]);
20774 case RULE_OP_MANGLE_LREST_UFIRST
:
20775 SET_NAME (rule
, rule_buf
[rule_pos
]);
20778 case RULE_OP_MANGLE_UREST_LFIRST
:
20779 SET_NAME (rule
, rule_buf
[rule_pos
]);
20782 case RULE_OP_MANGLE_TREST
:
20783 SET_NAME (rule
, rule_buf
[rule_pos
]);
20786 case RULE_OP_MANGLE_TOGGLE_AT
:
20787 SET_NAME (rule
, rule_buf
[rule_pos
]);
20788 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20791 case RULE_OP_MANGLE_REVERSE
:
20792 SET_NAME (rule
, rule_buf
[rule_pos
]);
20795 case RULE_OP_MANGLE_DUPEWORD
:
20796 SET_NAME (rule
, rule_buf
[rule_pos
]);
20799 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20800 SET_NAME (rule
, rule_buf
[rule_pos
]);
20801 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20804 case RULE_OP_MANGLE_REFLECT
:
20805 SET_NAME (rule
, rule_buf
[rule_pos
]);
20808 case RULE_OP_MANGLE_ROTATE_LEFT
:
20809 SET_NAME (rule
, rule_buf
[rule_pos
]);
20812 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20813 SET_NAME (rule
, rule_buf
[rule_pos
]);
20816 case RULE_OP_MANGLE_APPEND
:
20817 SET_NAME (rule
, rule_buf
[rule_pos
]);
20818 SET_P0 (rule
, rule_buf
[rule_pos
]);
20821 case RULE_OP_MANGLE_PREPEND
:
20822 SET_NAME (rule
, rule_buf
[rule_pos
]);
20823 SET_P0 (rule
, rule_buf
[rule_pos
]);
20826 case RULE_OP_MANGLE_DELETE_FIRST
:
20827 SET_NAME (rule
, rule_buf
[rule_pos
]);
20830 case RULE_OP_MANGLE_DELETE_LAST
:
20831 SET_NAME (rule
, rule_buf
[rule_pos
]);
20834 case RULE_OP_MANGLE_DELETE_AT
:
20835 SET_NAME (rule
, rule_buf
[rule_pos
]);
20836 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20839 case RULE_OP_MANGLE_EXTRACT
:
20840 SET_NAME (rule
, rule_buf
[rule_pos
]);
20841 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20842 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20845 case RULE_OP_MANGLE_OMIT
:
20846 SET_NAME (rule
, rule_buf
[rule_pos
]);
20847 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20848 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20851 case RULE_OP_MANGLE_INSERT
:
20852 SET_NAME (rule
, rule_buf
[rule_pos
]);
20853 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20854 SET_P1 (rule
, rule_buf
[rule_pos
]);
20857 case RULE_OP_MANGLE_OVERSTRIKE
:
20858 SET_NAME (rule
, rule_buf
[rule_pos
]);
20859 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20860 SET_P1 (rule
, rule_buf
[rule_pos
]);
20863 case RULE_OP_MANGLE_TRUNCATE_AT
:
20864 SET_NAME (rule
, rule_buf
[rule_pos
]);
20865 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20868 case RULE_OP_MANGLE_REPLACE
:
20869 SET_NAME (rule
, rule_buf
[rule_pos
]);
20870 SET_P0 (rule
, rule_buf
[rule_pos
]);
20871 SET_P1 (rule
, rule_buf
[rule_pos
]);
20874 case RULE_OP_MANGLE_PURGECHAR
:
20878 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20882 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20883 SET_NAME (rule
, rule_buf
[rule_pos
]);
20884 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20887 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20888 SET_NAME (rule
, rule_buf
[rule_pos
]);
20889 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20892 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20893 SET_NAME (rule
, rule_buf
[rule_pos
]);
20896 case RULE_OP_MANGLE_SWITCH_FIRST
:
20897 SET_NAME (rule
, rule_buf
[rule_pos
]);
20900 case RULE_OP_MANGLE_SWITCH_LAST
:
20901 SET_NAME (rule
, rule_buf
[rule_pos
]);
20904 case RULE_OP_MANGLE_SWITCH_AT
:
20905 SET_NAME (rule
, rule_buf
[rule_pos
]);
20906 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20907 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20910 case RULE_OP_MANGLE_CHR_SHIFTL
:
20911 SET_NAME (rule
, rule_buf
[rule_pos
]);
20912 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20915 case RULE_OP_MANGLE_CHR_SHIFTR
:
20916 SET_NAME (rule
, rule_buf
[rule_pos
]);
20917 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20920 case RULE_OP_MANGLE_CHR_INCR
:
20921 SET_NAME (rule
, rule_buf
[rule_pos
]);
20922 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20925 case RULE_OP_MANGLE_CHR_DECR
:
20926 SET_NAME (rule
, rule_buf
[rule_pos
]);
20927 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20930 case RULE_OP_MANGLE_REPLACE_NP1
:
20931 SET_NAME (rule
, rule_buf
[rule_pos
]);
20932 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20935 case RULE_OP_MANGLE_REPLACE_NM1
:
20936 SET_NAME (rule
, rule_buf
[rule_pos
]);
20937 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20940 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20941 SET_NAME (rule
, rule_buf
[rule_pos
]);
20942 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20945 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20946 SET_NAME (rule
, rule_buf
[rule_pos
]);
20947 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20950 case RULE_OP_MANGLE_TITLE
:
20951 SET_NAME (rule
, rule_buf
[rule_pos
]);
20960 if (rule_pos
< rule_len
) return (-1);
20965 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
20969 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
20973 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20977 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
20981 case RULE_OP_MANGLE_NOOP
:
20982 rule_buf
[rule_pos
] = rule_cmd
;
20985 case RULE_OP_MANGLE_LREST
:
20986 rule_buf
[rule_pos
] = rule_cmd
;
20989 case RULE_OP_MANGLE_UREST
:
20990 rule_buf
[rule_pos
] = rule_cmd
;
20993 case RULE_OP_MANGLE_LREST_UFIRST
:
20994 rule_buf
[rule_pos
] = rule_cmd
;
20997 case RULE_OP_MANGLE_UREST_LFIRST
:
20998 rule_buf
[rule_pos
] = rule_cmd
;
21001 case RULE_OP_MANGLE_TREST
:
21002 rule_buf
[rule_pos
] = rule_cmd
;
21005 case RULE_OP_MANGLE_TOGGLE_AT
:
21006 rule_buf
[rule_pos
] = rule_cmd
;
21007 GET_P0_CONV (rule
);
21010 case RULE_OP_MANGLE_REVERSE
:
21011 rule_buf
[rule_pos
] = rule_cmd
;
21014 case RULE_OP_MANGLE_DUPEWORD
:
21015 rule_buf
[rule_pos
] = rule_cmd
;
21018 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21019 rule_buf
[rule_pos
] = rule_cmd
;
21020 GET_P0_CONV (rule
);
21023 case RULE_OP_MANGLE_REFLECT
:
21024 rule_buf
[rule_pos
] = rule_cmd
;
21027 case RULE_OP_MANGLE_ROTATE_LEFT
:
21028 rule_buf
[rule_pos
] = rule_cmd
;
21031 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21032 rule_buf
[rule_pos
] = rule_cmd
;
21035 case RULE_OP_MANGLE_APPEND
:
21036 rule_buf
[rule_pos
] = rule_cmd
;
21040 case RULE_OP_MANGLE_PREPEND
:
21041 rule_buf
[rule_pos
] = rule_cmd
;
21045 case RULE_OP_MANGLE_DELETE_FIRST
:
21046 rule_buf
[rule_pos
] = rule_cmd
;
21049 case RULE_OP_MANGLE_DELETE_LAST
:
21050 rule_buf
[rule_pos
] = rule_cmd
;
21053 case RULE_OP_MANGLE_DELETE_AT
:
21054 rule_buf
[rule_pos
] = rule_cmd
;
21055 GET_P0_CONV (rule
);
21058 case RULE_OP_MANGLE_EXTRACT
:
21059 rule_buf
[rule_pos
] = rule_cmd
;
21060 GET_P0_CONV (rule
);
21061 GET_P1_CONV (rule
);
21064 case RULE_OP_MANGLE_OMIT
:
21065 rule_buf
[rule_pos
] = rule_cmd
;
21066 GET_P0_CONV (rule
);
21067 GET_P1_CONV (rule
);
21070 case RULE_OP_MANGLE_INSERT
:
21071 rule_buf
[rule_pos
] = rule_cmd
;
21072 GET_P0_CONV (rule
);
21076 case RULE_OP_MANGLE_OVERSTRIKE
:
21077 rule_buf
[rule_pos
] = rule_cmd
;
21078 GET_P0_CONV (rule
);
21082 case RULE_OP_MANGLE_TRUNCATE_AT
:
21083 rule_buf
[rule_pos
] = rule_cmd
;
21084 GET_P0_CONV (rule
);
21087 case RULE_OP_MANGLE_REPLACE
:
21088 rule_buf
[rule_pos
] = rule_cmd
;
21093 case RULE_OP_MANGLE_PURGECHAR
:
21097 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21101 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21102 rule_buf
[rule_pos
] = rule_cmd
;
21103 GET_P0_CONV (rule
);
21106 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21107 rule_buf
[rule_pos
] = rule_cmd
;
21108 GET_P0_CONV (rule
);
21111 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21112 rule_buf
[rule_pos
] = rule_cmd
;
21115 case RULE_OP_MANGLE_SWITCH_FIRST
:
21116 rule_buf
[rule_pos
] = rule_cmd
;
21119 case RULE_OP_MANGLE_SWITCH_LAST
:
21120 rule_buf
[rule_pos
] = rule_cmd
;
21123 case RULE_OP_MANGLE_SWITCH_AT
:
21124 rule_buf
[rule_pos
] = rule_cmd
;
21125 GET_P0_CONV (rule
);
21126 GET_P1_CONV (rule
);
21129 case RULE_OP_MANGLE_CHR_SHIFTL
:
21130 rule_buf
[rule_pos
] = rule_cmd
;
21131 GET_P0_CONV (rule
);
21134 case RULE_OP_MANGLE_CHR_SHIFTR
:
21135 rule_buf
[rule_pos
] = rule_cmd
;
21136 GET_P0_CONV (rule
);
21139 case RULE_OP_MANGLE_CHR_INCR
:
21140 rule_buf
[rule_pos
] = rule_cmd
;
21141 GET_P0_CONV (rule
);
21144 case RULE_OP_MANGLE_CHR_DECR
:
21145 rule_buf
[rule_pos
] = rule_cmd
;
21146 GET_P0_CONV (rule
);
21149 case RULE_OP_MANGLE_REPLACE_NP1
:
21150 rule_buf
[rule_pos
] = rule_cmd
;
21151 GET_P0_CONV (rule
);
21154 case RULE_OP_MANGLE_REPLACE_NM1
:
21155 rule_buf
[rule_pos
] = rule_cmd
;
21156 GET_P0_CONV (rule
);
21159 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21160 rule_buf
[rule_pos
] = rule_cmd
;
21161 GET_P0_CONV (rule
);
21164 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21165 rule_buf
[rule_pos
] = rule_cmd
;
21166 GET_P0_CONV (rule
);
21169 case RULE_OP_MANGLE_TITLE
:
21170 rule_buf
[rule_pos
] = rule_cmd
;
21174 return rule_pos
- 1;
21192 * CPU rules : this is from hashcat sources, cpu based rules
21195 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21196 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21198 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21199 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21200 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21202 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21203 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21204 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21206 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21210 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21215 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21219 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21224 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21228 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21233 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21238 for (l
= 0; l
< arr_len
; l
++)
21240 r
= arr_len
- 1 - l
;
21244 MANGLE_SWITCH (arr
, l
, r
);
21250 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21252 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21254 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21256 return (arr_len
* 2);
21259 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21261 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21263 int orig_len
= arr_len
;
21267 for (i
= 0; i
< times
; i
++)
21269 memcpy (&arr
[arr_len
], arr
, orig_len
);
21271 arr_len
+= orig_len
;
21277 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21279 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21281 mangle_double (arr
, arr_len
);
21283 mangle_reverse (arr
+ arr_len
, arr_len
);
21285 return (arr_len
* 2);
21288 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21293 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21295 MANGLE_SWITCH (arr
, l
, r
);
21301 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21306 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21308 MANGLE_SWITCH (arr
, l
, r
);
21314 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21316 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21320 return (arr_len
+ 1);
21323 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21325 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21329 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21331 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21336 return (arr_len
+ 1);
21339 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21341 if (upos
>= arr_len
) return (arr_len
);
21345 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21347 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21350 return (arr_len
- 1);
21353 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21355 if (upos
>= arr_len
) return (arr_len
);
21357 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21361 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21363 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21369 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21371 if (upos
>= arr_len
) return (arr_len
);
21373 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21377 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21379 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21382 return (arr_len
- ulen
);
21385 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21387 if (upos
>= arr_len
) return (arr_len
);
21389 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21393 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21395 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21400 return (arr_len
+ 1);
21403 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
)
21405 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21407 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21409 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21411 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21413 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21415 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21417 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21419 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21421 return (arr_len
+ arr2_cpy
);
21424 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21426 if (upos
>= arr_len
) return (arr_len
);
21433 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21435 if (upos
>= arr_len
) return (arr_len
);
21437 memset (arr
+ upos
, 0, arr_len
- upos
);
21442 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21446 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21448 if (arr
[arr_pos
] != oldc
) continue;
21450 arr
[arr_pos
] = newc
;
21456 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21462 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21464 if (arr
[arr_pos
] == c
) continue;
21466 arr
[ret_len
] = arr
[arr_pos
];
21474 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21476 if (ulen
> arr_len
) return (arr_len
);
21478 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21480 char cs
[100] = { 0 };
21482 memcpy (cs
, arr
, ulen
);
21486 for (i
= 0; i
< ulen
; i
++)
21490 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21496 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21498 if (ulen
> arr_len
) return (arr_len
);
21500 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21502 int upos
= arr_len
- ulen
;
21506 for (i
= 0; i
< ulen
; i
++)
21508 char c
= arr
[upos
+ i
];
21510 arr_len
= mangle_append (arr
, arr_len
, c
);
21516 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21518 if ( arr_len
== 0) return (arr_len
);
21519 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21521 char c
= arr
[upos
];
21525 for (i
= 0; i
< ulen
; i
++)
21527 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21533 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21535 if ( arr_len
== 0) return (arr_len
);
21536 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21540 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21542 int new_pos
= arr_pos
* 2;
21544 arr
[new_pos
] = arr
[arr_pos
];
21546 arr
[new_pos
+ 1] = arr
[arr_pos
];
21549 return (arr_len
* 2);
21552 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21554 if (upos
>= arr_len
) return (arr_len
);
21555 if (upos2
>= arr_len
) return (arr_len
);
21557 MANGLE_SWITCH (arr
, upos
, upos2
);
21562 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21564 MANGLE_SWITCH (arr
, upos
, upos2
);
21569 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21571 if (upos
>= arr_len
) return (arr_len
);
21578 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21580 if (upos
>= arr_len
) return (arr_len
);
21587 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21589 if (upos
>= arr_len
) return (arr_len
);
21596 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21598 if (upos
>= arr_len
) return (arr_len
);
21605 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21607 int upper_next
= 1;
21611 for (pos
= 0; pos
< arr_len
; pos
++)
21613 if (arr
[pos
] == ' ')
21624 MANGLE_UPPER_AT (arr
, pos
);
21628 MANGLE_LOWER_AT (arr
, pos
);
21635 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21637 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21643 for (j
= 0; j
< rp_gen_num
; j
++)
21650 switch ((char) get_random_num (0, 9))
21653 r
= get_random_num (0, sizeof (grp_op_nop
));
21654 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21658 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21659 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21660 p1
= get_random_num (0, sizeof (grp_pos
));
21661 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21665 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21666 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21667 p1
= get_random_num (1, 6);
21668 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21672 r
= get_random_num (0, sizeof (grp_op_chr
));
21673 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21674 p1
= get_random_num (0x20, 0x7e);
21675 rule_buf
[rule_pos
++] = (char) p1
;
21679 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21680 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21681 p1
= get_random_num (0x20, 0x7e);
21682 rule_buf
[rule_pos
++] = (char) p1
;
21683 p2
= get_random_num (0x20, 0x7e);
21685 p2
= get_random_num (0x20, 0x7e);
21686 rule_buf
[rule_pos
++] = (char) p2
;
21690 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21691 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21692 p1
= get_random_num (0, sizeof (grp_pos
));
21693 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21694 p2
= get_random_num (0x20, 0x7e);
21695 rule_buf
[rule_pos
++] = (char) p2
;
21699 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21700 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21701 p1
= get_random_num (0, sizeof (grp_pos
));
21702 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21703 p2
= get_random_num (0, sizeof (grp_pos
));
21705 p2
= get_random_num (0, sizeof (grp_pos
));
21706 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21710 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21711 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21712 p1
= get_random_num (0, sizeof (grp_pos
));
21713 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21714 p2
= get_random_num (1, sizeof (grp_pos
));
21716 p2
= get_random_num (1, sizeof (grp_pos
));
21717 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21721 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21722 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21723 p1
= get_random_num (0, sizeof (grp_pos
));
21724 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21725 p2
= get_random_num (1, sizeof (grp_pos
));
21726 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21727 p3
= get_random_num (0, sizeof (grp_pos
));
21728 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21736 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21738 char mem
[BLOCK_SIZE
] = { 0 };
21740 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21742 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21744 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21746 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21748 int out_len
= in_len
;
21749 int mem_len
= in_len
;
21751 memcpy (out
, in
, out_len
);
21755 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21760 switch (rule
[rule_pos
])
21765 case RULE_OP_MANGLE_NOOP
:
21768 case RULE_OP_MANGLE_LREST
:
21769 out_len
= mangle_lrest (out
, out_len
);
21772 case RULE_OP_MANGLE_UREST
:
21773 out_len
= mangle_urest (out
, out_len
);
21776 case RULE_OP_MANGLE_LREST_UFIRST
:
21777 out_len
= mangle_lrest (out
, out_len
);
21778 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21781 case RULE_OP_MANGLE_UREST_LFIRST
:
21782 out_len
= mangle_urest (out
, out_len
);
21783 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21786 case RULE_OP_MANGLE_TREST
:
21787 out_len
= mangle_trest (out
, out_len
);
21790 case RULE_OP_MANGLE_TOGGLE_AT
:
21791 NEXT_RULEPOS (rule_pos
);
21792 NEXT_RPTOI (rule
, rule_pos
, upos
);
21793 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21796 case RULE_OP_MANGLE_REVERSE
:
21797 out_len
= mangle_reverse (out
, out_len
);
21800 case RULE_OP_MANGLE_DUPEWORD
:
21801 out_len
= mangle_double (out
, out_len
);
21804 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21805 NEXT_RULEPOS (rule_pos
);
21806 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21807 out_len
= mangle_double_times (out
, out_len
, ulen
);
21810 case RULE_OP_MANGLE_REFLECT
:
21811 out_len
= mangle_reflect (out
, out_len
);
21814 case RULE_OP_MANGLE_ROTATE_LEFT
:
21815 mangle_rotate_left (out
, out_len
);
21818 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21819 mangle_rotate_right (out
, out_len
);
21822 case RULE_OP_MANGLE_APPEND
:
21823 NEXT_RULEPOS (rule_pos
);
21824 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21827 case RULE_OP_MANGLE_PREPEND
:
21828 NEXT_RULEPOS (rule_pos
);
21829 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21832 case RULE_OP_MANGLE_DELETE_FIRST
:
21833 out_len
= mangle_delete_at (out
, out_len
, 0);
21836 case RULE_OP_MANGLE_DELETE_LAST
:
21837 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21840 case RULE_OP_MANGLE_DELETE_AT
:
21841 NEXT_RULEPOS (rule_pos
);
21842 NEXT_RPTOI (rule
, rule_pos
, upos
);
21843 out_len
= mangle_delete_at (out
, out_len
, upos
);
21846 case RULE_OP_MANGLE_EXTRACT
:
21847 NEXT_RULEPOS (rule_pos
);
21848 NEXT_RPTOI (rule
, rule_pos
, upos
);
21849 NEXT_RULEPOS (rule_pos
);
21850 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21851 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21854 case RULE_OP_MANGLE_OMIT
:
21855 NEXT_RULEPOS (rule_pos
);
21856 NEXT_RPTOI (rule
, rule_pos
, upos
);
21857 NEXT_RULEPOS (rule_pos
);
21858 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21859 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21862 case RULE_OP_MANGLE_INSERT
:
21863 NEXT_RULEPOS (rule_pos
);
21864 NEXT_RPTOI (rule
, rule_pos
, upos
);
21865 NEXT_RULEPOS (rule_pos
);
21866 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21869 case RULE_OP_MANGLE_OVERSTRIKE
:
21870 NEXT_RULEPOS (rule_pos
);
21871 NEXT_RPTOI (rule
, rule_pos
, upos
);
21872 NEXT_RULEPOS (rule_pos
);
21873 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21876 case RULE_OP_MANGLE_TRUNCATE_AT
:
21877 NEXT_RULEPOS (rule_pos
);
21878 NEXT_RPTOI (rule
, rule_pos
, upos
);
21879 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21882 case RULE_OP_MANGLE_REPLACE
:
21883 NEXT_RULEPOS (rule_pos
);
21884 NEXT_RULEPOS (rule_pos
);
21885 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21888 case RULE_OP_MANGLE_PURGECHAR
:
21889 NEXT_RULEPOS (rule_pos
);
21890 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21893 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21897 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21898 NEXT_RULEPOS (rule_pos
);
21899 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21900 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21903 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21904 NEXT_RULEPOS (rule_pos
);
21905 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21906 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21909 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21910 out_len
= mangle_dupechar (out
, out_len
);
21913 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21914 NEXT_RULEPOS (rule_pos
);
21915 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21916 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21919 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21920 NEXT_RULEPOS (rule_pos
);
21921 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21922 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21925 case RULE_OP_MANGLE_SWITCH_FIRST
:
21926 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21929 case RULE_OP_MANGLE_SWITCH_LAST
:
21930 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21933 case RULE_OP_MANGLE_SWITCH_AT
:
21934 NEXT_RULEPOS (rule_pos
);
21935 NEXT_RPTOI (rule
, rule_pos
, upos
);
21936 NEXT_RULEPOS (rule_pos
);
21937 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21938 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
21941 case RULE_OP_MANGLE_CHR_SHIFTL
:
21942 NEXT_RULEPOS (rule_pos
);
21943 NEXT_RPTOI (rule
, rule_pos
, upos
);
21944 mangle_chr_shiftl (out
, out_len
, upos
);
21947 case RULE_OP_MANGLE_CHR_SHIFTR
:
21948 NEXT_RULEPOS (rule_pos
);
21949 NEXT_RPTOI (rule
, rule_pos
, upos
);
21950 mangle_chr_shiftr (out
, out_len
, upos
);
21953 case RULE_OP_MANGLE_CHR_INCR
:
21954 NEXT_RULEPOS (rule_pos
);
21955 NEXT_RPTOI (rule
, rule_pos
, upos
);
21956 mangle_chr_incr (out
, out_len
, upos
);
21959 case RULE_OP_MANGLE_CHR_DECR
:
21960 NEXT_RULEPOS (rule_pos
);
21961 NEXT_RPTOI (rule
, rule_pos
, upos
);
21962 mangle_chr_decr (out
, out_len
, upos
);
21965 case RULE_OP_MANGLE_REPLACE_NP1
:
21966 NEXT_RULEPOS (rule_pos
);
21967 NEXT_RPTOI (rule
, rule_pos
, upos
);
21968 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
21971 case RULE_OP_MANGLE_REPLACE_NM1
:
21972 NEXT_RULEPOS (rule_pos
);
21973 NEXT_RPTOI (rule
, rule_pos
, upos
);
21974 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
21977 case RULE_OP_MANGLE_TITLE
:
21978 out_len
= mangle_title (out
, out_len
);
21981 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
21982 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21983 NEXT_RULEPOS (rule_pos
);
21984 NEXT_RPTOI (rule
, rule_pos
, upos
);
21985 NEXT_RULEPOS (rule_pos
);
21986 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21987 NEXT_RULEPOS (rule_pos
);
21988 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21989 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
21992 case RULE_OP_MANGLE_APPEND_MEMORY
:
21993 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21994 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21995 memcpy (out
+ out_len
, mem
, mem_len
);
21996 out_len
+= mem_len
;
21999 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22000 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22001 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22002 memcpy (mem
+ mem_len
, out
, out_len
);
22003 out_len
+= mem_len
;
22004 memcpy (out
, mem
, out_len
);
22007 case RULE_OP_MEMORIZE_WORD
:
22008 memcpy (mem
, out
, out_len
);
22012 case RULE_OP_REJECT_LESS
:
22013 NEXT_RULEPOS (rule_pos
);
22014 NEXT_RPTOI (rule
, rule_pos
, upos
);
22015 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22018 case RULE_OP_REJECT_GREATER
:
22019 NEXT_RULEPOS (rule_pos
);
22020 NEXT_RPTOI (rule
, rule_pos
, upos
);
22021 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22024 case RULE_OP_REJECT_CONTAIN
:
22025 NEXT_RULEPOS (rule_pos
);
22026 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22029 case RULE_OP_REJECT_NOT_CONTAIN
:
22030 NEXT_RULEPOS (rule_pos
);
22031 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22034 case RULE_OP_REJECT_EQUAL_FIRST
:
22035 NEXT_RULEPOS (rule_pos
);
22036 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22039 case RULE_OP_REJECT_EQUAL_LAST
:
22040 NEXT_RULEPOS (rule_pos
);
22041 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22044 case RULE_OP_REJECT_EQUAL_AT
:
22045 NEXT_RULEPOS (rule_pos
);
22046 NEXT_RPTOI (rule
, rule_pos
, upos
);
22047 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22048 NEXT_RULEPOS (rule_pos
);
22049 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22052 case RULE_OP_REJECT_CONTAINS
:
22053 NEXT_RULEPOS (rule_pos
);
22054 NEXT_RPTOI (rule
, rule_pos
, upos
);
22055 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22056 NEXT_RULEPOS (rule_pos
);
22057 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22058 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22061 case RULE_OP_REJECT_MEMORY
:
22062 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22066 return (RULE_RC_SYNTAX_ERROR
);
22071 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);