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
);
2675 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2679 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2681 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2683 // can be used to determine if the device by index matches the cuda device by index
2684 // char name[100]; memset (name, 0, sizeof (name));
2685 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2692 log_info ("WARN: No NVML adapters found");
2700 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2702 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2704 if (iNumberAdapters
== 0)
2706 log_info ("WARN: No ADL adapters found.");
2715 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2717 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2718 ADLODParameters lpOdParameters;
2720 lpOdParameters.iSize = sizeof (ADLODParameters);
2721 size_t plevels_size = 0;
2723 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2725 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2726 __func__, iAdapterIndex,
2727 lpOdParameters.iNumberOfPerformanceLevels,
2728 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2729 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2731 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2733 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2735 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2737 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2739 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2740 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2741 __func__, iAdapterIndex, j,
2742 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2744 myfree (lpOdPerformanceLevels);
2750 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2752 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2754 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2756 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2758 return lpAdapterInfo
;
2763 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2766 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2770 for (uint i = 0; i < num_adl_adapters; i++)
2772 int opencl_bus_num = hm_device[i].busid;
2773 int opencl_dev_num = hm_device[i].devid;
2775 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2783 if (idx >= DEVICES_MAX) return -1;
2788 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2790 for (uint i = 0; i < opencl_num_devices; i++)
2792 cl_device_topology_amd device_topology;
2794 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2796 hm_device[i].busid = device_topology.pcie.bus;
2797 hm_device[i].devid = device_topology.pcie.device;
2802 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2804 // basically bubble sort
2806 for (int i
= 0; i
< num_adl_adapters
; i
++)
2808 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2810 // get info of adapter [x]
2812 u32 adapter_index_x
= valid_adl_device_list
[j
];
2813 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2815 u32 bus_num_x
= info_x
.iBusNumber
;
2816 u32 dev_num_x
= info_x
.iDeviceNumber
;
2818 // get info of adapter [y]
2820 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2821 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2823 u32 bus_num_y
= info_y
.iBusNumber
;
2824 u32 dev_num_y
= info_y
.iDeviceNumber
;
2828 if (bus_num_y
< bus_num_x
)
2832 else if (bus_num_y
== bus_num_x
)
2834 if (dev_num_y
< dev_num_x
)
2842 u32 temp
= valid_adl_device_list
[j
+ 1];
2844 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2845 valid_adl_device_list
[j
+ 0] = temp
;
2851 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2853 *num_adl_adapters
= 0;
2855 u32
*adl_adapters
= NULL
;
2857 int *bus_numbers
= NULL
;
2858 int *device_numbers
= NULL
;
2860 for (int i
= 0; i
< iNumberAdapters
; i
++)
2862 AdapterInfo info
= lpAdapterInfo
[i
];
2864 if (strlen (info
.strUDID
) < 1) continue;
2867 if (info
.iVendorID
!= 1002) continue;
2869 if (info
.iVendorID
!= 0x1002) continue;
2872 if (info
.iBusNumber
< 0) continue;
2873 if (info
.iDeviceNumber
< 0) continue;
2877 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2879 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2886 if (found
) continue;
2888 // add it to the list
2890 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2892 adl_adapters
[*num_adl_adapters
] = i
;
2894 // rest is just bookkeeping
2896 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2897 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2899 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2900 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2902 (*num_adl_adapters
)++;
2905 myfree (bus_numbers
);
2906 myfree (device_numbers
);
2908 // sort the list by increasing bus id, device id number
2910 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2912 return adl_adapters
;
2915 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2917 // loop through all valid devices
2919 for (int i
= 0; i
< num_adl_adapters
; i
++)
2921 u32 adapter_index
= valid_adl_device_list
[i
];
2925 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2927 // unfortunately this doesn't work since bus id and dev id are not unique
2928 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2929 // if (opencl_device_index == -1) continue;
2931 int opencl_device_index
= i
;
2933 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2935 // get fanspeed info
2937 if (hm_device
[opencl_device_index
].od_version
== 5)
2939 ADLFanSpeedInfo FanSpeedInfo
;
2941 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2943 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2945 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2947 // check read and write capability in fanspeedinfo
2949 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2950 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2952 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2956 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2959 else // od_version == 6
2961 ADLOD6FanSpeedInfo faninfo
;
2963 memset (&faninfo
, 0, sizeof (faninfo
));
2965 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2967 // check read capability in fanspeedinfo
2969 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2971 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2975 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2983 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2985 for (int i
= 0; i
< num_adl_adapters
; i
++)
2987 u32 adapter_index
= valid_adl_device_list
[i
];
2991 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2993 // get overdrive version
2995 int od_supported
= 0;
2999 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3001 // store the overdrive version in hm_device
3003 // unfortunately this doesn't work since bus id and dev id are not unique
3004 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3005 // if (opencl_device_index == -1) continue;
3007 int opencl_device_index
= i
;
3009 hm_device
[opencl_device_index
].od_version
= od_version
;
3015 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3017 for (int i
= 0; i
< num_adl_adapters
; i
++)
3019 u32 adapter_index
= valid_adl_device_list
[i
];
3023 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3025 // store the iAdapterIndex in hm_device
3027 // unfortunately this doesn't work since bus id and dev id are not unique
3028 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3029 // if (opencl_device_index == -1) continue;
3031 int opencl_device_index
= i
;
3033 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3036 return num_adl_adapters
;
3039 int hm_get_threshold_slowdown_with_device_id (const uint device_id
)
3041 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3043 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3047 if (data
.hm_device
[device_id
].od_version
== 5)
3051 else if (data
.hm_device
[device_id
].od_version
== 6)
3053 int CurrentValue
= 0;
3054 int DefaultValue
= 0;
3056 if (hm_ADL_Overdrive6_TargetTemperatureData_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &CurrentValue
, &DefaultValue
) != ADL_OK
) return -1;
3058 // the return value has never been tested since hm_ADL_Overdrive6_TargetTemperatureData_Get() never worked on any system. expect problems.
3060 return DefaultValue
;
3065 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3069 hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_THRESHOLD_SLOWDOWN
, (unsigned int *) &target
);
3077 int hm_get_temperature_with_device_id (const uint device_id
)
3079 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3081 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3085 if (data
.hm_device
[device_id
].od_version
== 5)
3087 ADLTemperature Temperature
;
3089 Temperature
.iSize
= sizeof (ADLTemperature
);
3091 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3093 return Temperature
.iTemperature
/ 1000;
3095 else if (data
.hm_device
[device_id
].od_version
== 6)
3097 int Temperature
= 0;
3099 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3101 return Temperature
/ 1000;
3106 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3108 int temperature
= 0;
3110 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
);
3118 int hm_get_fanpolicy_with_device_id (const uint device_id
)
3120 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3122 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3124 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3128 if (data
.hm_device
[device_id
].od_version
== 5)
3130 ADLFanSpeedValue lpFanSpeedValue
;
3132 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3134 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3135 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3137 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3139 return (lpFanSpeedValue
.iFanSpeed
& ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
) ? 0 : 1;
3141 else // od_version == 6
3148 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3163 int hm_get_fanspeed_with_device_id (const uint device_id
)
3165 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3167 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3169 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3173 if (data
.hm_device
[device_id
].od_version
== 5)
3175 ADLFanSpeedValue lpFanSpeedValue
;
3177 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3179 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3180 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3181 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3183 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3185 return lpFanSpeedValue
.iFanSpeed
;
3187 else // od_version == 6
3189 ADLOD6FanSpeedInfo faninfo
;
3191 memset (&faninfo
, 0, sizeof (faninfo
));
3193 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3195 return faninfo
.iFanSpeedPercent
;
3200 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3204 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
);
3213 int hm_get_buslanes_with_device_id (const uint device_id
)
3215 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3217 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3221 ADLPMActivity PMActivity
;
3223 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3225 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3227 return PMActivity
.iCurrentBusLanes
;
3231 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3233 unsigned int currLinkWidth
;
3235 hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &currLinkWidth
);
3237 return currLinkWidth
;
3243 int hm_get_utilization_with_device_id (const uint device_id
)
3245 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3247 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3251 ADLPMActivity PMActivity
;
3253 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3255 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3257 return PMActivity
.iActivityPercent
;
3261 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3263 nvmlUtilization_t utilization
;
3265 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3267 return utilization
.gpu
;
3273 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3275 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3277 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3281 ADLPMActivity PMActivity
;
3283 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3285 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3287 return PMActivity
.iMemoryClock
/ 100;
3291 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3295 hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_CLOCK_MEM
, &clock
);
3303 int hm_get_corespeed_with_device_id (const uint device_id
)
3305 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3307 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3311 ADLPMActivity PMActivity
;
3313 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3315 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3317 return PMActivity
.iEngineClock
/ 100;
3321 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3325 hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_CLOCK_SM
, &clock
);
3333 int hm_get_throttle_with_device_id (const uint device_id
)
3335 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3337 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3342 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3350 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3352 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3356 if (data
.hm_device
[device_id
].od_version
== 5)
3358 ADLFanSpeedValue lpFanSpeedValue
;
3360 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3362 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3363 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3364 lpFanSpeedValue
.iFlags
= (fanpolicy
== 1) ? ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
: 0;
3365 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3367 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3371 else // od_version == 6
3373 ADLOD6FanSpeedValue fan_speed_value
;
3375 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3377 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3378 fan_speed_value
.iFanSpeed
= fanspeed
;
3380 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3390 int hm_set_fanspeed_with_device_id_nvml (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3392 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3396 // NVML does not support setting the fan speed... :((
3398 if (fanspeed
== fanpolicy
) return -1; // makes the compiler happy
3405 #endif // HAVE_HWMON
3411 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3413 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3415 if (css_cnt
> SP_PW_MAX
)
3417 log_error ("ERROR: mask length is too long");
3422 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3424 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3426 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3427 uint cs_len
= css
[css_pos
].cs_len
;
3429 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3431 uint c
= cs_buf
[cs_pos
] & 0xff;
3438 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3440 cs_t
*cs
= &css
[css_cnt
];
3442 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3444 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3448 for (i
= 0; i
< cs
->cs_len
; i
++)
3450 const uint u
= cs
->cs_buf
[i
];
3455 for (i
= 0; i
< in_len
; i
++)
3457 uint u
= in_buf
[i
] & 0xff;
3459 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3461 if (css_uniq
[u
] == 1) continue;
3465 cs
->cs_buf
[cs
->cs_len
] = u
;
3473 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3477 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3479 uint p0
= in_buf
[in_pos
] & 0xff;
3481 if (interpret
== 1 && p0
== '?')
3485 if (in_pos
== in_len
) break;
3487 uint p1
= in_buf
[in_pos
] & 0xff;
3491 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3493 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3495 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3497 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3499 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3501 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3503 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3504 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3506 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3507 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3509 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3510 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3512 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3513 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3515 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3517 default: log_error ("Syntax error: %s", in_buf
);
3523 if (data
.hex_charset
)
3527 if (in_pos
== in_len
)
3529 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3534 uint p1
= in_buf
[in_pos
] & 0xff;
3536 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3538 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3545 chr
= hex_convert (p1
) << 0;
3546 chr
|= hex_convert (p0
) << 4;
3548 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3554 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3560 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3564 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3566 sum
*= css
[css_pos
].cs_len
;
3572 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3574 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3579 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3581 char p0
= mask_buf
[mask_pos
];
3587 if (mask_pos
== mask_len
) break;
3589 char p1
= mask_buf
[mask_pos
];
3595 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3597 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3599 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3601 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3603 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3605 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3607 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3608 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3610 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3611 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3613 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3614 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3616 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3617 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3619 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3621 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3627 if (data
.hex_charset
)
3631 // if there is no 2nd hex character, show an error:
3633 if (mask_pos
== mask_len
)
3635 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3640 char p1
= mask_buf
[mask_pos
];
3642 // if they are not valid hex character, show an error:
3644 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3646 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3653 chr
|= hex_convert (p1
) << 0;
3654 chr
|= hex_convert (p0
) << 4;
3656 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3662 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3669 log_error ("ERROR: invalid mask length (0)");
3679 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3681 for (int i
= 0; i
< css_cnt
; i
++)
3683 uint len
= css
[i
].cs_len
;
3684 u64 next
= val
/ len
;
3685 uint pos
= val
% len
;
3686 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3691 void mp_cut_at (char *mask
, uint max
)
3695 uint mask_len
= strlen (mask
);
3697 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3699 if (mask
[i
] == '?') i
++;
3705 void mp_setup_sys (cs_t
*mp_sys
)
3709 uint donec
[CHARSIZ
] = { 0 };
3711 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3712 mp_sys
[0].cs_buf
[pos
++] = chr
;
3713 mp_sys
[0].cs_len
= pos
; }
3715 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3716 mp_sys
[1].cs_buf
[pos
++] = chr
;
3717 mp_sys
[1].cs_len
= pos
; }
3719 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3720 mp_sys
[2].cs_buf
[pos
++] = chr
;
3721 mp_sys
[2].cs_len
= pos
; }
3723 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3724 mp_sys
[3].cs_buf
[pos
++] = chr
;
3725 mp_sys
[3].cs_len
= pos
; }
3727 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3728 mp_sys
[4].cs_len
= pos
; }
3730 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3731 mp_sys
[5].cs_len
= pos
; }
3734 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3736 FILE *fp
= fopen (buf
, "rb");
3738 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3740 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3744 char mp_file
[1024] = { 0 };
3746 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3750 len
= in_superchop (mp_file
);
3754 log_info ("WARNING: charset file corrupted");
3756 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3760 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3765 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3767 mp_usr
[index
].cs_len
= 0;
3769 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3772 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3774 char *new_mask_buf
= (char *) mymalloc (256);
3780 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3782 if (css_pos
== len
) break;
3784 char p0
= mask_buf
[mask_pos
];
3786 new_mask_buf
[mask_pos
] = p0
;
3792 if (mask_pos
== mask_len
) break;
3794 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3798 if (data
.hex_charset
)
3802 if (mask_pos
== mask_len
)
3804 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3809 char p1
= mask_buf
[mask_pos
];
3811 // if they are not valid hex character, show an error:
3813 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3815 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3820 new_mask_buf
[mask_pos
] = p1
;
3825 if (css_pos
== len
) return (new_mask_buf
);
3827 myfree (new_mask_buf
);
3836 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3842 for (i
= start
; i
< stop
; i
++)
3844 sum
*= root_css_buf
[i
].cs_len
;
3850 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3854 cs_t
*cs
= &root_css_buf
[start
];
3858 for (i
= start
; i
< stop
; i
++)
3860 const u64 m
= v
% cs
->cs_len
;
3861 const u64 d
= v
/ cs
->cs_len
;
3865 const uint k
= cs
->cs_buf
[m
];
3867 pw_buf
[i
- start
] = (char) k
;
3869 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3873 int sp_comp_val (const void *p1
, const void *p2
)
3875 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3876 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3878 return b2
->val
- b1
->val
;
3881 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
)
3888 * Initialize hcstats
3891 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3893 u64
*root_stats_ptr
= root_stats_buf
;
3895 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3897 for (i
= 0; i
< SP_PW_MAX
; i
++)
3899 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3901 root_stats_ptr
+= CHARSIZ
;
3904 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3906 u64
*markov_stats_ptr
= markov_stats_buf
;
3908 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3910 for (i
= 0; i
< SP_PW_MAX
; i
++)
3912 for (j
= 0; j
< CHARSIZ
; j
++)
3914 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3916 markov_stats_ptr
+= CHARSIZ
;
3926 char hcstat_tmp
[256] = { 0 };
3928 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3930 hcstat
= hcstat_tmp
;
3933 FILE *fd
= fopen (hcstat
, "rb");
3937 log_error ("%s: %s", hcstat
, strerror (errno
));
3942 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3944 log_error ("%s: Could not load data", hcstat
);
3951 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3953 log_error ("%s: Could not load data", hcstat
);
3963 * Markov modifier of hcstat_table on user request
3968 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3969 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3974 /* Add all stats to first position */
3976 for (i
= 1; i
< SP_PW_MAX
; i
++)
3978 u64
*out
= root_stats_buf_by_pos
[0];
3979 u64
*in
= root_stats_buf_by_pos
[i
];
3981 for (j
= 0; j
< CHARSIZ
; j
++)
3987 for (i
= 1; i
< SP_PW_MAX
; i
++)
3989 u64
*out
= markov_stats_buf_by_key
[0][0];
3990 u64
*in
= markov_stats_buf_by_key
[i
][0];
3992 for (j
= 0; j
< CHARSIZ
; j
++)
3994 for (k
= 0; k
< CHARSIZ
; k
++)
4001 /* copy them to all pw_positions */
4003 for (i
= 1; i
< SP_PW_MAX
; i
++)
4005 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4008 for (i
= 1; i
< SP_PW_MAX
; i
++)
4010 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4018 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4020 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4022 for (i
= 0; i
< SP_PW_MAX
; i
++)
4024 root_table_buf_by_pos
[i
] = root_table_ptr
;
4026 root_table_ptr
+= CHARSIZ
;
4029 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4031 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4033 for (i
= 0; i
< SP_PW_MAX
; i
++)
4035 for (j
= 0; j
< CHARSIZ
; j
++)
4037 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4039 markov_table_ptr
+= CHARSIZ
;
4044 * Convert hcstat to tables
4047 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4049 uint key
= i
% CHARSIZ
;
4051 root_table_buf
[i
].key
= key
;
4052 root_table_buf
[i
].val
= root_stats_buf
[i
];
4055 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4057 uint key
= i
% CHARSIZ
;
4059 markov_table_buf
[i
].key
= key
;
4060 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4063 myfree (root_stats_buf
);
4064 myfree (markov_stats_buf
);
4070 for (i
= 0; i
< SP_PW_MAX
; i
++)
4072 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4075 for (i
= 0; i
< SP_PW_MAX
; i
++)
4077 for (j
= 0; j
< CHARSIZ
; j
++)
4079 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4084 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
])
4087 * Convert tables to css
4090 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4092 uint pw_pos
= i
/ CHARSIZ
;
4094 cs_t
*cs
= &root_css_buf
[pw_pos
];
4096 if (cs
->cs_len
== threshold
) continue;
4098 uint key
= root_table_buf
[i
].key
;
4100 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4102 cs
->cs_buf
[cs
->cs_len
] = key
;
4108 * Convert table to css
4111 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4113 uint c
= i
/ CHARSIZ
;
4115 cs_t
*cs
= &markov_css_buf
[c
];
4117 if (cs
->cs_len
== threshold
) continue;
4119 uint pw_pos
= c
/ CHARSIZ
;
4121 uint key
= markov_table_buf
[i
].key
;
4123 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4125 cs
->cs_buf
[cs
->cs_len
] = key
;
4131 for (uint i = 0; i < 8; i++)
4133 for (uint j = 0x20; j < 0x80; j++)
4135 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4137 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4139 for (uint k = 0; k < 10; k++)
4141 printf (" %u\n", ptr->cs_buf[k]);
4148 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4150 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4152 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4162 for (uint j
= 1; j
< CHARSIZ
; j
++)
4172 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4174 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4176 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4178 out
+= CHARSIZ
* CHARSIZ
;
4179 in
+= CHARSIZ
* CHARSIZ
;
4181 for (uint j
= 0; j
< CHARSIZ
; j
++)
4188 for (uint k
= 1; k
< CHARSIZ
; k
++)
4200 * mixed shared functions
4203 void dump_hex (const u8
*s
, const int sz
)
4205 for (int i
= 0; i
< sz
; i
++)
4207 log_info_nn ("%02x ", s
[i
]);
4213 void usage_mini_print (const char *progname
)
4215 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4218 void usage_big_print (const char *progname
)
4220 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4223 char *get_exec_path ()
4225 int exec_path_len
= 1024;
4227 char *exec_path
= (char *) mymalloc (exec_path_len
);
4231 char tmp
[32] = { 0 };
4233 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4235 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4239 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4243 uint size
= exec_path_len
;
4245 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4247 log_error("! executable path buffer too small\n");
4252 const int len
= strlen (exec_path
);
4255 #error Your Operating System is not supported or detected
4263 char *get_install_dir (const char *progname
)
4265 char *install_dir
= mystrdup (progname
);
4266 char *last_slash
= NULL
;
4268 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4272 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4278 install_dir
[0] = '.';
4282 return (install_dir
);
4285 char *get_profile_dir (const char *homedir
)
4287 #define DOT_HASHCAT ".hashcat"
4289 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4291 char *profile_dir
= (char *) mymalloc (len
+ 1);
4293 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4298 char *get_session_dir (const char *profile_dir
)
4300 #define SESSIONS_FOLDER "sessions"
4302 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4304 char *session_dir
= (char *) mymalloc (len
+ 1);
4306 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4311 uint
count_lines (FILE *fd
)
4315 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4321 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4323 if (nread
< 1) continue;
4327 for (i
= 0; i
< nread
; i
++)
4329 if (prev
== '\n') cnt
++;
4340 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4344 FILE *fd
= fopen (filename
, "rb");
4348 log_error ("%s: %s", filename
, strerror (errno
));
4353 #define MAX_KEY_SIZE (1024 * 1024)
4355 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4357 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4363 for (int fpos
= 0; fpos
< nread
; fpos
++)
4365 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4367 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4368 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4369 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4370 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4372 if (kpos
>= 64) kpos
= 0;
4379 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4383 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4384 if (CPU_ISSET(core
, cpu_set
)) break;
4386 thread_affinity_policy_data_t policy
= { core
};
4388 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4390 if (data
.quiet
== 0)
4392 if (rc
!= KERN_SUCCESS
)
4394 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4402 void set_cpu_affinity (char *cpu_affinity
)
4405 DWORD_PTR aff_mask
= 0;
4413 char *devices
= strdup (cpu_affinity
);
4415 char *next
= strtok (devices
, ",");
4419 uint cpu_id
= atoi (next
);
4434 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4440 aff_mask
|= 1 << (cpu_id
- 1);
4442 CPU_SET ((cpu_id
- 1), &cpuset
);
4445 } while ((next
= strtok (NULL
, ",")) != NULL
);
4451 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4452 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4454 pthread_t thread
= pthread_self ();
4455 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4459 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4461 char *element
, *end
;
4463 end
= (char *) base
+ nmemb
* size
;
4465 for (element
= (char *) base
; element
< end
; element
+= size
)
4466 if (!compar (element
, key
))
4472 int sort_by_u32 (const void *v1
, const void *v2
)
4474 const u32
*s1
= (const u32
*) v1
;
4475 const u32
*s2
= (const u32
*) v2
;
4480 int sort_by_salt (const void *v1
, const void *v2
)
4482 const salt_t
*s1
= (const salt_t
*) v1
;
4483 const salt_t
*s2
= (const salt_t
*) v2
;
4485 const int res1
= s1
->salt_len
- s2
->salt_len
;
4487 if (res1
!= 0) return (res1
);
4489 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4491 if (res2
!= 0) return (res2
);
4499 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4500 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4507 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4508 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4514 int sort_by_salt_buf (const void *v1
, const void *v2
)
4516 const pot_t
*p1
= (const pot_t
*) v1
;
4517 const pot_t
*p2
= (const pot_t
*) v2
;
4519 const hash_t
*h1
= &p1
->hash
;
4520 const hash_t
*h2
= &p2
->hash
;
4522 const salt_t
*s1
= h1
->salt
;
4523 const salt_t
*s2
= h2
->salt
;
4529 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4530 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4536 int sort_by_hash_t_salt (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 // testphase: this should work
4549 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4550 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4553 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4554 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4555 if (s1->salt_len > s2->salt_len) return ( 1);
4556 if (s1->salt_len < s2->salt_len) return (-1);
4558 uint n = s1->salt_len;
4562 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4563 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4570 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4572 const hash_t
*h1
= (const hash_t
*) v1
;
4573 const hash_t
*h2
= (const hash_t
*) v2
;
4575 const salt_t
*s1
= h1
->salt
;
4576 const salt_t
*s2
= h2
->salt
;
4578 // 16 - 2 (since last 2 uints contain the digest)
4583 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4584 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4590 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4592 const hash_t
*h1
= (const hash_t
*) v1
;
4593 const hash_t
*h2
= (const hash_t
*) v2
;
4595 const void *d1
= h1
->digest
;
4596 const void *d2
= h2
->digest
;
4598 return data
.sort_by_digest (d1
, d2
);
4601 int sort_by_hash (const void *v1
, const void *v2
)
4603 const hash_t
*h1
= (const hash_t
*) v1
;
4604 const hash_t
*h2
= (const hash_t
*) v2
;
4608 const salt_t
*s1
= h1
->salt
;
4609 const salt_t
*s2
= h2
->salt
;
4611 int res
= sort_by_salt (s1
, s2
);
4613 if (res
!= 0) return (res
);
4616 const void *d1
= h1
->digest
;
4617 const void *d2
= h2
->digest
;
4619 return data
.sort_by_digest (d1
, d2
);
4622 int sort_by_pot (const void *v1
, const void *v2
)
4624 const pot_t
*p1
= (const pot_t
*) v1
;
4625 const pot_t
*p2
= (const pot_t
*) v2
;
4627 const hash_t
*h1
= &p1
->hash
;
4628 const hash_t
*h2
= &p2
->hash
;
4630 return sort_by_hash (h1
, h2
);
4633 int sort_by_mtime (const void *p1
, const void *p2
)
4635 const char **f1
= (const char **) p1
;
4636 const char **f2
= (const char **) p2
;
4638 struct stat s1
; stat (*f1
, &s1
);
4639 struct stat s2
; stat (*f2
, &s2
);
4641 return s2
.st_mtime
- s1
.st_mtime
;
4644 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4646 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4647 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4649 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4652 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4654 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4655 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4657 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4660 int sort_by_stringptr (const void *p1
, const void *p2
)
4662 const char **s1
= (const char **) p1
;
4663 const char **s2
= (const char **) p2
;
4665 return strcmp (*s1
, *s2
);
4668 int sort_by_dictstat (const void *s1
, const void *s2
)
4670 dictstat_t
*d1
= (dictstat_t
*) s1
;
4671 dictstat_t
*d2
= (dictstat_t
*) s2
;
4674 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4676 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4679 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4682 int sort_by_bitmap (const void *p1
, const void *p2
)
4684 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4685 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4687 return b1
->collisions
- b2
->collisions
;
4690 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4692 const u32
*d1
= (const u32
*) v1
;
4693 const u32
*d2
= (const u32
*) v2
;
4699 if (d1
[n
] > d2
[n
]) return ( 1);
4700 if (d1
[n
] < d2
[n
]) return (-1);
4706 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4708 const u32
*d1
= (const u32
*) v1
;
4709 const u32
*d2
= (const u32
*) v2
;
4715 if (d1
[n
] > d2
[n
]) return ( 1);
4716 if (d1
[n
] < d2
[n
]) return (-1);
4722 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4724 const u32
*d1
= (const u32
*) v1
;
4725 const u32
*d2
= (const u32
*) v2
;
4731 if (d1
[n
] > d2
[n
]) return ( 1);
4732 if (d1
[n
] < d2
[n
]) return (-1);
4738 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4740 const u32
*d1
= (const u32
*) v1
;
4741 const u32
*d2
= (const u32
*) v2
;
4747 if (d1
[n
] > d2
[n
]) return ( 1);
4748 if (d1
[n
] < d2
[n
]) return (-1);
4754 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4756 const u32
*d1
= (const u32
*) v1
;
4757 const u32
*d2
= (const u32
*) v2
;
4763 if (d1
[n
] > d2
[n
]) return ( 1);
4764 if (d1
[n
] < d2
[n
]) return (-1);
4770 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4772 const u32
*d1
= (const u32
*) v1
;
4773 const u32
*d2
= (const u32
*) v2
;
4779 if (d1
[n
] > d2
[n
]) return ( 1);
4780 if (d1
[n
] < d2
[n
]) return (-1);
4786 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4788 const u32
*d1
= (const u32
*) v1
;
4789 const u32
*d2
= (const u32
*) v2
;
4795 if (d1
[n
] > d2
[n
]) return ( 1);
4796 if (d1
[n
] < d2
[n
]) return (-1);
4802 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4804 const u32
*d1
= (const u32
*) v1
;
4805 const u32
*d2
= (const u32
*) v2
;
4811 if (d1
[n
] > d2
[n
]) return ( 1);
4812 if (d1
[n
] < d2
[n
]) return (-1);
4818 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4820 const u64
*d1
= (const u64
*) v1
;
4821 const u64
*d2
= (const u64
*) v2
;
4827 if (d1
[n
] > d2
[n
]) return ( 1);
4828 if (d1
[n
] < d2
[n
]) return (-1);
4834 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4836 const u64
*d1
= (const u64
*) v1
;
4837 const u64
*d2
= (const u64
*) v2
;
4843 if (d1
[n
] > d2
[n
]) return ( 1);
4844 if (d1
[n
] < d2
[n
]) return (-1);
4850 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4852 const u64
*d1
= (const u64
*) v1
;
4853 const u64
*d2
= (const u64
*) v2
;
4859 if (d1
[n
] > d2
[n
]) return ( 1);
4860 if (d1
[n
] < d2
[n
]) return (-1);
4866 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4868 const u32
*d1
= (const u32
*) v1
;
4869 const u32
*d2
= (const u32
*) v2
;
4871 const uint dgst_pos0
= data
.dgst_pos0
;
4872 const uint dgst_pos1
= data
.dgst_pos1
;
4873 const uint dgst_pos2
= data
.dgst_pos2
;
4874 const uint dgst_pos3
= data
.dgst_pos3
;
4876 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4877 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4878 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4879 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4880 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4881 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4882 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4883 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4888 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4890 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4891 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4893 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4895 if (res1
!= 0) return (res1
);
4900 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4902 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4903 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4905 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4907 if (res1
!= 0) return (res1
);
4909 const int res2
= t1
->attack_mode
4912 if (res2
!= 0) return (res2
);
4914 const int res3
= t1
->hash_type
4917 if (res3
!= 0) return (res3
);
4922 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
)
4924 uint outfile_autohex
= data
.outfile_autohex
;
4926 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4928 FILE *debug_fp
= NULL
;
4930 if (debug_file
!= NULL
)
4932 debug_fp
= fopen (debug_file
, "ab");
4934 lock_file (debug_fp
);
4941 if (debug_fp
== NULL
)
4943 log_info ("WARNING: Could not open debug-file for writing");
4947 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4949 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4951 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4954 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4956 if (debug_mode
== 4)
4958 fputc (':', debug_fp
);
4960 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4963 fputc ('\n', debug_fp
);
4965 if (debug_file
!= NULL
) fclose (debug_fp
);
4969 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4971 int needs_hexify
= 0;
4973 if (outfile_autohex
== 1)
4975 for (uint i
= 0; i
< plain_len
; i
++)
4977 if (plain_ptr
[i
] < 0x20)
4984 if (plain_ptr
[i
] > 0x7f)
4993 if (needs_hexify
== 1)
4995 fprintf (fp
, "$HEX[");
4997 for (uint i
= 0; i
< plain_len
; i
++)
4999 fprintf (fp
, "%02x", plain_ptr
[i
]);
5006 fwrite (plain_ptr
, plain_len
, 1, fp
);
5010 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
)
5012 uint outfile_format
= data
.outfile_format
;
5014 char separator
= data
.separator
;
5016 if (outfile_format
& OUTFILE_FMT_HASH
)
5018 fprintf (out_fp
, "%s", out_buf
);
5020 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5022 fputc (separator
, out_fp
);
5025 else if (data
.username
)
5027 if (username
!= NULL
)
5029 for (uint i
= 0; i
< user_len
; i
++)
5031 fprintf (out_fp
, "%c", username
[i
]);
5034 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5036 fputc (separator
, out_fp
);
5041 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5043 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5045 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5047 fputc (separator
, out_fp
);
5051 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5053 for (uint i
= 0; i
< plain_len
; i
++)
5055 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5058 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5060 fputc (separator
, out_fp
);
5064 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5067 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5072 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5074 fprintf (out_fp
, "%llu", crackpos
);
5079 fputc ('\n', out_fp
);
5082 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
)
5086 pot_key
.hash
.salt
= hashes_buf
->salt
;
5087 pot_key
.hash
.digest
= hashes_buf
->digest
;
5089 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5095 input_buf
[input_len
] = 0;
5098 unsigned char *username
= NULL
;
5103 user_t
*user
= hashes_buf
->hash_info
->user
;
5107 username
= (unsigned char *) (user
->user_name
);
5109 user_len
= user
->user_len
;
5113 // do output the line
5114 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5118 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5119 #define LM_MASKED_PLAIN "[notfound]"
5121 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
)
5127 pot_left_key
.hash
.salt
= hash_left
->salt
;
5128 pot_left_key
.hash
.digest
= hash_left
->digest
;
5130 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5134 uint weak_hash_found
= 0;
5136 pot_t pot_right_key
;
5138 pot_right_key
.hash
.salt
= hash_right
->salt
;
5139 pot_right_key
.hash
.digest
= hash_right
->digest
;
5141 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5143 if (pot_right_ptr
== NULL
)
5145 // special case, if "weak hash"
5147 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5149 weak_hash_found
= 1;
5151 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5153 // in theory this is not needed, but we are paranoia:
5155 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5156 pot_right_ptr
->plain_len
= 0;
5160 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5162 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
5167 // at least one half was found:
5171 input_buf
[input_len
] = 0;
5175 unsigned char *username
= NULL
;
5180 user_t
*user
= hash_left
->hash_info
->user
;
5184 username
= (unsigned char *) (user
->user_name
);
5186 user_len
= user
->user_len
;
5190 // mask the part which was not found
5192 uint left_part_masked
= 0;
5193 uint right_part_masked
= 0;
5195 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5197 if (pot_left_ptr
== NULL
)
5199 left_part_masked
= 1;
5201 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5203 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5205 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5206 pot_left_ptr
->plain_len
= mask_plain_len
;
5209 if (pot_right_ptr
== NULL
)
5211 right_part_masked
= 1;
5213 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5215 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5217 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5218 pot_right_ptr
->plain_len
= mask_plain_len
;
5221 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5225 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5227 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5229 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5231 // do output the line
5233 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5235 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5237 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5238 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5241 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
)
5245 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5247 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5249 if (pot_ptr
== NULL
)
5253 input_buf
[input_len
] = 0;
5255 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5259 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
)
5265 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5267 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5271 pot_t pot_right_key
;
5273 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5275 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5277 uint weak_hash_found
= 0;
5279 if (pot_right_ptr
== NULL
)
5281 // special case, if "weak hash"
5283 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5285 weak_hash_found
= 1;
5287 // we just need that pot_right_ptr is not a NULL pointer
5289 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5293 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5295 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5300 // ... at least one part was not cracked
5304 input_buf
[input_len
] = 0;
5306 // only show the hash part which is still not cracked
5308 uint user_len
= input_len
- 32;
5310 char *hash_output
= (char *) mymalloc (33);
5312 memcpy (hash_output
, input_buf
, input_len
);
5314 if (pot_left_ptr
!= NULL
)
5316 // only show right part (because left part was already found)
5318 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5320 hash_output
[user_len
+ 16] = 0;
5323 if (pot_right_ptr
!= NULL
)
5325 // only show left part (because right part was already found)
5327 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5329 hash_output
[user_len
+ 16] = 0;
5332 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5334 myfree (hash_output
);
5336 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5339 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5341 uint opencl_platforms_filter
= 0;
5343 if (opencl_platforms
)
5345 char *platforms
= strdup (opencl_platforms
);
5347 char *next
= strtok (platforms
, ",");
5351 int platform
= atoi (next
);
5353 if (platform
< 1 || platform
> 32)
5355 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5360 opencl_platforms_filter
|= 1 << (platform
- 1);
5362 } while ((next
= strtok (NULL
, ",")) != NULL
);
5368 opencl_platforms_filter
= -1;
5371 return opencl_platforms_filter
;
5374 u32
setup_devices_filter (char *opencl_devices
)
5376 u32 devices_filter
= 0;
5380 char *devices
= strdup (opencl_devices
);
5382 char *next
= strtok (devices
, ",");
5386 int device_id
= atoi (next
);
5388 if (device_id
< 1 || device_id
> 32)
5390 log_error ("ERROR: invalid device_id %u specified", device_id
);
5395 devices_filter
|= 1 << (device_id
- 1);
5397 } while ((next
= strtok (NULL
, ",")) != NULL
);
5403 devices_filter
= -1;
5406 return devices_filter
;
5409 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5411 cl_device_type device_types_filter
= 0;
5413 if (opencl_device_types
)
5415 char *device_types
= strdup (opencl_device_types
);
5417 char *next
= strtok (device_types
, ",");
5421 int device_type
= atoi (next
);
5423 if (device_type
< 1 || device_type
> 3)
5425 log_error ("ERROR: invalid device_type %u specified", device_type
);
5430 device_types_filter
|= 1 << device_type
;
5432 } while ((next
= strtok (NULL
, ",")) != NULL
);
5434 free (device_types
);
5438 // Do not use CPU by default, this often reduces GPU performance because
5439 // the CPU is too busy to handle GPU synchronization
5441 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5444 return device_types_filter
;
5447 u32
get_random_num (const u32 min
, const u32 max
)
5449 if (min
== max
) return (min
);
5451 return ((rand () % (max
- min
)) + min
);
5454 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5456 u32 quotient
= dividend
/ divisor
;
5458 if (dividend
% divisor
) quotient
++;
5463 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5465 u64 quotient
= dividend
/ divisor
;
5467 if (dividend
% divisor
) quotient
++;
5472 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5474 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5475 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5477 if (tm
->tm_year
- 70)
5479 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5480 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5482 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5484 else if (tm
->tm_yday
)
5486 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5487 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5489 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5491 else if (tm
->tm_hour
)
5493 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5494 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5496 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5498 else if (tm
->tm_min
)
5500 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5501 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5503 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5507 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5509 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5513 void format_speed_display (float val
, char *buf
, size_t len
)
5524 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5535 /* generate output */
5539 snprintf (buf
, len
- 1, "%.0f ", val
);
5543 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5547 void lowercase (u8
*buf
, int len
)
5549 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5552 void uppercase (u8
*buf
, int len
)
5554 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5557 int fgetl (FILE *fp
, char *line_buf
)
5563 const int c
= fgetc (fp
);
5565 if (c
== EOF
) break;
5567 line_buf
[line_len
] = (char) c
;
5571 if (line_len
== HCBUFSIZ
) line_len
--;
5573 if (c
== '\n') break;
5576 if (line_len
== 0) return 0;
5578 if (line_buf
[line_len
- 1] == '\n')
5582 line_buf
[line_len
] = 0;
5585 if (line_len
== 0) return 0;
5587 if (line_buf
[line_len
- 1] == '\r')
5591 line_buf
[line_len
] = 0;
5597 int in_superchop (char *buf
)
5599 int len
= strlen (buf
);
5603 if (buf
[len
- 1] == '\n')
5610 if (buf
[len
- 1] == '\r')
5625 char **scan_directory (const char *path
)
5627 char *tmp_path
= mystrdup (path
);
5629 size_t tmp_path_len
= strlen (tmp_path
);
5631 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5633 tmp_path
[tmp_path_len
- 1] = 0;
5635 tmp_path_len
= strlen (tmp_path
);
5638 char **files
= NULL
;
5644 if ((d
= opendir (tmp_path
)) != NULL
)
5650 memset (&e
, 0, sizeof (e
));
5651 struct dirent
*de
= NULL
;
5653 if (readdir_r (d
, &e
, &de
) != 0)
5655 log_error ("ERROR: readdir_r() failed");
5660 if (de
== NULL
) break;
5664 while ((de
= readdir (d
)) != NULL
)
5667 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5669 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5671 char *path_file
= (char *) mymalloc (path_size
+ 1);
5673 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5675 path_file
[path_size
] = 0;
5679 if ((d_test
= opendir (path_file
)) != NULL
)
5687 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5691 files
[num_files
- 1] = path_file
;
5697 else if (errno
== ENOTDIR
)
5699 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5703 files
[num_files
- 1] = mystrdup (path
);
5706 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5710 files
[num_files
- 1] = NULL
;
5717 int count_dictionaries (char **dictionary_files
)
5719 if (dictionary_files
== NULL
) return 0;
5723 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5731 char *stroptitype (const uint opti_type
)
5735 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5736 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5737 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5738 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5739 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5740 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5741 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5742 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5743 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5744 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5745 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5746 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5747 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5748 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5749 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5750 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5751 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5752 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5753 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5759 char *strparser (const uint parser_status
)
5761 switch (parser_status
)
5763 case PARSER_OK
: return ((char *) PA_000
); break;
5764 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5765 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5766 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5767 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5768 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5769 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5770 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5771 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5772 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5773 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5774 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5775 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5776 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5777 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5778 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5779 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5782 return ((char *) PA_255
);
5785 char *strhashtype (const uint hash_mode
)
5789 case 0: return ((char *) HT_00000
); break;
5790 case 10: return ((char *) HT_00010
); break;
5791 case 11: return ((char *) HT_00011
); break;
5792 case 12: return ((char *) HT_00012
); break;
5793 case 20: return ((char *) HT_00020
); break;
5794 case 21: return ((char *) HT_00021
); break;
5795 case 22: return ((char *) HT_00022
); break;
5796 case 23: return ((char *) HT_00023
); break;
5797 case 30: return ((char *) HT_00030
); break;
5798 case 40: return ((char *) HT_00040
); break;
5799 case 50: return ((char *) HT_00050
); break;
5800 case 60: return ((char *) HT_00060
); break;
5801 case 100: return ((char *) HT_00100
); break;
5802 case 101: return ((char *) HT_00101
); break;
5803 case 110: return ((char *) HT_00110
); break;
5804 case 111: return ((char *) HT_00111
); break;
5805 case 112: return ((char *) HT_00112
); break;
5806 case 120: return ((char *) HT_00120
); break;
5807 case 121: return ((char *) HT_00121
); break;
5808 case 122: return ((char *) HT_00122
); break;
5809 case 124: return ((char *) HT_00124
); break;
5810 case 125: return ((char *) HT_00125
); break;
5811 case 130: return ((char *) HT_00130
); break;
5812 case 131: return ((char *) HT_00131
); break;
5813 case 132: return ((char *) HT_00132
); break;
5814 case 133: return ((char *) HT_00133
); break;
5815 case 140: return ((char *) HT_00140
); break;
5816 case 141: return ((char *) HT_00141
); break;
5817 case 150: return ((char *) HT_00150
); break;
5818 case 160: return ((char *) HT_00160
); break;
5819 case 190: return ((char *) HT_00190
); break;
5820 case 200: return ((char *) HT_00200
); break;
5821 case 300: return ((char *) HT_00300
); break;
5822 case 400: return ((char *) HT_00400
); break;
5823 case 500: return ((char *) HT_00500
); break;
5824 case 501: return ((char *) HT_00501
); break;
5825 case 900: return ((char *) HT_00900
); break;
5826 case 910: return ((char *) HT_00910
); break;
5827 case 1000: return ((char *) HT_01000
); break;
5828 case 1100: return ((char *) HT_01100
); break;
5829 case 1400: return ((char *) HT_01400
); break;
5830 case 1410: return ((char *) HT_01410
); break;
5831 case 1420: return ((char *) HT_01420
); break;
5832 case 1421: return ((char *) HT_01421
); break;
5833 case 1430: return ((char *) HT_01430
); break;
5834 case 1440: return ((char *) HT_01440
); break;
5835 case 1441: return ((char *) HT_01441
); break;
5836 case 1450: return ((char *) HT_01450
); break;
5837 case 1460: return ((char *) HT_01460
); break;
5838 case 1500: return ((char *) HT_01500
); break;
5839 case 1600: return ((char *) HT_01600
); break;
5840 case 1700: return ((char *) HT_01700
); break;
5841 case 1710: return ((char *) HT_01710
); break;
5842 case 1711: return ((char *) HT_01711
); break;
5843 case 1720: return ((char *) HT_01720
); break;
5844 case 1722: return ((char *) HT_01722
); break;
5845 case 1730: return ((char *) HT_01730
); break;
5846 case 1731: return ((char *) HT_01731
); break;
5847 case 1740: return ((char *) HT_01740
); break;
5848 case 1750: return ((char *) HT_01750
); break;
5849 case 1760: return ((char *) HT_01760
); break;
5850 case 1800: return ((char *) HT_01800
); break;
5851 case 2100: return ((char *) HT_02100
); break;
5852 case 2400: return ((char *) HT_02400
); break;
5853 case 2410: return ((char *) HT_02410
); break;
5854 case 2500: return ((char *) HT_02500
); break;
5855 case 2600: return ((char *) HT_02600
); break;
5856 case 2611: return ((char *) HT_02611
); break;
5857 case 2612: return ((char *) HT_02612
); break;
5858 case 2711: return ((char *) HT_02711
); break;
5859 case 2811: return ((char *) HT_02811
); break;
5860 case 3000: return ((char *) HT_03000
); break;
5861 case 3100: return ((char *) HT_03100
); break;
5862 case 3200: return ((char *) HT_03200
); break;
5863 case 3710: return ((char *) HT_03710
); break;
5864 case 3711: return ((char *) HT_03711
); break;
5865 case 3800: return ((char *) HT_03800
); break;
5866 case 4300: return ((char *) HT_04300
); break;
5867 case 4400: return ((char *) HT_04400
); break;
5868 case 4500: return ((char *) HT_04500
); break;
5869 case 4700: return ((char *) HT_04700
); break;
5870 case 4800: return ((char *) HT_04800
); break;
5871 case 4900: return ((char *) HT_04900
); break;
5872 case 5000: return ((char *) HT_05000
); break;
5873 case 5100: return ((char *) HT_05100
); break;
5874 case 5200: return ((char *) HT_05200
); break;
5875 case 5300: return ((char *) HT_05300
); break;
5876 case 5400: return ((char *) HT_05400
); break;
5877 case 5500: return ((char *) HT_05500
); break;
5878 case 5600: return ((char *) HT_05600
); break;
5879 case 5700: return ((char *) HT_05700
); break;
5880 case 5800: return ((char *) HT_05800
); break;
5881 case 6000: return ((char *) HT_06000
); break;
5882 case 6100: return ((char *) HT_06100
); break;
5883 case 6211: return ((char *) HT_06211
); break;
5884 case 6212: return ((char *) HT_06212
); break;
5885 case 6213: return ((char *) HT_06213
); break;
5886 case 6221: return ((char *) HT_06221
); break;
5887 case 6222: return ((char *) HT_06222
); break;
5888 case 6223: return ((char *) HT_06223
); break;
5889 case 6231: return ((char *) HT_06231
); break;
5890 case 6232: return ((char *) HT_06232
); break;
5891 case 6233: return ((char *) HT_06233
); break;
5892 case 6241: return ((char *) HT_06241
); break;
5893 case 6242: return ((char *) HT_06242
); break;
5894 case 6243: return ((char *) HT_06243
); break;
5895 case 6300: return ((char *) HT_06300
); break;
5896 case 6400: return ((char *) HT_06400
); break;
5897 case 6500: return ((char *) HT_06500
); break;
5898 case 6600: return ((char *) HT_06600
); break;
5899 case 6700: return ((char *) HT_06700
); break;
5900 case 6800: return ((char *) HT_06800
); break;
5901 case 6900: return ((char *) HT_06900
); break;
5902 case 7100: return ((char *) HT_07100
); break;
5903 case 7200: return ((char *) HT_07200
); break;
5904 case 7300: return ((char *) HT_07300
); break;
5905 case 7400: return ((char *) HT_07400
); break;
5906 case 7500: return ((char *) HT_07500
); break;
5907 case 7600: return ((char *) HT_07600
); break;
5908 case 7700: return ((char *) HT_07700
); break;
5909 case 7800: return ((char *) HT_07800
); break;
5910 case 7900: return ((char *) HT_07900
); break;
5911 case 8000: return ((char *) HT_08000
); break;
5912 case 8100: return ((char *) HT_08100
); break;
5913 case 8200: return ((char *) HT_08200
); break;
5914 case 8300: return ((char *) HT_08300
); break;
5915 case 8400: return ((char *) HT_08400
); break;
5916 case 8500: return ((char *) HT_08500
); break;
5917 case 8600: return ((char *) HT_08600
); break;
5918 case 8700: return ((char *) HT_08700
); break;
5919 case 8800: return ((char *) HT_08800
); break;
5920 case 8900: return ((char *) HT_08900
); break;
5921 case 9000: return ((char *) HT_09000
); break;
5922 case 9100: return ((char *) HT_09100
); break;
5923 case 9200: return ((char *) HT_09200
); break;
5924 case 9300: return ((char *) HT_09300
); break;
5925 case 9400: return ((char *) HT_09400
); break;
5926 case 9500: return ((char *) HT_09500
); break;
5927 case 9600: return ((char *) HT_09600
); break;
5928 case 9700: return ((char *) HT_09700
); break;
5929 case 9710: return ((char *) HT_09710
); break;
5930 case 9720: return ((char *) HT_09720
); break;
5931 case 9800: return ((char *) HT_09800
); break;
5932 case 9810: return ((char *) HT_09810
); break;
5933 case 9820: return ((char *) HT_09820
); break;
5934 case 9900: return ((char *) HT_09900
); break;
5935 case 10000: return ((char *) HT_10000
); break;
5936 case 10100: return ((char *) HT_10100
); break;
5937 case 10200: return ((char *) HT_10200
); break;
5938 case 10300: return ((char *) HT_10300
); break;
5939 case 10400: return ((char *) HT_10400
); break;
5940 case 10410: return ((char *) HT_10410
); break;
5941 case 10420: return ((char *) HT_10420
); break;
5942 case 10500: return ((char *) HT_10500
); break;
5943 case 10600: return ((char *) HT_10600
); break;
5944 case 10700: return ((char *) HT_10700
); break;
5945 case 10800: return ((char *) HT_10800
); break;
5946 case 10900: return ((char *) HT_10900
); break;
5947 case 11000: return ((char *) HT_11000
); break;
5948 case 11100: return ((char *) HT_11100
); break;
5949 case 11200: return ((char *) HT_11200
); break;
5950 case 11300: return ((char *) HT_11300
); break;
5951 case 11400: return ((char *) HT_11400
); break;
5952 case 11500: return ((char *) HT_11500
); break;
5953 case 11600: return ((char *) HT_11600
); break;
5954 case 11700: return ((char *) HT_11700
); break;
5955 case 11800: return ((char *) HT_11800
); break;
5956 case 11900: return ((char *) HT_11900
); break;
5957 case 12000: return ((char *) HT_12000
); break;
5958 case 12100: return ((char *) HT_12100
); break;
5959 case 12200: return ((char *) HT_12200
); break;
5960 case 12300: return ((char *) HT_12300
); break;
5961 case 12400: return ((char *) HT_12400
); break;
5962 case 12500: return ((char *) HT_12500
); break;
5963 case 12600: return ((char *) HT_12600
); break;
5964 case 12700: return ((char *) HT_12700
); break;
5965 case 12800: return ((char *) HT_12800
); break;
5966 case 12900: return ((char *) HT_12900
); break;
5967 case 13000: return ((char *) HT_13000
); break;
5968 case 13100: return ((char *) HT_13100
); break;
5969 case 13200: return ((char *) HT_13200
); break;
5970 case 13300: return ((char *) HT_13300
); break;
5971 case 13400: return ((char *) HT_13400
); break;
5972 case 13500: return ((char *) HT_13500
); break;
5973 case 13600: return ((char *) HT_13600
); break;
5974 case 13711: return ((char *) HT_13711
); break;
5975 case 13712: return ((char *) HT_13712
); break;
5976 case 13713: return ((char *) HT_13713
); break;
5977 case 13721: return ((char *) HT_13721
); break;
5978 case 13722: return ((char *) HT_13722
); break;
5979 case 13723: return ((char *) HT_13723
); break;
5980 case 13731: return ((char *) HT_13731
); break;
5981 case 13732: return ((char *) HT_13732
); break;
5982 case 13733: return ((char *) HT_13733
); break;
5983 case 13741: return ((char *) HT_13741
); break;
5984 case 13742: return ((char *) HT_13742
); break;
5985 case 13743: return ((char *) HT_13743
); break;
5986 case 13751: return ((char *) HT_13751
); break;
5987 case 13752: return ((char *) HT_13752
); break;
5988 case 13753: return ((char *) HT_13753
); break;
5989 case 13761: return ((char *) HT_13761
); break;
5990 case 13762: return ((char *) HT_13762
); break;
5991 case 13763: return ((char *) HT_13763
); break;
5994 return ((char *) "Unknown");
5997 char *strstatus (const uint devices_status
)
5999 switch (devices_status
)
6001 case STATUS_INIT
: return ((char *) ST_0000
); break;
6002 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6003 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6004 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6005 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6006 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6007 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6008 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6009 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6010 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6011 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6014 return ((char *) "Unknown");
6017 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6019 uint hash_type
= data
.hash_type
;
6020 uint hash_mode
= data
.hash_mode
;
6021 uint salt_type
= data
.salt_type
;
6022 uint opts_type
= data
.opts_type
;
6023 uint opti_type
= data
.opti_type
;
6024 uint dgst_size
= data
.dgst_size
;
6026 char *hashfile
= data
.hashfile
;
6030 uint digest_buf
[64] = { 0 };
6032 u64
*digest_buf64
= (u64
*) digest_buf
;
6034 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6036 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6038 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6044 case HASH_TYPE_DESCRYPT
:
6045 FP (digest_buf
[1], digest_buf
[0], tt
);
6048 case HASH_TYPE_DESRACF
:
6049 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6050 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6052 FP (digest_buf
[1], digest_buf
[0], tt
);
6056 FP (digest_buf
[1], digest_buf
[0], tt
);
6059 case HASH_TYPE_NETNTLM
:
6060 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6061 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6062 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6063 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6065 FP (digest_buf
[1], digest_buf
[0], tt
);
6066 FP (digest_buf
[3], digest_buf
[2], tt
);
6069 case HASH_TYPE_BSDICRYPT
:
6070 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6071 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6073 FP (digest_buf
[1], digest_buf
[0], tt
);
6078 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6083 digest_buf
[0] += MD4M_A
;
6084 digest_buf
[1] += MD4M_B
;
6085 digest_buf
[2] += MD4M_C
;
6086 digest_buf
[3] += MD4M_D
;
6090 digest_buf
[0] += MD5M_A
;
6091 digest_buf
[1] += MD5M_B
;
6092 digest_buf
[2] += MD5M_C
;
6093 digest_buf
[3] += MD5M_D
;
6096 case HASH_TYPE_SHA1
:
6097 digest_buf
[0] += SHA1M_A
;
6098 digest_buf
[1] += SHA1M_B
;
6099 digest_buf
[2] += SHA1M_C
;
6100 digest_buf
[3] += SHA1M_D
;
6101 digest_buf
[4] += SHA1M_E
;
6104 case HASH_TYPE_SHA256
:
6105 digest_buf
[0] += SHA256M_A
;
6106 digest_buf
[1] += SHA256M_B
;
6107 digest_buf
[2] += SHA256M_C
;
6108 digest_buf
[3] += SHA256M_D
;
6109 digest_buf
[4] += SHA256M_E
;
6110 digest_buf
[5] += SHA256M_F
;
6111 digest_buf
[6] += SHA256M_G
;
6112 digest_buf
[7] += SHA256M_H
;
6115 case HASH_TYPE_SHA384
:
6116 digest_buf64
[0] += SHA384M_A
;
6117 digest_buf64
[1] += SHA384M_B
;
6118 digest_buf64
[2] += SHA384M_C
;
6119 digest_buf64
[3] += SHA384M_D
;
6120 digest_buf64
[4] += SHA384M_E
;
6121 digest_buf64
[5] += SHA384M_F
;
6122 digest_buf64
[6] += 0;
6123 digest_buf64
[7] += 0;
6126 case HASH_TYPE_SHA512
:
6127 digest_buf64
[0] += SHA512M_A
;
6128 digest_buf64
[1] += SHA512M_B
;
6129 digest_buf64
[2] += SHA512M_C
;
6130 digest_buf64
[3] += SHA512M_D
;
6131 digest_buf64
[4] += SHA512M_E
;
6132 digest_buf64
[5] += SHA512M_F
;
6133 digest_buf64
[6] += SHA512M_G
;
6134 digest_buf64
[7] += SHA512M_H
;
6139 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6141 if (dgst_size
== DGST_SIZE_4_2
)
6143 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6145 else if (dgst_size
== DGST_SIZE_4_4
)
6147 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6149 else if (dgst_size
== DGST_SIZE_4_5
)
6151 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6153 else if (dgst_size
== DGST_SIZE_4_6
)
6155 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6157 else if (dgst_size
== DGST_SIZE_4_8
)
6159 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6161 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6163 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6165 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6167 else if (hash_type
== HASH_TYPE_SHA384
)
6169 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6171 else if (hash_type
== HASH_TYPE_SHA512
)
6173 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6175 else if (hash_type
== HASH_TYPE_GOST
)
6177 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6180 else if (dgst_size
== DGST_SIZE_4_64
)
6182 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6184 else if (dgst_size
== DGST_SIZE_8_25
)
6186 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6190 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6191 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6192 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6198 memset (&salt
, 0, sizeof (salt_t
));
6200 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6202 char *ptr
= (char *) salt
.salt_buf
;
6204 uint len
= salt
.salt_len
;
6206 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6212 case HASH_TYPE_NETNTLM
:
6214 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6215 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6217 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6223 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6225 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6233 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6235 uint max
= salt
.salt_len
/ 4;
6239 for (uint i
= 0; i
< max
; i
++)
6241 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6245 if (opts_type
& OPTS_TYPE_ST_HEX
)
6247 char tmp
[64] = { 0 };
6249 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6251 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6256 memcpy (ptr
, tmp
, len
);
6259 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6261 memset (ptr
+ len
, 0, memset_size
);
6263 salt
.salt_len
= len
;
6267 // some modes require special encoding
6270 uint out_buf_plain
[256] = { 0 };
6271 uint out_buf_salt
[256] = { 0 };
6273 char tmp_buf
[1024] = { 0 };
6275 char *ptr_plain
= (char *) out_buf_plain
;
6276 char *ptr_salt
= (char *) out_buf_salt
;
6278 if (hash_mode
== 22)
6280 char username
[30] = { 0 };
6282 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6284 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6286 u16
*ptr
= (u16
*) digest_buf
;
6288 tmp_buf
[ 0] = sig
[0];
6289 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6290 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6291 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6292 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6293 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6294 tmp_buf
[ 6] = sig
[1];
6295 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6296 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6297 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6298 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6299 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6300 tmp_buf
[12] = sig
[2];
6301 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6302 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6303 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6304 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6305 tmp_buf
[17] = sig
[3];
6306 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6307 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6308 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6309 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6310 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6311 tmp_buf
[23] = sig
[4];
6312 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6313 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6314 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6315 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6316 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6317 tmp_buf
[29] = sig
[5];
6319 snprintf (out_buf
, len
-1, "%s:%s",
6323 else if (hash_mode
== 23)
6325 // do not show the skyper part in output
6327 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6329 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6331 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6338 else if (hash_mode
== 101)
6340 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6342 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6343 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6344 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6345 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6346 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6348 memcpy (tmp_buf
, digest_buf
, 20);
6350 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6352 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6354 else if (hash_mode
== 111)
6356 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6358 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6359 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6360 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6361 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6362 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6364 memcpy (tmp_buf
, digest_buf
, 20);
6365 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6367 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6369 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6371 else if ((hash_mode
== 122) || (hash_mode
== 125))
6373 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6374 (char *) salt
.salt_buf
,
6381 else if (hash_mode
== 124)
6383 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6384 (char *) salt
.salt_buf
,
6391 else if (hash_mode
== 131)
6393 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6394 (char *) salt
.salt_buf
,
6402 else if (hash_mode
== 132)
6404 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6405 (char *) salt
.salt_buf
,
6412 else if (hash_mode
== 133)
6414 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6416 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6417 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6418 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6419 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6420 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6422 memcpy (tmp_buf
, digest_buf
, 20);
6424 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6426 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6428 else if (hash_mode
== 141)
6430 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6432 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6434 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6436 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6438 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6439 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6440 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6441 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6442 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6444 memcpy (tmp_buf
, digest_buf
, 20);
6446 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6450 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6452 else if (hash_mode
== 400)
6454 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6456 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6457 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6458 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6459 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6461 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6463 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6465 else if (hash_mode
== 500)
6467 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6469 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6470 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6471 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6472 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6474 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6476 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6478 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6482 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6485 else if (hash_mode
== 501)
6487 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6489 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6490 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6492 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6494 else if (hash_mode
== 1421)
6496 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6498 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6514 else if (hash_mode
== 1441)
6516 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6518 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6520 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6522 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6524 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6525 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6526 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6527 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6528 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6529 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6530 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6531 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6533 memcpy (tmp_buf
, digest_buf
, 32);
6535 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6539 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6541 else if (hash_mode
== 1500)
6543 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6544 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6545 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6546 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6547 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6549 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6551 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6553 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6554 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6556 memcpy (tmp_buf
, digest_buf
, 8);
6558 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6560 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6564 else if (hash_mode
== 1600)
6566 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6568 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6569 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6570 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6571 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6573 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6575 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6577 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6581 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6584 else if (hash_mode
== 1711)
6586 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6588 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6589 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6590 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6591 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6592 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6593 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6594 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6595 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6597 memcpy (tmp_buf
, digest_buf
, 64);
6598 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6600 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6602 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6604 else if (hash_mode
== 1722)
6606 uint
*ptr
= digest_buf
;
6608 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6609 (unsigned char *) salt
.salt_buf
,
6619 else if (hash_mode
== 1731)
6621 uint
*ptr
= digest_buf
;
6623 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6624 (unsigned char *) salt
.salt_buf
,
6634 else if (hash_mode
== 1800)
6638 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6639 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6640 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6641 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6642 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6643 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6644 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6645 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6647 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6649 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6651 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6655 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6658 else if (hash_mode
== 2100)
6662 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6664 salt
.salt_iter
+ 1);
6666 uint signature_len
= strlen (out_buf
);
6668 pos
+= signature_len
;
6669 len
-= signature_len
;
6671 char *salt_ptr
= (char *) salt
.salt_buf
;
6673 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6675 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6676 byte_swap_32 (digest_buf
[0]),
6677 byte_swap_32 (digest_buf
[1]),
6678 byte_swap_32 (digest_buf
[2]),
6679 byte_swap_32 (digest_buf
[3]));
6681 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6683 memcpy (tmp_buf
, digest_buf
, 16);
6685 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6687 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6688 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6689 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6690 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6692 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6693 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6694 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6695 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6697 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6698 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6699 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6700 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6702 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6703 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6704 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6705 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6707 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6708 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6709 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6710 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6714 else if (hash_mode
== 2500)
6716 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6718 wpa_t
*wpa
= &wpas
[salt_pos
];
6720 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6721 (char *) salt
.salt_buf
,
6735 else if (hash_mode
== 4400)
6737 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6738 byte_swap_32 (digest_buf
[0]),
6739 byte_swap_32 (digest_buf
[1]),
6740 byte_swap_32 (digest_buf
[2]),
6741 byte_swap_32 (digest_buf
[3]));
6743 else if (hash_mode
== 4700)
6745 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6746 byte_swap_32 (digest_buf
[0]),
6747 byte_swap_32 (digest_buf
[1]),
6748 byte_swap_32 (digest_buf
[2]),
6749 byte_swap_32 (digest_buf
[3]),
6750 byte_swap_32 (digest_buf
[4]));
6752 else if (hash_mode
== 4800)
6754 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6756 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6761 byte_swap_32 (salt
.salt_buf
[0]),
6762 byte_swap_32 (salt
.salt_buf
[1]),
6763 byte_swap_32 (salt
.salt_buf
[2]),
6764 byte_swap_32 (salt
.salt_buf
[3]),
6767 else if (hash_mode
== 4900)
6769 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6770 byte_swap_32 (digest_buf
[0]),
6771 byte_swap_32 (digest_buf
[1]),
6772 byte_swap_32 (digest_buf
[2]),
6773 byte_swap_32 (digest_buf
[3]),
6774 byte_swap_32 (digest_buf
[4]));
6776 else if (hash_mode
== 5100)
6778 snprintf (out_buf
, len
-1, "%08x%08x",
6782 else if (hash_mode
== 5200)
6784 snprintf (out_buf
, len
-1, "%s", hashfile
);
6786 else if (hash_mode
== 5300)
6788 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6790 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6792 int buf_len
= len
-1;
6796 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6798 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6800 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6802 snprintf (out_buf
, buf_len
, ":");
6808 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6816 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6818 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6820 if ((i
== 0) || (i
== 5))
6822 snprintf (out_buf
, buf_len
, ":");
6828 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6836 for (uint i
= 0; i
< 4; i
++)
6840 snprintf (out_buf
, buf_len
, ":");
6846 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6852 else if (hash_mode
== 5400)
6854 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6856 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6858 int buf_len
= len
-1;
6862 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6864 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6866 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6868 snprintf (out_buf
, buf_len
, ":");
6874 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6882 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6884 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6886 if ((i
== 0) || (i
== 5))
6888 snprintf (out_buf
, buf_len
, ":");
6894 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6902 for (uint i
= 0; i
< 5; i
++)
6906 snprintf (out_buf
, buf_len
, ":");
6912 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6918 else if (hash_mode
== 5500)
6920 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6922 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6924 char user_buf
[64] = { 0 };
6925 char domain_buf
[64] = { 0 };
6926 char srvchall_buf
[1024] = { 0 };
6927 char clichall_buf
[1024] = { 0 };
6929 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6931 char *ptr
= (char *) netntlm
->userdomain_buf
;
6933 user_buf
[i
] = ptr
[j
];
6936 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6938 char *ptr
= (char *) netntlm
->userdomain_buf
;
6940 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6943 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6945 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6947 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6950 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6952 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6954 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6957 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6965 byte_swap_32 (salt
.salt_buf_pc
[0]),
6966 byte_swap_32 (salt
.salt_buf_pc
[1]),
6969 else if (hash_mode
== 5600)
6971 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6973 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6975 char user_buf
[64] = { 0 };
6976 char domain_buf
[64] = { 0 };
6977 char srvchall_buf
[1024] = { 0 };
6978 char clichall_buf
[1024] = { 0 };
6980 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6982 char *ptr
= (char *) netntlm
->userdomain_buf
;
6984 user_buf
[i
] = ptr
[j
];
6987 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6989 char *ptr
= (char *) netntlm
->userdomain_buf
;
6991 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6994 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6996 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6998 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7001 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7003 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7005 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7008 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7018 else if (hash_mode
== 5700)
7020 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7022 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7023 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7024 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7025 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7026 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7027 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7028 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7029 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7031 memcpy (tmp_buf
, digest_buf
, 32);
7033 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7037 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7039 else if (hash_mode
== 5800)
7041 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7042 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7043 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7044 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7045 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7047 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7054 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7056 snprintf (out_buf
, len
-1, "%s", hashfile
);
7058 else if (hash_mode
== 6300)
7060 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7062 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7063 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7064 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7065 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7067 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7069 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7071 else if (hash_mode
== 6400)
7073 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7075 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7077 else if (hash_mode
== 6500)
7079 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7081 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7083 else if (hash_mode
== 6600)
7085 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7087 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7089 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7090 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7092 uint buf_len
= len
- 1;
7094 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7097 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7099 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7104 else if (hash_mode
== 6700)
7106 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7108 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7110 else if (hash_mode
== 6800)
7112 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7114 else if (hash_mode
== 7100)
7116 uint
*ptr
= digest_buf
;
7118 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7120 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7122 uint esalt
[8] = { 0 };
7124 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7125 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7126 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7127 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7128 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7129 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7130 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7131 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7133 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",
7134 SIGNATURE_SHA512OSX
,
7136 esalt
[ 0], esalt
[ 1],
7137 esalt
[ 2], esalt
[ 3],
7138 esalt
[ 4], esalt
[ 5],
7139 esalt
[ 6], esalt
[ 7],
7147 ptr
[15], ptr
[14]);
7149 else if (hash_mode
== 7200)
7151 uint
*ptr
= digest_buf
;
7153 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7155 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7159 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7161 len_used
= strlen (out_buf
);
7163 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7165 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7167 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7170 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",
7178 ptr
[15], ptr
[14]);
7180 else if (hash_mode
== 7300)
7182 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7184 rakp_t
*rakp
= &rakps
[salt_pos
];
7186 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7188 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7191 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7198 else if (hash_mode
== 7400)
7200 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7202 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7203 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7204 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7205 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7206 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7207 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7208 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7209 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7211 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7213 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7215 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7219 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7222 else if (hash_mode
== 7500)
7224 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7226 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7228 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7229 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7231 char data
[128] = { 0 };
7233 char *ptr_data
= data
;
7235 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7237 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7240 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7242 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7247 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7249 (char *) krb5pa
->user
,
7250 (char *) krb5pa
->realm
,
7251 (char *) krb5pa
->salt
,
7254 else if (hash_mode
== 7700)
7256 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7257 (char *) salt
.salt_buf
,
7261 else if (hash_mode
== 7800)
7263 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7264 (char *) salt
.salt_buf
,
7271 else if (hash_mode
== 7900)
7273 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7277 char *tmp
= (char *) salt
.salt_buf_pc
;
7279 ptr_plain
[42] = tmp
[0];
7285 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7287 else if (hash_mode
== 8000)
7289 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7290 (unsigned char *) salt
.salt_buf
,
7300 else if (hash_mode
== 8100)
7302 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7303 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7305 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7306 (unsigned char *) salt
.salt_buf
,
7313 else if (hash_mode
== 8200)
7315 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7317 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7319 char data_buf
[4096] = { 0 };
7321 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7323 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7326 data_buf
[cloudkey
->data_len
* 2] = 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]);
7333 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7334 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7335 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7337 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7338 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7339 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7340 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7342 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7358 else if (hash_mode
== 8300)
7360 char digest_buf_c
[34] = { 0 };
7362 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7363 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7364 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7365 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7366 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7368 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7370 digest_buf_c
[32] = 0;
7374 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7376 char domain_buf_c
[33] = { 0 };
7378 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7380 for (uint i
= 0; i
< salt_pc_len
; i
++)
7382 const char next
= domain_buf_c
[i
];
7384 domain_buf_c
[i
] = '.';
7389 domain_buf_c
[salt_pc_len
] = 0;
7393 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7395 else if (hash_mode
== 8500)
7397 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7399 else if (hash_mode
== 2612)
7401 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7403 (char *) salt
.salt_buf
,
7409 else if (hash_mode
== 3711)
7411 char *salt_ptr
= (char *) salt
.salt_buf
;
7413 salt_ptr
[salt
.salt_len
- 1] = 0;
7415 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7416 SIGNATURE_MEDIAWIKI_B
,
7423 else if (hash_mode
== 8800)
7425 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7427 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7429 char tmp
[3073] = { 0 };
7431 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7433 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7438 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7439 SIGNATURE_ANDROIDFDE
,
7440 byte_swap_32 (salt
.salt_buf
[0]),
7441 byte_swap_32 (salt
.salt_buf
[1]),
7442 byte_swap_32 (salt
.salt_buf
[2]),
7443 byte_swap_32 (salt
.salt_buf
[3]),
7444 byte_swap_32 (digest_buf
[0]),
7445 byte_swap_32 (digest_buf
[1]),
7446 byte_swap_32 (digest_buf
[2]),
7447 byte_swap_32 (digest_buf
[3]),
7450 else if (hash_mode
== 8900)
7452 uint N
= salt
.scrypt_N
;
7453 uint r
= salt
.scrypt_r
;
7454 uint p
= salt
.scrypt_p
;
7456 char base64_salt
[32] = { 0 };
7458 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7460 memset (tmp_buf
, 0, 46);
7462 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7463 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7464 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7465 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7466 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7467 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7468 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7469 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7470 digest_buf
[8] = 0; // needed for base64_encode ()
7472 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7474 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7482 else if (hash_mode
== 9000)
7484 snprintf (out_buf
, len
-1, "%s", hashfile
);
7486 else if (hash_mode
== 9200)
7490 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7492 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7494 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7498 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7499 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7500 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7501 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7502 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7503 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7504 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7505 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7506 digest_buf
[8] = 0; // needed for base64_encode ()
7508 char tmp_buf
[64] = { 0 };
7510 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7511 tmp_buf
[43] = 0; // cut it here
7515 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7517 else if (hash_mode
== 9300)
7519 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7520 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7521 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7522 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7523 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7524 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7525 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7526 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7527 digest_buf
[8] = 0; // needed for base64_encode ()
7529 char tmp_buf
[64] = { 0 };
7531 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7532 tmp_buf
[43] = 0; // cut it here
7534 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7536 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7538 else if (hash_mode
== 9400)
7540 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7542 office2007_t
*office2007
= &office2007s
[salt_pos
];
7544 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7545 SIGNATURE_OFFICE2007
,
7548 office2007
->keySize
,
7554 office2007
->encryptedVerifier
[0],
7555 office2007
->encryptedVerifier
[1],
7556 office2007
->encryptedVerifier
[2],
7557 office2007
->encryptedVerifier
[3],
7558 office2007
->encryptedVerifierHash
[0],
7559 office2007
->encryptedVerifierHash
[1],
7560 office2007
->encryptedVerifierHash
[2],
7561 office2007
->encryptedVerifierHash
[3],
7562 office2007
->encryptedVerifierHash
[4]);
7564 else if (hash_mode
== 9500)
7566 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7568 office2010_t
*office2010
= &office2010s
[salt_pos
];
7570 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,
7576 office2010
->encryptedVerifier
[0],
7577 office2010
->encryptedVerifier
[1],
7578 office2010
->encryptedVerifier
[2],
7579 office2010
->encryptedVerifier
[3],
7580 office2010
->encryptedVerifierHash
[0],
7581 office2010
->encryptedVerifierHash
[1],
7582 office2010
->encryptedVerifierHash
[2],
7583 office2010
->encryptedVerifierHash
[3],
7584 office2010
->encryptedVerifierHash
[4],
7585 office2010
->encryptedVerifierHash
[5],
7586 office2010
->encryptedVerifierHash
[6],
7587 office2010
->encryptedVerifierHash
[7]);
7589 else if (hash_mode
== 9600)
7591 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7593 office2013_t
*office2013
= &office2013s
[salt_pos
];
7595 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,
7601 office2013
->encryptedVerifier
[0],
7602 office2013
->encryptedVerifier
[1],
7603 office2013
->encryptedVerifier
[2],
7604 office2013
->encryptedVerifier
[3],
7605 office2013
->encryptedVerifierHash
[0],
7606 office2013
->encryptedVerifierHash
[1],
7607 office2013
->encryptedVerifierHash
[2],
7608 office2013
->encryptedVerifierHash
[3],
7609 office2013
->encryptedVerifierHash
[4],
7610 office2013
->encryptedVerifierHash
[5],
7611 office2013
->encryptedVerifierHash
[6],
7612 office2013
->encryptedVerifierHash
[7]);
7614 else if (hash_mode
== 9700)
7616 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7618 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7620 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7621 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7622 byte_swap_32 (salt
.salt_buf
[0]),
7623 byte_swap_32 (salt
.salt_buf
[1]),
7624 byte_swap_32 (salt
.salt_buf
[2]),
7625 byte_swap_32 (salt
.salt_buf
[3]),
7626 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7627 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7628 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7629 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7630 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7631 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7632 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7633 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7635 else if (hash_mode
== 9710)
7637 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7639 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7641 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7642 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7643 byte_swap_32 (salt
.salt_buf
[0]),
7644 byte_swap_32 (salt
.salt_buf
[1]),
7645 byte_swap_32 (salt
.salt_buf
[2]),
7646 byte_swap_32 (salt
.salt_buf
[3]),
7647 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7648 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7649 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7650 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7651 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7652 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7653 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7654 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7656 else if (hash_mode
== 9720)
7658 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7660 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7662 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7664 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7665 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7666 byte_swap_32 (salt
.salt_buf
[0]),
7667 byte_swap_32 (salt
.salt_buf
[1]),
7668 byte_swap_32 (salt
.salt_buf
[2]),
7669 byte_swap_32 (salt
.salt_buf
[3]),
7670 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7671 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7672 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7673 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7674 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7675 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7676 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7677 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7684 else if (hash_mode
== 9800)
7686 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7688 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7690 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7691 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7696 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7697 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7698 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7699 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7700 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7701 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7702 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7703 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7704 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7706 else if (hash_mode
== 9810)
7708 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7710 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7712 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7713 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7718 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7719 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7720 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7721 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7722 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7723 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7724 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7725 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7726 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7728 else if (hash_mode
== 9820)
7730 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7732 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7734 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7736 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7737 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7742 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7743 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7744 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7745 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7746 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7747 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7748 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7749 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7750 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7757 else if (hash_mode
== 10000)
7761 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7763 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7765 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7769 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7770 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7771 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7772 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7773 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7774 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7775 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7776 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7777 digest_buf
[8] = 0; // needed for base64_encode ()
7779 char tmp_buf
[64] = { 0 };
7781 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7785 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7787 else if (hash_mode
== 10100)
7789 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7794 byte_swap_32 (salt
.salt_buf
[0]),
7795 byte_swap_32 (salt
.salt_buf
[1]),
7796 byte_swap_32 (salt
.salt_buf
[2]),
7797 byte_swap_32 (salt
.salt_buf
[3]));
7799 else if (hash_mode
== 10200)
7801 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7803 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7807 char challenge
[100] = { 0 };
7809 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7813 char tmp_buf
[100] = { 0 };
7815 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7816 (char *) cram_md5
->user
,
7822 char response
[100] = { 0 };
7824 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7826 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7828 else if (hash_mode
== 10300)
7830 char tmp_buf
[100] = { 0 };
7832 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7833 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7835 uint tmp_len
= 20 + salt
.salt_len
;
7839 char base64_encoded
[100] = { 0 };
7841 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7843 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7845 else if (hash_mode
== 10400)
7847 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7849 pdf_t
*pdf
= &pdfs
[salt_pos
];
7851 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",
7859 byte_swap_32 (pdf
->id_buf
[0]),
7860 byte_swap_32 (pdf
->id_buf
[1]),
7861 byte_swap_32 (pdf
->id_buf
[2]),
7862 byte_swap_32 (pdf
->id_buf
[3]),
7864 byte_swap_32 (pdf
->u_buf
[0]),
7865 byte_swap_32 (pdf
->u_buf
[1]),
7866 byte_swap_32 (pdf
->u_buf
[2]),
7867 byte_swap_32 (pdf
->u_buf
[3]),
7868 byte_swap_32 (pdf
->u_buf
[4]),
7869 byte_swap_32 (pdf
->u_buf
[5]),
7870 byte_swap_32 (pdf
->u_buf
[6]),
7871 byte_swap_32 (pdf
->u_buf
[7]),
7873 byte_swap_32 (pdf
->o_buf
[0]),
7874 byte_swap_32 (pdf
->o_buf
[1]),
7875 byte_swap_32 (pdf
->o_buf
[2]),
7876 byte_swap_32 (pdf
->o_buf
[3]),
7877 byte_swap_32 (pdf
->o_buf
[4]),
7878 byte_swap_32 (pdf
->o_buf
[5]),
7879 byte_swap_32 (pdf
->o_buf
[6]),
7880 byte_swap_32 (pdf
->o_buf
[7])
7883 else if (hash_mode
== 10410)
7885 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7887 pdf_t
*pdf
= &pdfs
[salt_pos
];
7889 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",
7897 byte_swap_32 (pdf
->id_buf
[0]),
7898 byte_swap_32 (pdf
->id_buf
[1]),
7899 byte_swap_32 (pdf
->id_buf
[2]),
7900 byte_swap_32 (pdf
->id_buf
[3]),
7902 byte_swap_32 (pdf
->u_buf
[0]),
7903 byte_swap_32 (pdf
->u_buf
[1]),
7904 byte_swap_32 (pdf
->u_buf
[2]),
7905 byte_swap_32 (pdf
->u_buf
[3]),
7906 byte_swap_32 (pdf
->u_buf
[4]),
7907 byte_swap_32 (pdf
->u_buf
[5]),
7908 byte_swap_32 (pdf
->u_buf
[6]),
7909 byte_swap_32 (pdf
->u_buf
[7]),
7911 byte_swap_32 (pdf
->o_buf
[0]),
7912 byte_swap_32 (pdf
->o_buf
[1]),
7913 byte_swap_32 (pdf
->o_buf
[2]),
7914 byte_swap_32 (pdf
->o_buf
[3]),
7915 byte_swap_32 (pdf
->o_buf
[4]),
7916 byte_swap_32 (pdf
->o_buf
[5]),
7917 byte_swap_32 (pdf
->o_buf
[6]),
7918 byte_swap_32 (pdf
->o_buf
[7])
7921 else if (hash_mode
== 10420)
7923 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7925 pdf_t
*pdf
= &pdfs
[salt_pos
];
7927 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7929 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",
7937 byte_swap_32 (pdf
->id_buf
[0]),
7938 byte_swap_32 (pdf
->id_buf
[1]),
7939 byte_swap_32 (pdf
->id_buf
[2]),
7940 byte_swap_32 (pdf
->id_buf
[3]),
7942 byte_swap_32 (pdf
->u_buf
[0]),
7943 byte_swap_32 (pdf
->u_buf
[1]),
7944 byte_swap_32 (pdf
->u_buf
[2]),
7945 byte_swap_32 (pdf
->u_buf
[3]),
7946 byte_swap_32 (pdf
->u_buf
[4]),
7947 byte_swap_32 (pdf
->u_buf
[5]),
7948 byte_swap_32 (pdf
->u_buf
[6]),
7949 byte_swap_32 (pdf
->u_buf
[7]),
7951 byte_swap_32 (pdf
->o_buf
[0]),
7952 byte_swap_32 (pdf
->o_buf
[1]),
7953 byte_swap_32 (pdf
->o_buf
[2]),
7954 byte_swap_32 (pdf
->o_buf
[3]),
7955 byte_swap_32 (pdf
->o_buf
[4]),
7956 byte_swap_32 (pdf
->o_buf
[5]),
7957 byte_swap_32 (pdf
->o_buf
[6]),
7958 byte_swap_32 (pdf
->o_buf
[7]),
7966 else if (hash_mode
== 10500)
7968 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7970 pdf_t
*pdf
= &pdfs
[salt_pos
];
7972 if (pdf
->id_len
== 32)
7974 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",
7982 byte_swap_32 (pdf
->id_buf
[0]),
7983 byte_swap_32 (pdf
->id_buf
[1]),
7984 byte_swap_32 (pdf
->id_buf
[2]),
7985 byte_swap_32 (pdf
->id_buf
[3]),
7986 byte_swap_32 (pdf
->id_buf
[4]),
7987 byte_swap_32 (pdf
->id_buf
[5]),
7988 byte_swap_32 (pdf
->id_buf
[6]),
7989 byte_swap_32 (pdf
->id_buf
[7]),
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])
8012 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",
8020 byte_swap_32 (pdf
->id_buf
[0]),
8021 byte_swap_32 (pdf
->id_buf
[1]),
8022 byte_swap_32 (pdf
->id_buf
[2]),
8023 byte_swap_32 (pdf
->id_buf
[3]),
8025 byte_swap_32 (pdf
->u_buf
[0]),
8026 byte_swap_32 (pdf
->u_buf
[1]),
8027 byte_swap_32 (pdf
->u_buf
[2]),
8028 byte_swap_32 (pdf
->u_buf
[3]),
8029 byte_swap_32 (pdf
->u_buf
[4]),
8030 byte_swap_32 (pdf
->u_buf
[5]),
8031 byte_swap_32 (pdf
->u_buf
[6]),
8032 byte_swap_32 (pdf
->u_buf
[7]),
8034 byte_swap_32 (pdf
->o_buf
[0]),
8035 byte_swap_32 (pdf
->o_buf
[1]),
8036 byte_swap_32 (pdf
->o_buf
[2]),
8037 byte_swap_32 (pdf
->o_buf
[3]),
8038 byte_swap_32 (pdf
->o_buf
[4]),
8039 byte_swap_32 (pdf
->o_buf
[5]),
8040 byte_swap_32 (pdf
->o_buf
[6]),
8041 byte_swap_32 (pdf
->o_buf
[7])
8045 else if (hash_mode
== 10600)
8047 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8049 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8050 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8052 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8054 else if (hash_mode
== 10700)
8056 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8058 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8059 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8061 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8063 else if (hash_mode
== 10900)
8065 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8067 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8068 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8070 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8072 else if (hash_mode
== 11100)
8074 u32 salt_challenge
= salt
.salt_buf
[0];
8076 salt_challenge
= byte_swap_32 (salt_challenge
);
8078 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8080 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8081 SIGNATURE_POSTGRESQL_AUTH
,
8089 else if (hash_mode
== 11200)
8091 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8092 SIGNATURE_MYSQL_AUTH
,
8093 (unsigned char *) salt
.salt_buf
,
8100 else if (hash_mode
== 11300)
8102 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8104 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8106 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8107 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8108 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8110 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8111 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8112 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8114 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8116 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8118 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8121 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8123 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8125 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8128 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8130 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8132 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8135 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8136 SIGNATURE_BITCOIN_WALLET
,
8140 (unsigned char *) salt
.salt_buf
,
8148 free (cry_master_buf
);
8150 free (public_key_buf
);
8152 else if (hash_mode
== 11400)
8154 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8156 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8157 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8159 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8161 else if (hash_mode
== 11600)
8163 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8165 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8167 const uint data_len
= seven_zip
->data_len
;
8169 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8171 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8173 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8175 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8178 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8179 SIGNATURE_SEVEN_ZIP
,
8183 (char *) seven_zip
->salt_buf
,
8185 seven_zip
->iv_buf
[0],
8186 seven_zip
->iv_buf
[1],
8187 seven_zip
->iv_buf
[2],
8188 seven_zip
->iv_buf
[3],
8190 seven_zip
->data_len
,
8191 seven_zip
->unpack_size
,
8196 else if (hash_mode
== 11700)
8198 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8208 else if (hash_mode
== 11800)
8210 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8228 else if (hash_mode
== 11900)
8230 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8232 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8233 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8235 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8237 else if (hash_mode
== 12000)
8239 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8241 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8242 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8244 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8246 else if (hash_mode
== 12100)
8248 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8250 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8251 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8253 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8255 else if (hash_mode
== 12200)
8257 uint
*ptr_digest
= digest_buf
;
8258 uint
*ptr_salt
= salt
.salt_buf
;
8260 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8267 else if (hash_mode
== 12300)
8269 uint
*ptr_digest
= digest_buf
;
8270 uint
*ptr_salt
= salt
.salt_buf
;
8272 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",
8273 ptr_digest
[ 0], ptr_digest
[ 1],
8274 ptr_digest
[ 2], ptr_digest
[ 3],
8275 ptr_digest
[ 4], ptr_digest
[ 5],
8276 ptr_digest
[ 6], ptr_digest
[ 7],
8277 ptr_digest
[ 8], ptr_digest
[ 9],
8278 ptr_digest
[10], ptr_digest
[11],
8279 ptr_digest
[12], ptr_digest
[13],
8280 ptr_digest
[14], ptr_digest
[15],
8286 else if (hash_mode
== 12400)
8288 // encode iteration count
8290 char salt_iter
[5] = { 0 };
8292 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8293 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8294 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8295 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8300 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8301 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8302 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8303 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8308 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8310 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8311 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8313 memcpy (tmp_buf
, digest_buf
, 8);
8315 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8319 // fill the resulting buffer
8321 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8323 else if (hash_mode
== 12500)
8325 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8327 byte_swap_32 (salt
.salt_buf
[0]),
8328 byte_swap_32 (salt
.salt_buf
[1]),
8334 else if (hash_mode
== 12600)
8336 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8337 digest_buf
[0] + salt
.salt_buf_pc
[0],
8338 digest_buf
[1] + salt
.salt_buf_pc
[1],
8339 digest_buf
[2] + salt
.salt_buf_pc
[2],
8340 digest_buf
[3] + salt
.salt_buf_pc
[3],
8341 digest_buf
[4] + salt
.salt_buf_pc
[4],
8342 digest_buf
[5] + salt
.salt_buf_pc
[5],
8343 digest_buf
[6] + salt
.salt_buf_pc
[6],
8344 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8346 else if (hash_mode
== 12700)
8348 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8350 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8351 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8353 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8355 else if (hash_mode
== 12800)
8357 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8359 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",
8372 byte_swap_32 (digest_buf
[0]),
8373 byte_swap_32 (digest_buf
[1]),
8374 byte_swap_32 (digest_buf
[2]),
8375 byte_swap_32 (digest_buf
[3]),
8376 byte_swap_32 (digest_buf
[4]),
8377 byte_swap_32 (digest_buf
[5]),
8378 byte_swap_32 (digest_buf
[6]),
8379 byte_swap_32 (digest_buf
[7])
8382 else if (hash_mode
== 12900)
8384 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",
8393 byte_swap_32 (digest_buf
[0]),
8394 byte_swap_32 (digest_buf
[1]),
8395 byte_swap_32 (digest_buf
[2]),
8396 byte_swap_32 (digest_buf
[3]),
8397 byte_swap_32 (digest_buf
[4]),
8398 byte_swap_32 (digest_buf
[5]),
8399 byte_swap_32 (digest_buf
[6]),
8400 byte_swap_32 (digest_buf
[7]),
8407 else if (hash_mode
== 13000)
8409 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8411 rar5_t
*rar5
= &rar5s
[salt_pos
];
8413 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8423 byte_swap_32 (digest_buf
[0]),
8424 byte_swap_32 (digest_buf
[1])
8427 else if (hash_mode
== 13100)
8429 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8431 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8433 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8434 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8436 char data
[2560 * 4 * 2] = { 0 };
8438 char *ptr_data
= data
;
8440 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8441 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8446 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8447 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8449 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8451 (char *) krb5tgs
->account_info
,
8455 else if (hash_mode
== 13200)
8457 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8471 else if (hash_mode
== 13300)
8473 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8474 SIGNATURE_AXCRYPT_SHA1
,
8480 else if (hash_mode
== 13400)
8482 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8484 keepass_t
*keepass
= &keepasss
[salt_pos
];
8486 u32 version
= (u32
) keepass
->version
;
8487 u32 rounds
= salt
.salt_iter
;
8488 u32 algorithm
= (u32
) keepass
->algorithm
;
8489 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8491 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8492 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8493 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8494 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8495 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8497 /* specific to version 1 */
8501 /* specific to version 2 */
8502 u32 expected_bytes_len
;
8503 u32
*ptr_expected_bytes
;
8505 u32 final_random_seed_len
;
8506 u32 transf_random_seed_len
;
8508 u32 contents_hash_len
;
8510 transf_random_seed_len
= 8;
8512 contents_hash_len
= 8;
8513 final_random_seed_len
= 8;
8516 final_random_seed_len
= 4;
8518 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8524 char *ptr_data
= out_buf
;
8526 ptr_data
+= strlen(out_buf
);
8531 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8532 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8537 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8538 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8543 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8544 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8551 contents_len
= (u32
) keepass
->contents_len
;
8552 ptr_contents
= (u32
*) keepass
->contents
;
8554 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8555 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8567 char ptr_contents_len
[10] = { 0 };
8569 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8571 sprintf (ptr_data
, "%d", contents_len
);
8573 ptr_data
+= strlen(ptr_contents_len
);
8578 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8579 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8581 else if (version
== 2)
8583 expected_bytes_len
= 8;
8584 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8586 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8587 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8592 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8593 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8607 sprintf (ptr_data
, "%d", keyfile_len
);
8614 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8615 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8618 else if (hash_mode
== 13500)
8620 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8622 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8624 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8626 char pstoken_tmp
[1024 + 1] = { 0 };
8628 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8630 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8632 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8635 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8643 else if (hash_mode
== 13600)
8645 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8647 zip2_t
*zip2
= &zip2s
[salt_pos
];
8649 const u32 salt_len
= zip2
->salt_len
;
8651 char salt_tmp
[32 + 1] = { 0 };
8653 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8655 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8657 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8660 const u32 data_len
= zip2
->data_len
;
8662 char data_tmp
[8192 + 1] = { 0 };
8664 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8666 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8668 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8671 const u32 auth_len
= zip2
->auth_len
;
8673 char auth_tmp
[20 + 1] = { 0 };
8675 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8677 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8679 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8682 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8683 SIGNATURE_ZIP2_START
,
8689 zip2
->compress_length
,
8692 SIGNATURE_ZIP2_STOP
);
8694 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8696 snprintf (out_buf
, len
-1, "%s", hashfile
);
8700 if (hash_type
== HASH_TYPE_MD4
)
8702 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8708 else if (hash_type
== HASH_TYPE_MD5
)
8710 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8716 else if (hash_type
== HASH_TYPE_SHA1
)
8718 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8725 else if (hash_type
== HASH_TYPE_SHA256
)
8727 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8737 else if (hash_type
== HASH_TYPE_SHA384
)
8739 uint
*ptr
= digest_buf
;
8741 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8749 else if (hash_type
== HASH_TYPE_SHA512
)
8751 uint
*ptr
= digest_buf
;
8753 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8763 else if (hash_type
== HASH_TYPE_LM
)
8765 snprintf (out_buf
, len
-1, "%08x%08x",
8769 else if (hash_type
== HASH_TYPE_ORACLEH
)
8771 snprintf (out_buf
, len
-1, "%08X%08X",
8775 else if (hash_type
== HASH_TYPE_BCRYPT
)
8777 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8778 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8780 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8782 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8784 else if (hash_type
== HASH_TYPE_KECCAK
)
8786 uint
*ptr
= digest_buf
;
8788 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",
8816 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8818 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8820 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8827 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8829 digest_buf
[ 0] = digest_buf
[ 0];
8830 digest_buf
[ 1] = digest_buf
[ 1];
8831 digest_buf
[ 2] = digest_buf
[ 2];
8832 digest_buf
[ 3] = digest_buf
[ 3];
8833 digest_buf
[ 4] = digest_buf
[ 4];
8834 digest_buf
[ 5] = digest_buf
[ 5];
8835 digest_buf
[ 6] = digest_buf
[ 6];
8836 digest_buf
[ 7] = digest_buf
[ 7];
8837 digest_buf
[ 8] = digest_buf
[ 8];
8838 digest_buf
[ 9] = digest_buf
[ 9];
8839 digest_buf
[10] = digest_buf
[10];
8840 digest_buf
[11] = digest_buf
[11];
8841 digest_buf
[12] = digest_buf
[12];
8842 digest_buf
[13] = digest_buf
[13];
8843 digest_buf
[14] = digest_buf
[14];
8844 digest_buf
[15] = digest_buf
[15];
8846 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8864 else if (hash_type
== HASH_TYPE_GOST
)
8866 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8876 else if (hash_type
== HASH_TYPE_MYSQL
)
8878 snprintf (out_buf
, len
-1, "%08x%08x",
8882 else if (hash_type
== HASH_TYPE_LOTUS5
)
8884 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8890 else if (hash_type
== HASH_TYPE_LOTUS6
)
8892 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8893 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8894 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8895 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8897 char buf
[16] = { 0 };
8899 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8900 memcpy (buf
+ 5, digest_buf
, 9);
8904 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8906 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8909 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8911 else if (hash_type
== HASH_TYPE_LOTUS8
)
8913 char buf
[52] = { 0 };
8917 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8923 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8927 buf
[26] = salt
.salt_buf_pc
[0];
8928 buf
[27] = salt
.salt_buf_pc
[1];
8932 memcpy (buf
+ 28, digest_buf
, 8);
8934 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8938 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8940 else if (hash_type
== HASH_TYPE_CRC32
)
8942 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8946 if (salt_type
== SALT_TYPE_INTERN
)
8948 size_t pos
= strlen (out_buf
);
8950 out_buf
[pos
] = data
.separator
;
8952 char *ptr
= (char *) salt
.salt_buf
;
8954 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8956 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8960 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8962 memset (hccap
, 0, sizeof (hccap_t
));
8964 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8966 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8968 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8969 wpa_t
*wpa
= &wpas
[salt_pos
];
8971 hccap
->keyver
= wpa
->keyver
;
8973 hccap
->eapol_size
= wpa
->eapol_size
;
8975 if (wpa
->keyver
!= 1)
8977 uint eapol_tmp
[64] = { 0 };
8979 for (uint i
= 0; i
< 64; i
++)
8981 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8984 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8988 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8991 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
8992 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
8993 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
8994 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
8996 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8998 uint dgst_size
= data
.dgst_size
;
9000 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9002 if (wpa
->keyver
!= 1)
9004 uint digest_tmp
[4] = { 0 };
9006 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9007 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9008 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9009 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9011 memcpy (hccap
->keymic
, digest_tmp
, 16);
9015 memcpy (hccap
->keymic
, digest_ptr
, 16);
9019 void SuspendThreads ()
9021 if (data
.devices_status
== STATUS_RUNNING
)
9023 hc_timer_set (&data
.timer_paused
);
9025 data
.devices_status
= STATUS_PAUSED
;
9027 log_info ("Paused");
9031 void ResumeThreads ()
9033 if (data
.devices_status
== STATUS_PAUSED
)
9037 hc_timer_get (data
.timer_paused
, ms_paused
);
9039 data
.ms_paused
+= ms_paused
;
9041 data
.devices_status
= STATUS_RUNNING
;
9043 log_info ("Resumed");
9049 if (data
.devices_status
!= STATUS_RUNNING
) return;
9051 data
.devices_status
= STATUS_BYPASS
;
9053 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9056 void stop_at_checkpoint ()
9058 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9060 if (data
.devices_status
!= STATUS_RUNNING
) return;
9063 // this feature only makes sense if --restore-disable was not specified
9065 if (data
.restore_disable
== 1)
9067 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
9072 // check if monitoring of Restore Point updates should be enabled or disabled
9074 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9076 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9078 // save the current restore point value
9080 data
.checkpoint_cur_words
= get_lowest_words_done ();
9082 log_info ("Checkpoint enabled: will quit at next Restore Point update");
9086 data
.devices_status
= STATUS_RUNNING
;
9088 // reset the global value for checkpoint checks
9090 data
.checkpoint_cur_words
= 0;
9092 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9098 if (data
.devices_status
== STATUS_INIT
) return;
9099 if (data
.devices_status
== STATUS_STARTING
) return;
9101 data
.devices_status
= STATUS_ABORTED
;
9106 if (data
.devices_status
== STATUS_INIT
) return;
9107 if (data
.devices_status
== STATUS_STARTING
) return;
9109 data
.devices_status
= STATUS_QUIT
;
9112 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9114 FILE *fp
= fopen (kernel_file
, "rb");
9120 memset (&st
, 0, sizeof (st
));
9122 stat (kernel_file
, &st
);
9124 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9126 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9128 if (num_read
!= (size_t) st
.st_size
)
9130 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9137 buf
[st
.st_size
] = 0;
9139 for (int i
= 0; i
< num_devices
; i
++)
9141 kernel_lengths
[i
] = (size_t) st
.st_size
;
9143 kernel_sources
[i
] = buf
;
9148 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9156 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9158 if (binary_size
> 0)
9160 FILE *fp
= fopen (dst
, "wb");
9163 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9174 restore_data_t
*init_restore (int argc
, char **argv
)
9176 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9178 if (data
.restore_disable
== 0)
9180 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9184 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9188 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9197 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9199 int pidbin_len
= -1;
9202 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9204 FILE *fd
= fopen (pidbin
, "rb");
9208 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9210 pidbin
[pidbin_len
] = 0;
9214 char *argv0_r
= strrchr (argv
[0], '/');
9216 char *pidbin_r
= strrchr (pidbin
, '/');
9218 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9220 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9222 if (strcmp (argv0_r
, pidbin_r
) == 0)
9224 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9231 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9233 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9235 int pidbin2_len
= -1;
9237 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9238 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9240 pidbin
[pidbin_len
] = 0;
9241 pidbin2
[pidbin2_len
] = 0;
9245 if (strcmp (pidbin
, pidbin2
) == 0)
9247 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9260 if (rd
->version_bin
< RESTORE_MIN
)
9262 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9269 memset (rd
, 0, sizeof (restore_data_t
));
9271 rd
->version_bin
= VERSION_BIN
;
9274 rd
->pid
= getpid ();
9276 rd
->pid
= GetCurrentProcessId ();
9279 if (getcwd (rd
->cwd
, 255) == NULL
)
9292 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9294 FILE *fp
= fopen (eff_restore_file
, "rb");
9298 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9303 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9305 log_error ("ERROR: cannot read %s", eff_restore_file
);
9310 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9312 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9314 for (uint i
= 0; i
< rd
->argc
; i
++)
9316 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9318 log_error ("ERROR: cannot read %s", eff_restore_file
);
9323 size_t len
= strlen (buf
);
9325 if (len
) buf
[len
- 1] = 0;
9327 rd
->argv
[i
] = mystrdup (buf
);
9334 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9336 if (chdir (rd
->cwd
))
9338 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9339 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9340 " https://github.com/philsmd/analyze_hc_restore\n"
9341 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9347 u64
get_lowest_words_done ()
9351 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9353 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9355 if (device_param
->skipped
) continue;
9357 const u64 words_done
= device_param
->words_done
;
9359 if (words_done
< words_cur
) words_cur
= words_done
;
9362 // It's possible that a device's workload isn't finished right after a restore-case.
9363 // In that case, this function would return 0 and overwrite the real restore point
9364 // There's also data.words_cur which is set to rd->words_cur but it changes while
9365 // the attack is running therefore we should stick to rd->words_cur.
9366 // Note that -s influences rd->words_cur we should keep a close look on that.
9368 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9373 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9375 u64 words_cur
= get_lowest_words_done ();
9377 rd
->words_cur
= words_cur
;
9379 FILE *fp
= fopen (new_restore_file
, "wb");
9383 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9388 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9390 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9395 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9397 for (uint i
= 0; i
< rd
->argc
; i
++)
9399 fprintf (fp
, "%s", rd
->argv
[i
]);
9405 fsync (fileno (fp
));
9410 void cycle_restore ()
9412 const char *eff_restore_file
= data
.eff_restore_file
;
9413 const char *new_restore_file
= data
.new_restore_file
;
9415 restore_data_t
*rd
= data
.rd
;
9417 write_restore (new_restore_file
, rd
);
9421 memset (&st
, 0, sizeof(st
));
9423 if (stat (eff_restore_file
, &st
) == 0)
9425 if (unlink (eff_restore_file
))
9427 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9431 if (rename (new_restore_file
, eff_restore_file
))
9433 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9437 void check_checkpoint ()
9439 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9441 u64 words_cur
= get_lowest_words_done ();
9443 if (words_cur
!= data
.checkpoint_cur_words
)
9453 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9457 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9459 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9461 myfree (alias
->device_name
);
9462 myfree (alias
->alias_name
);
9465 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9467 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9469 myfree (entry
->device_name
);
9472 myfree (tuning_db
->alias_buf
);
9473 myfree (tuning_db
->entry_buf
);
9478 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9480 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9482 int num_lines
= count_lines (fp
);
9484 // a bit over-allocated
9486 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9487 tuning_db
->alias_cnt
= 0;
9489 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9490 tuning_db
->entry_cnt
= 0;
9495 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9497 FILE *fp
= fopen (tuning_db_file
, "rb");
9501 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9506 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9512 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9516 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9518 if (line_buf
== NULL
) break;
9522 const int line_len
= in_superchop (line_buf
);
9524 if (line_len
== 0) continue;
9526 if (line_buf
[0] == '#') continue;
9530 char *token_ptr
[7] = { NULL
};
9534 char *next
= strtok (line_buf
, "\t ");
9536 token_ptr
[token_cnt
] = next
;
9540 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9542 token_ptr
[token_cnt
] = next
;
9549 char *device_name
= token_ptr
[0];
9550 char *alias_name
= token_ptr
[1];
9552 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9554 alias
->device_name
= mystrdup (device_name
);
9555 alias
->alias_name
= mystrdup (alias_name
);
9557 tuning_db
->alias_cnt
++;
9559 else if (token_cnt
== 6)
9561 if ((token_ptr
[1][0] != '0') &&
9562 (token_ptr
[1][0] != '1') &&
9563 (token_ptr
[1][0] != '3') &&
9564 (token_ptr
[1][0] != '*'))
9566 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9571 if ((token_ptr
[3][0] != '1') &&
9572 (token_ptr
[3][0] != '2') &&
9573 (token_ptr
[3][0] != '4') &&
9574 (token_ptr
[3][0] != '8') &&
9575 (token_ptr
[3][0] != 'N'))
9577 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9582 char *device_name
= token_ptr
[0];
9584 int attack_mode
= -1;
9586 int vector_width
= -1;
9587 int kernel_accel
= -1;
9588 int kernel_loops
= -1;
9590 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9591 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9592 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9594 if (token_ptr
[4][0] != 'A')
9596 kernel_accel
= atoi (token_ptr
[4]);
9598 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9600 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9610 if (token_ptr
[5][0] != 'A')
9612 kernel_loops
= atoi (token_ptr
[5]);
9614 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9616 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9626 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9628 entry
->device_name
= mystrdup (device_name
);
9629 entry
->attack_mode
= attack_mode
;
9630 entry
->hash_type
= hash_type
;
9631 entry
->vector_width
= vector_width
;
9632 entry
->kernel_accel
= kernel_accel
;
9633 entry
->kernel_loops
= kernel_loops
;
9635 tuning_db
->entry_cnt
++;
9639 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9649 // todo: print loaded 'cnt' message
9651 // sort the database
9653 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9654 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9659 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9661 static tuning_db_entry_t s
;
9663 // first we need to convert all spaces in the device_name to underscore
9665 char *device_name_nospace
= strdup (device_param
->device_name
);
9667 int device_name_length
= strlen (device_name_nospace
);
9671 for (i
= 0; i
< device_name_length
; i
++)
9673 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9676 // find out if there's an alias configured
9678 tuning_db_alias_t a
;
9680 a
.device_name
= device_name_nospace
;
9682 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
);
9684 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9686 // attack-mode 6 and 7 are attack-mode 1 basically
9688 if (attack_mode
== 6) attack_mode
= 1;
9689 if (attack_mode
== 7) attack_mode
= 1;
9691 // bsearch is not ideal but fast enough
9693 s
.device_name
= device_name_nospace
;
9694 s
.attack_mode
= attack_mode
;
9695 s
.hash_type
= hash_type
;
9697 tuning_db_entry_t
*entry
= NULL
;
9699 // this will produce all 2^3 combinations required
9701 for (i
= 0; i
< 8; i
++)
9703 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9704 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9705 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
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;
9711 // in non-wildcard mode do some additional checks:
9715 // in case we have an alias-name
9717 if (alias_name
!= NULL
)
9719 s
.device_name
= alias_name
;
9721 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9723 if (entry
!= NULL
) break;
9726 // or by device type
9728 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9730 s
.device_name
= "DEVICE_TYPE_CPU";
9732 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9734 s
.device_name
= "DEVICE_TYPE_GPU";
9736 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9738 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9741 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9743 if (entry
!= NULL
) break;
9747 // free converted device_name
9749 myfree (device_name_nospace
);
9758 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9760 u8 tmp
[256] = { 0 };
9762 if (salt_len
> sizeof (tmp
))
9767 memcpy (tmp
, in
, salt_len
);
9769 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9771 if ((salt_len
% 2) == 0)
9773 u32 new_salt_len
= salt_len
/ 2;
9775 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9780 tmp
[i
] = hex_convert (p1
) << 0;
9781 tmp
[i
] |= hex_convert (p0
) << 4;
9784 salt_len
= new_salt_len
;
9791 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9793 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9796 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9798 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9802 u32
*tmp_uint
= (u32
*) tmp
;
9804 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9805 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9806 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9807 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9808 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9809 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9810 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9811 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9812 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9813 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9815 salt_len
= salt_len
* 2;
9823 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9825 lowercase (tmp
, salt_len
);
9828 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9830 uppercase (tmp
, salt_len
);
9835 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9840 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9845 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9847 u32
*tmp_uint
= (uint
*) tmp
;
9853 for (u32 i
= 0; i
< max
; i
++)
9855 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9858 // Important: we may need to increase the length of memcpy since
9859 // we don't want to "loose" some swapped bytes (could happen if
9860 // they do not perfectly fit in the 4-byte blocks)
9861 // Memcpy does always copy the bytes in the BE order, but since
9862 // we swapped them, some important bytes could be in positions
9863 // we normally skip with the original len
9865 if (len
% 4) len
+= 4 - (len
% 4);
9868 memcpy (out
, tmp
, len
);
9873 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9875 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9877 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9879 u32
*digest
= (u32
*) hash_buf
->digest
;
9881 salt_t
*salt
= hash_buf
->salt
;
9883 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9885 char *iter_pos
= input_buf
+ 4;
9887 salt
->salt_iter
= 1 << atoi (iter_pos
);
9889 char *salt_pos
= strchr (iter_pos
, '$');
9891 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9897 salt
->salt_len
= salt_len
;
9899 u8 tmp_buf
[100] = { 0 };
9901 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9903 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9905 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9907 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9908 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9909 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9910 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9912 char *hash_pos
= salt_pos
+ 22;
9914 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9916 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9918 memcpy (digest
, tmp_buf
, 24);
9920 digest
[0] = byte_swap_32 (digest
[0]);
9921 digest
[1] = byte_swap_32 (digest
[1]);
9922 digest
[2] = byte_swap_32 (digest
[2]);
9923 digest
[3] = byte_swap_32 (digest
[3]);
9924 digest
[4] = byte_swap_32 (digest
[4]);
9925 digest
[5] = byte_swap_32 (digest
[5]);
9927 digest
[5] &= ~0xff; // its just 23 not 24 !
9932 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9934 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9936 u32
*digest
= (u32
*) hash_buf
->digest
;
9938 u8 tmp_buf
[100] = { 0 };
9940 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9942 memcpy (digest
, tmp_buf
, 32);
9944 digest
[0] = byte_swap_32 (digest
[0]);
9945 digest
[1] = byte_swap_32 (digest
[1]);
9946 digest
[2] = byte_swap_32 (digest
[2]);
9947 digest
[3] = byte_swap_32 (digest
[3]);
9948 digest
[4] = byte_swap_32 (digest
[4]);
9949 digest
[5] = byte_swap_32 (digest
[5]);
9950 digest
[6] = byte_swap_32 (digest
[6]);
9951 digest
[7] = byte_swap_32 (digest
[7]);
9953 digest
[0] -= SHA256M_A
;
9954 digest
[1] -= SHA256M_B
;
9955 digest
[2] -= SHA256M_C
;
9956 digest
[3] -= SHA256M_D
;
9957 digest
[4] -= SHA256M_E
;
9958 digest
[5] -= SHA256M_F
;
9959 digest
[6] -= SHA256M_G
;
9960 digest
[7] -= SHA256M_H
;
9965 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9967 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9969 u32
*digest
= (u32
*) hash_buf
->digest
;
9971 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9972 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9974 digest
[0] = byte_swap_32 (digest
[0]);
9975 digest
[1] = byte_swap_32 (digest
[1]);
9979 IP (digest
[0], digest
[1], tt
);
9981 digest
[0] = digest
[0];
9982 digest
[1] = digest
[1];
9989 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9991 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
9993 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
9995 u32
*digest
= (u32
*) hash_buf
->digest
;
9997 salt_t
*salt
= hash_buf
->salt
;
9999 char *hash_pos
= input_buf
+ 10;
10001 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10002 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10003 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10004 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10005 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10007 digest
[0] -= SHA1M_A
;
10008 digest
[1] -= SHA1M_B
;
10009 digest
[2] -= SHA1M_C
;
10010 digest
[3] -= SHA1M_D
;
10011 digest
[4] -= SHA1M_E
;
10013 uint salt_len
= 10;
10015 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10017 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10019 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10021 salt
->salt_len
= salt_len
;
10023 return (PARSER_OK
);
10026 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10028 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10030 u32
*digest
= (u32
*) hash_buf
->digest
;
10032 salt_t
*salt
= hash_buf
->salt
;
10034 char *hash_pos
= input_buf
+ 8;
10036 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10037 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10038 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10039 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10040 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10042 digest
[0] -= SHA1M_A
;
10043 digest
[1] -= SHA1M_B
;
10044 digest
[2] -= SHA1M_C
;
10045 digest
[3] -= SHA1M_D
;
10046 digest
[4] -= SHA1M_E
;
10050 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10052 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10054 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10056 salt
->salt_len
= salt_len
;
10058 return (PARSER_OK
);
10061 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10063 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10065 u64
*digest
= (u64
*) hash_buf
->digest
;
10067 salt_t
*salt
= hash_buf
->salt
;
10069 char *hash_pos
= input_buf
+ 8;
10071 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10072 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10073 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10074 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10075 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10076 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10077 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10078 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10080 digest
[0] -= SHA512M_A
;
10081 digest
[1] -= SHA512M_B
;
10082 digest
[2] -= SHA512M_C
;
10083 digest
[3] -= SHA512M_D
;
10084 digest
[4] -= SHA512M_E
;
10085 digest
[5] -= SHA512M_F
;
10086 digest
[6] -= SHA512M_G
;
10087 digest
[7] -= SHA512M_H
;
10091 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10093 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10095 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10097 salt
->salt_len
= salt_len
;
10099 return (PARSER_OK
);
10102 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10104 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10106 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10110 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10113 u32
*digest
= (u32
*) hash_buf
->digest
;
10115 salt_t
*salt
= hash_buf
->salt
;
10117 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10118 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10119 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10120 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10122 digest
[0] = byte_swap_32 (digest
[0]);
10123 digest
[1] = byte_swap_32 (digest
[1]);
10124 digest
[2] = byte_swap_32 (digest
[2]);
10125 digest
[3] = byte_swap_32 (digest
[3]);
10127 digest
[0] -= MD5M_A
;
10128 digest
[1] -= MD5M_B
;
10129 digest
[2] -= MD5M_C
;
10130 digest
[3] -= MD5M_D
;
10132 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10134 uint salt_len
= input_len
- 32 - 1;
10136 char *salt_buf
= input_buf
+ 32 + 1;
10138 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10140 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10142 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10144 salt
->salt_len
= salt_len
;
10146 return (PARSER_OK
);
10149 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10151 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10153 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10157 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10162 char clean_input_buf
[32] = { 0 };
10164 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10165 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10167 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10171 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10177 clean_input_buf
[k
] = input_buf
[i
];
10185 u32
*digest
= (u32
*) hash_buf
->digest
;
10187 salt_t
*salt
= hash_buf
->salt
;
10189 u32 a
, b
, c
, d
, e
, f
;
10191 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10192 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10193 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10194 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10195 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10196 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10198 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10199 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10201 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10202 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10203 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10204 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10205 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10206 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10208 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10209 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10211 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10212 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10213 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10214 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10215 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10216 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10218 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10219 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10221 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10222 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10223 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10224 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10225 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10226 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10228 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10229 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10231 digest
[0] = byte_swap_32 (digest
[0]);
10232 digest
[1] = byte_swap_32 (digest
[1]);
10233 digest
[2] = byte_swap_32 (digest
[2]);
10234 digest
[3] = byte_swap_32 (digest
[3]);
10236 digest
[0] -= MD5M_A
;
10237 digest
[1] -= MD5M_B
;
10238 digest
[2] -= MD5M_C
;
10239 digest
[3] -= MD5M_D
;
10241 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10243 uint salt_len
= input_len
- 30 - 1;
10245 char *salt_buf
= input_buf
+ 30 + 1;
10247 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10249 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10251 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10252 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10254 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10256 salt
->salt_len
= salt_len
;
10258 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10260 salt
->salt_len
+= 22;
10262 return (PARSER_OK
);
10265 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10267 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10269 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10273 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10276 u32
*digest
= (u32
*) hash_buf
->digest
;
10278 salt_t
*salt
= hash_buf
->salt
;
10280 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10281 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10282 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10283 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10284 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10286 digest
[0] -= SHA1M_A
;
10287 digest
[1] -= SHA1M_B
;
10288 digest
[2] -= SHA1M_C
;
10289 digest
[3] -= SHA1M_D
;
10290 digest
[4] -= SHA1M_E
;
10292 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10294 uint salt_len
= input_len
- 40 - 1;
10296 char *salt_buf
= input_buf
+ 40 + 1;
10298 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10300 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10302 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10304 salt
->salt_len
= salt_len
;
10306 return (PARSER_OK
);
10309 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10311 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10313 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10317 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10320 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10322 char *iter_pos
= input_buf
+ 6;
10324 salt_t
*salt
= hash_buf
->salt
;
10326 uint iter
= atoi (iter_pos
);
10330 iter
= ROUNDS_DCC2
;
10333 salt
->salt_iter
= iter
- 1;
10335 char *salt_pos
= strchr (iter_pos
, '#');
10337 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10341 char *digest_pos
= strchr (salt_pos
, '#');
10343 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10347 uint salt_len
= digest_pos
- salt_pos
- 1;
10349 u32
*digest
= (u32
*) hash_buf
->digest
;
10351 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10352 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10353 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10354 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10356 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10358 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10360 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10362 salt
->salt_len
= salt_len
;
10364 return (PARSER_OK
);
10367 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10369 u32
*digest
= (u32
*) hash_buf
->digest
;
10371 salt_t
*salt
= hash_buf
->salt
;
10373 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10377 memcpy (&in
, input_buf
, input_len
);
10379 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10381 memcpy (digest
, in
.keymic
, 16);
10384 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10385 The phrase "Pairwise key expansion"
10386 Access Point Address (referred to as Authenticator Address AA)
10387 Supplicant Address (referred to as Supplicant Address SA)
10388 Access Point Nonce (referred to as Authenticator Anonce)
10389 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10392 uint salt_len
= strlen (in
.essid
);
10396 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10398 return (PARSER_SALT_LENGTH
);
10401 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10403 salt
->salt_len
= salt_len
;
10405 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10407 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10409 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10411 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10413 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10414 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10418 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10419 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10422 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10424 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10425 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10429 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10430 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10433 for (int i
= 0; i
< 25; i
++)
10435 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10438 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10439 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10440 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10441 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10443 wpa
->keyver
= in
.keyver
;
10445 if (wpa
->keyver
> 255)
10447 log_info ("ATTENTION!");
10448 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10449 log_info (" This could be due to a recent aircrack-ng bug.");
10450 log_info (" The key version was automatically reset to a reasonable value.");
10453 wpa
->keyver
&= 0xff;
10456 wpa
->eapol_size
= in
.eapol_size
;
10458 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10460 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10462 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10464 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10466 if (wpa
->keyver
== 1)
10472 digest
[0] = byte_swap_32 (digest
[0]);
10473 digest
[1] = byte_swap_32 (digest
[1]);
10474 digest
[2] = byte_swap_32 (digest
[2]);
10475 digest
[3] = byte_swap_32 (digest
[3]);
10477 for (int i
= 0; i
< 64; i
++)
10479 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10483 uint32_t *p0
= (uint32_t *) in
.essid
;
10487 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10488 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10490 salt
->salt_buf
[10] = c0
;
10491 salt
->salt_buf
[11] = c1
;
10493 return (PARSER_OK
);
10496 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10498 u32
*digest
= (u32
*) hash_buf
->digest
;
10500 salt_t
*salt
= hash_buf
->salt
;
10502 if (input_len
== 0)
10504 log_error ("Password Safe v2 container not specified");
10509 FILE *fp
= fopen (input_buf
, "rb");
10513 log_error ("%s: %s", input_buf
, strerror (errno
));
10520 memset (&buf
, 0, sizeof (psafe2_hdr
));
10522 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10526 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10528 salt
->salt_buf
[0] = buf
.random
[0];
10529 salt
->salt_buf
[1] = buf
.random
[1];
10531 salt
->salt_len
= 8;
10532 salt
->salt_iter
= 1000;
10534 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10535 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10536 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10537 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10538 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10540 return (PARSER_OK
);
10543 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10545 u32
*digest
= (u32
*) hash_buf
->digest
;
10547 salt_t
*salt
= hash_buf
->salt
;
10549 if (input_len
== 0)
10551 log_error (".psafe3 not specified");
10556 FILE *fp
= fopen (input_buf
, "rb");
10560 log_error ("%s: %s", input_buf
, strerror (errno
));
10567 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10571 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10573 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10575 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10577 salt
->salt_iter
= in
.iterations
+ 1;
10579 salt
->salt_buf
[0] = in
.salt_buf
[0];
10580 salt
->salt_buf
[1] = in
.salt_buf
[1];
10581 salt
->salt_buf
[2] = in
.salt_buf
[2];
10582 salt
->salt_buf
[3] = in
.salt_buf
[3];
10583 salt
->salt_buf
[4] = in
.salt_buf
[4];
10584 salt
->salt_buf
[5] = in
.salt_buf
[5];
10585 salt
->salt_buf
[6] = in
.salt_buf
[6];
10586 salt
->salt_buf
[7] = in
.salt_buf
[7];
10588 salt
->salt_len
= 32;
10590 digest
[0] = in
.hash_buf
[0];
10591 digest
[1] = in
.hash_buf
[1];
10592 digest
[2] = in
.hash_buf
[2];
10593 digest
[3] = in
.hash_buf
[3];
10594 digest
[4] = in
.hash_buf
[4];
10595 digest
[5] = in
.hash_buf
[5];
10596 digest
[6] = in
.hash_buf
[6];
10597 digest
[7] = in
.hash_buf
[7];
10599 digest
[0] = byte_swap_32 (digest
[0]);
10600 digest
[1] = byte_swap_32 (digest
[1]);
10601 digest
[2] = byte_swap_32 (digest
[2]);
10602 digest
[3] = byte_swap_32 (digest
[3]);
10603 digest
[4] = byte_swap_32 (digest
[4]);
10604 digest
[5] = byte_swap_32 (digest
[5]);
10605 digest
[6] = byte_swap_32 (digest
[6]);
10606 digest
[7] = byte_swap_32 (digest
[7]);
10608 return (PARSER_OK
);
10611 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10613 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10615 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10617 u32
*digest
= (u32
*) hash_buf
->digest
;
10619 salt_t
*salt
= hash_buf
->salt
;
10621 char *iter_pos
= input_buf
+ 3;
10623 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10625 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10627 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10629 salt
->salt_iter
= salt_iter
;
10631 char *salt_pos
= iter_pos
+ 1;
10635 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10637 salt
->salt_len
= salt_len
;
10639 char *hash_pos
= salt_pos
+ salt_len
;
10641 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10643 return (PARSER_OK
);
10646 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10648 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10650 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10652 u32
*digest
= (u32
*) hash_buf
->digest
;
10654 salt_t
*salt
= hash_buf
->salt
;
10656 char *salt_pos
= input_buf
+ 3;
10658 uint iterations_len
= 0;
10660 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10664 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10666 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10667 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10671 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10675 iterations_len
+= 8;
10679 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10682 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10684 char *hash_pos
= strchr (salt_pos
, '$');
10686 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10688 uint salt_len
= hash_pos
- salt_pos
;
10690 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10692 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10694 salt
->salt_len
= salt_len
;
10698 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10700 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10702 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10704 return (PARSER_OK
);
10707 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10709 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10711 u32
*digest
= (u32
*) hash_buf
->digest
;
10713 salt_t
*salt
= hash_buf
->salt
;
10715 char *salt_pos
= input_buf
+ 6;
10717 uint iterations_len
= 0;
10719 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10723 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10725 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10726 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10730 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10734 iterations_len
+= 8;
10738 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10741 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10743 char *hash_pos
= strchr (salt_pos
, '$');
10745 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10747 uint salt_len
= hash_pos
- salt_pos
;
10749 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10751 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10753 salt
->salt_len
= salt_len
;
10757 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10759 return (PARSER_OK
);
10762 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10764 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10766 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10768 u32
*digest
= (u32
*) hash_buf
->digest
;
10770 salt_t
*salt
= hash_buf
->salt
;
10772 char *salt_pos
= input_buf
+ 14;
10774 char *hash_pos
= strchr (salt_pos
, '*');
10776 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10780 uint salt_len
= hash_pos
- salt_pos
- 1;
10782 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10784 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10786 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10788 salt
->salt_len
= salt_len
;
10790 u8 tmp_buf
[100] = { 0 };
10792 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10794 memcpy (digest
, tmp_buf
, 20);
10796 digest
[0] = byte_swap_32 (digest
[0]);
10797 digest
[1] = byte_swap_32 (digest
[1]);
10798 digest
[2] = byte_swap_32 (digest
[2]);
10799 digest
[3] = byte_swap_32 (digest
[3]);
10800 digest
[4] = byte_swap_32 (digest
[4]);
10802 digest
[0] -= SHA1M_A
;
10803 digest
[1] -= SHA1M_B
;
10804 digest
[2] -= SHA1M_C
;
10805 digest
[3] -= SHA1M_D
;
10806 digest
[4] -= SHA1M_E
;
10808 return (PARSER_OK
);
10811 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10813 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10815 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10817 if (c12
& 3) return (PARSER_HASH_VALUE
);
10819 u32
*digest
= (u32
*) hash_buf
->digest
;
10821 salt_t
*salt
= hash_buf
->salt
;
10823 // for ascii_digest
10824 salt
->salt_sign
[0] = input_buf
[0];
10825 salt
->salt_sign
[1] = input_buf
[1];
10827 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10828 | itoa64_to_int (input_buf
[1]) << 6;
10830 salt
->salt_len
= 2;
10832 u8 tmp_buf
[100] = { 0 };
10834 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10836 memcpy (digest
, tmp_buf
, 8);
10840 IP (digest
[0], digest
[1], tt
);
10845 return (PARSER_OK
);
10848 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10850 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10852 u32
*digest
= (u32
*) hash_buf
->digest
;
10854 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10855 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10856 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10857 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10859 digest
[0] = byte_swap_32 (digest
[0]);
10860 digest
[1] = byte_swap_32 (digest
[1]);
10861 digest
[2] = byte_swap_32 (digest
[2]);
10862 digest
[3] = byte_swap_32 (digest
[3]);
10864 digest
[0] -= MD4M_A
;
10865 digest
[1] -= MD4M_B
;
10866 digest
[2] -= MD4M_C
;
10867 digest
[3] -= MD4M_D
;
10869 return (PARSER_OK
);
10872 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10874 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10876 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10880 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10883 u32
*digest
= (u32
*) hash_buf
->digest
;
10885 salt_t
*salt
= hash_buf
->salt
;
10887 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10888 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10889 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10890 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10892 digest
[0] = byte_swap_32 (digest
[0]);
10893 digest
[1] = byte_swap_32 (digest
[1]);
10894 digest
[2] = byte_swap_32 (digest
[2]);
10895 digest
[3] = byte_swap_32 (digest
[3]);
10897 digest
[0] -= MD4M_A
;
10898 digest
[1] -= MD4M_B
;
10899 digest
[2] -= MD4M_C
;
10900 digest
[3] -= MD4M_D
;
10902 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10904 uint salt_len
= input_len
- 32 - 1;
10906 char *salt_buf
= input_buf
+ 32 + 1;
10908 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10910 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10912 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10914 salt
->salt_len
= salt_len
;
10916 return (PARSER_OK
);
10919 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10921 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10923 u32
*digest
= (u32
*) hash_buf
->digest
;
10925 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10926 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10927 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10928 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10930 digest
[0] = byte_swap_32 (digest
[0]);
10931 digest
[1] = byte_swap_32 (digest
[1]);
10932 digest
[2] = byte_swap_32 (digest
[2]);
10933 digest
[3] = byte_swap_32 (digest
[3]);
10935 digest
[0] -= MD5M_A
;
10936 digest
[1] -= MD5M_B
;
10937 digest
[2] -= MD5M_C
;
10938 digest
[3] -= MD5M_D
;
10940 return (PARSER_OK
);
10943 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10945 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10947 u32
*digest
= (u32
*) hash_buf
->digest
;
10949 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10950 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10954 digest
[0] = byte_swap_32 (digest
[0]);
10955 digest
[1] = byte_swap_32 (digest
[1]);
10957 return (PARSER_OK
);
10960 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10962 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10964 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10968 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10971 u32
*digest
= (u32
*) hash_buf
->digest
;
10973 salt_t
*salt
= hash_buf
->salt
;
10975 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10976 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10977 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10978 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10980 digest
[0] = byte_swap_32 (digest
[0]);
10981 digest
[1] = byte_swap_32 (digest
[1]);
10982 digest
[2] = byte_swap_32 (digest
[2]);
10983 digest
[3] = byte_swap_32 (digest
[3]);
10985 digest
[0] -= MD5M_A
;
10986 digest
[1] -= MD5M_B
;
10987 digest
[2] -= MD5M_C
;
10988 digest
[3] -= MD5M_D
;
10990 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10992 uint salt_len
= input_len
- 32 - 1;
10994 char *salt_buf
= input_buf
+ 32 + 1;
10996 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10998 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11000 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11002 salt
->salt_len
= salt_len
;
11004 return (PARSER_OK
);
11007 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11009 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11011 u32
*digest
= (u32
*) hash_buf
->digest
;
11013 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11014 | itoa64_to_int (input_buf
[ 1]) << 6
11015 | itoa64_to_int (input_buf
[ 2]) << 12
11016 | itoa64_to_int (input_buf
[ 3]) << 18;
11017 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11018 | itoa64_to_int (input_buf
[ 5]) << 6
11019 | itoa64_to_int (input_buf
[ 6]) << 12
11020 | itoa64_to_int (input_buf
[ 7]) << 18;
11021 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11022 | itoa64_to_int (input_buf
[ 9]) << 6
11023 | itoa64_to_int (input_buf
[10]) << 12
11024 | itoa64_to_int (input_buf
[11]) << 18;
11025 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11026 | itoa64_to_int (input_buf
[13]) << 6
11027 | itoa64_to_int (input_buf
[14]) << 12
11028 | itoa64_to_int (input_buf
[15]) << 18;
11030 digest
[0] -= MD5M_A
;
11031 digest
[1] -= MD5M_B
;
11032 digest
[2] -= MD5M_C
;
11033 digest
[3] -= MD5M_D
;
11035 digest
[0] &= 0x00ffffff;
11036 digest
[1] &= 0x00ffffff;
11037 digest
[2] &= 0x00ffffff;
11038 digest
[3] &= 0x00ffffff;
11040 return (PARSER_OK
);
11043 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11045 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11047 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11051 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11054 u32
*digest
= (u32
*) hash_buf
->digest
;
11056 salt_t
*salt
= hash_buf
->salt
;
11058 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11059 | itoa64_to_int (input_buf
[ 1]) << 6
11060 | itoa64_to_int (input_buf
[ 2]) << 12
11061 | itoa64_to_int (input_buf
[ 3]) << 18;
11062 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11063 | itoa64_to_int (input_buf
[ 5]) << 6
11064 | itoa64_to_int (input_buf
[ 6]) << 12
11065 | itoa64_to_int (input_buf
[ 7]) << 18;
11066 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11067 | itoa64_to_int (input_buf
[ 9]) << 6
11068 | itoa64_to_int (input_buf
[10]) << 12
11069 | itoa64_to_int (input_buf
[11]) << 18;
11070 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11071 | itoa64_to_int (input_buf
[13]) << 6
11072 | itoa64_to_int (input_buf
[14]) << 12
11073 | itoa64_to_int (input_buf
[15]) << 18;
11075 digest
[0] -= MD5M_A
;
11076 digest
[1] -= MD5M_B
;
11077 digest
[2] -= MD5M_C
;
11078 digest
[3] -= MD5M_D
;
11080 digest
[0] &= 0x00ffffff;
11081 digest
[1] &= 0x00ffffff;
11082 digest
[2] &= 0x00ffffff;
11083 digest
[3] &= 0x00ffffff;
11085 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11087 uint salt_len
= input_len
- 16 - 1;
11089 char *salt_buf
= input_buf
+ 16 + 1;
11091 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11093 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11095 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11097 salt
->salt_len
= salt_len
;
11099 return (PARSER_OK
);
11102 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11104 key
[0] = (nthash
[0] >> 0);
11105 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11106 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11107 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11108 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11109 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11110 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11111 key
[7] = (nthash
[6] << 1);
11123 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11125 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11127 u32
*digest
= (u32
*) hash_buf
->digest
;
11129 salt_t
*salt
= hash_buf
->salt
;
11131 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11137 char *user_pos
= input_buf
;
11139 char *unused_pos
= strchr (user_pos
, ':');
11141 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11143 uint user_len
= unused_pos
- user_pos
;
11145 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11149 char *domain_pos
= strchr (unused_pos
, ':');
11151 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11153 uint unused_len
= domain_pos
- unused_pos
;
11155 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11159 char *srvchall_pos
= strchr (domain_pos
, ':');
11161 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11163 uint domain_len
= srvchall_pos
- domain_pos
;
11165 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11169 char *hash_pos
= strchr (srvchall_pos
, ':');
11171 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11173 uint srvchall_len
= hash_pos
- srvchall_pos
;
11175 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11179 char *clichall_pos
= strchr (hash_pos
, ':');
11181 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11183 uint hash_len
= clichall_pos
- hash_pos
;
11185 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11189 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11191 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11194 * store some data for later use
11197 netntlm
->user_len
= user_len
* 2;
11198 netntlm
->domain_len
= domain_len
* 2;
11199 netntlm
->srvchall_len
= srvchall_len
/ 2;
11200 netntlm
->clichall_len
= clichall_len
/ 2;
11202 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11203 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11206 * handle username and domainname
11209 for (uint i
= 0; i
< user_len
; i
++)
11211 *userdomain_ptr
++ = user_pos
[i
];
11212 *userdomain_ptr
++ = 0;
11215 for (uint i
= 0; i
< domain_len
; i
++)
11217 *userdomain_ptr
++ = domain_pos
[i
];
11218 *userdomain_ptr
++ = 0;
11222 * handle server challenge encoding
11225 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11227 const char p0
= srvchall_pos
[i
+ 0];
11228 const char p1
= srvchall_pos
[i
+ 1];
11230 *chall_ptr
++ = hex_convert (p1
) << 0
11231 | hex_convert (p0
) << 4;
11235 * handle client challenge encoding
11238 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11240 const char p0
= clichall_pos
[i
+ 0];
11241 const char p1
= clichall_pos
[i
+ 1];
11243 *chall_ptr
++ = hex_convert (p1
) << 0
11244 | hex_convert (p0
) << 4;
11251 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11253 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11255 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11257 salt
->salt_len
= salt_len
;
11259 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11260 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11261 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11262 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11264 digest
[0] = byte_swap_32 (digest
[0]);
11265 digest
[1] = byte_swap_32 (digest
[1]);
11266 digest
[2] = byte_swap_32 (digest
[2]);
11267 digest
[3] = byte_swap_32 (digest
[3]);
11269 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11271 uint digest_tmp
[2] = { 0 };
11273 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11274 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11276 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11277 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11279 /* special case 2: ESS */
11281 if (srvchall_len
== 48)
11283 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11285 uint w
[16] = { 0 };
11287 w
[ 0] = netntlm
->chall_buf
[6];
11288 w
[ 1] = netntlm
->chall_buf
[7];
11289 w
[ 2] = netntlm
->chall_buf
[0];
11290 w
[ 3] = netntlm
->chall_buf
[1];
11294 uint dgst
[4] = { 0 };
11303 salt
->salt_buf
[0] = dgst
[0];
11304 salt
->salt_buf
[1] = dgst
[1];
11308 /* precompute netntlmv1 exploit start */
11310 for (uint i
= 0; i
< 0x10000; i
++)
11312 uint key_md4
[2] = { i
, 0 };
11313 uint key_des
[2] = { 0, 0 };
11315 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11317 uint Kc
[16] = { 0 };
11318 uint Kd
[16] = { 0 };
11320 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11322 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11324 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11326 if (data3
[0] != digest_tmp
[0]) continue;
11327 if (data3
[1] != digest_tmp
[1]) continue;
11329 salt
->salt_buf
[2] = i
;
11331 salt
->salt_len
= 24;
11336 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11337 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11339 /* precompute netntlmv1 exploit stop */
11343 IP (digest
[0], digest
[1], tt
);
11344 IP (digest
[2], digest
[3], tt
);
11346 digest
[0] = rotr32 (digest
[0], 29);
11347 digest
[1] = rotr32 (digest
[1], 29);
11348 digest
[2] = rotr32 (digest
[2], 29);
11349 digest
[3] = rotr32 (digest
[3], 29);
11351 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11353 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11354 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11356 return (PARSER_OK
);
11359 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11361 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11363 u32
*digest
= (u32
*) hash_buf
->digest
;
11365 salt_t
*salt
= hash_buf
->salt
;
11367 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11373 char *user_pos
= input_buf
;
11375 char *unused_pos
= strchr (user_pos
, ':');
11377 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11379 uint user_len
= unused_pos
- user_pos
;
11381 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11385 char *domain_pos
= strchr (unused_pos
, ':');
11387 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11389 uint unused_len
= domain_pos
- unused_pos
;
11391 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11395 char *srvchall_pos
= strchr (domain_pos
, ':');
11397 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11399 uint domain_len
= srvchall_pos
- domain_pos
;
11401 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11405 char *hash_pos
= strchr (srvchall_pos
, ':');
11407 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11409 uint srvchall_len
= hash_pos
- srvchall_pos
;
11411 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11415 char *clichall_pos
= strchr (hash_pos
, ':');
11417 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11419 uint hash_len
= clichall_pos
- hash_pos
;
11421 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11425 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11427 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11429 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11432 * store some data for later use
11435 netntlm
->user_len
= user_len
* 2;
11436 netntlm
->domain_len
= domain_len
* 2;
11437 netntlm
->srvchall_len
= srvchall_len
/ 2;
11438 netntlm
->clichall_len
= clichall_len
/ 2;
11440 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11441 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11444 * handle username and domainname
11447 for (uint i
= 0; i
< user_len
; i
++)
11449 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11450 *userdomain_ptr
++ = 0;
11453 for (uint i
= 0; i
< domain_len
; i
++)
11455 *userdomain_ptr
++ = domain_pos
[i
];
11456 *userdomain_ptr
++ = 0;
11459 *userdomain_ptr
++ = 0x80;
11462 * handle server challenge encoding
11465 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11467 const char p0
= srvchall_pos
[i
+ 0];
11468 const char p1
= srvchall_pos
[i
+ 1];
11470 *chall_ptr
++ = hex_convert (p1
) << 0
11471 | hex_convert (p0
) << 4;
11475 * handle client challenge encoding
11478 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11480 const char p0
= clichall_pos
[i
+ 0];
11481 const char p1
= clichall_pos
[i
+ 1];
11483 *chall_ptr
++ = hex_convert (p1
) << 0
11484 | hex_convert (p0
) << 4;
11487 *chall_ptr
++ = 0x80;
11490 * handle hash itself
11493 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11494 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11495 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11496 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11498 digest
[0] = byte_swap_32 (digest
[0]);
11499 digest
[1] = byte_swap_32 (digest
[1]);
11500 digest
[2] = byte_swap_32 (digest
[2]);
11501 digest
[3] = byte_swap_32 (digest
[3]);
11504 * reuse challange data as salt_buf, its the buffer that is most likely unique
11507 salt
->salt_buf
[0] = 0;
11508 salt
->salt_buf
[1] = 0;
11509 salt
->salt_buf
[2] = 0;
11510 salt
->salt_buf
[3] = 0;
11511 salt
->salt_buf
[4] = 0;
11512 salt
->salt_buf
[5] = 0;
11513 salt
->salt_buf
[6] = 0;
11514 salt
->salt_buf
[7] = 0;
11518 uptr
= (uint
*) netntlm
->userdomain_buf
;
11520 for (uint i
= 0; i
< 16; i
+= 16)
11522 md5_64 (uptr
, salt
->salt_buf
);
11525 uptr
= (uint
*) netntlm
->chall_buf
;
11527 for (uint i
= 0; i
< 256; i
+= 16)
11529 md5_64 (uptr
, salt
->salt_buf
);
11532 salt
->salt_len
= 16;
11534 return (PARSER_OK
);
11537 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11539 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11541 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11545 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11548 u32
*digest
= (u32
*) hash_buf
->digest
;
11550 salt_t
*salt
= hash_buf
->salt
;
11552 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11553 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11554 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11555 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11557 digest
[0] = byte_swap_32 (digest
[0]);
11558 digest
[1] = byte_swap_32 (digest
[1]);
11559 digest
[2] = byte_swap_32 (digest
[2]);
11560 digest
[3] = byte_swap_32 (digest
[3]);
11562 digest
[0] -= MD5M_A
;
11563 digest
[1] -= MD5M_B
;
11564 digest
[2] -= MD5M_C
;
11565 digest
[3] -= MD5M_D
;
11567 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11569 uint salt_len
= input_len
- 32 - 1;
11571 char *salt_buf
= input_buf
+ 32 + 1;
11573 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11575 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11577 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11579 salt
->salt_len
= salt_len
;
11581 return (PARSER_OK
);
11584 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11586 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11588 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11592 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11595 u32
*digest
= (u32
*) hash_buf
->digest
;
11597 salt_t
*salt
= hash_buf
->salt
;
11599 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11600 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11601 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11602 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11604 digest
[0] = byte_swap_32 (digest
[0]);
11605 digest
[1] = byte_swap_32 (digest
[1]);
11606 digest
[2] = byte_swap_32 (digest
[2]);
11607 digest
[3] = byte_swap_32 (digest
[3]);
11609 digest
[0] -= MD5M_A
;
11610 digest
[1] -= MD5M_B
;
11611 digest
[2] -= MD5M_C
;
11612 digest
[3] -= MD5M_D
;
11614 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11616 uint salt_len
= input_len
- 32 - 1;
11618 char *salt_buf
= input_buf
+ 32 + 1;
11620 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11622 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11624 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11626 salt
->salt_len
= salt_len
;
11628 return (PARSER_OK
);
11631 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11633 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11635 u32
*digest
= (u32
*) hash_buf
->digest
;
11637 salt_t
*salt
= hash_buf
->salt
;
11639 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11640 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11641 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11642 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11644 digest
[0] = byte_swap_32 (digest
[0]);
11645 digest
[1] = byte_swap_32 (digest
[1]);
11646 digest
[2] = byte_swap_32 (digest
[2]);
11647 digest
[3] = byte_swap_32 (digest
[3]);
11649 digest
[0] -= MD5M_A
;
11650 digest
[1] -= MD5M_B
;
11651 digest
[2] -= MD5M_C
;
11652 digest
[3] -= MD5M_D
;
11655 * This is a virtual salt. While the algorithm is basically not salted
11656 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11657 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11660 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11662 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11664 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11666 salt
->salt_len
= salt_len
;
11668 return (PARSER_OK
);
11671 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11673 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11675 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11679 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11682 u32
*digest
= (u32
*) hash_buf
->digest
;
11684 salt_t
*salt
= hash_buf
->salt
;
11686 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11687 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11688 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11689 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11691 digest
[0] = byte_swap_32 (digest
[0]);
11692 digest
[1] = byte_swap_32 (digest
[1]);
11693 digest
[2] = byte_swap_32 (digest
[2]);
11694 digest
[3] = byte_swap_32 (digest
[3]);
11696 digest
[0] -= MD5M_A
;
11697 digest
[1] -= MD5M_B
;
11698 digest
[2] -= MD5M_C
;
11699 digest
[3] -= MD5M_D
;
11701 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11703 uint salt_len
= input_len
- 32 - 1;
11705 char *salt_buf
= input_buf
+ 32 + 1;
11707 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11709 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11711 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11713 salt
->salt_len
= salt_len
;
11715 return (PARSER_OK
);
11718 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11720 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11722 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11726 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11729 u32
*digest
= (u32
*) hash_buf
->digest
;
11731 salt_t
*salt
= hash_buf
->salt
;
11733 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11734 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11735 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11736 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11738 digest
[0] = byte_swap_32 (digest
[0]);
11739 digest
[1] = byte_swap_32 (digest
[1]);
11740 digest
[2] = byte_swap_32 (digest
[2]);
11741 digest
[3] = byte_swap_32 (digest
[3]);
11743 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11745 uint salt_len
= input_len
- 32 - 1;
11747 char *salt_buf
= input_buf
+ 32 + 1;
11749 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11751 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11753 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11755 salt
->salt_len
= salt_len
;
11757 return (PARSER_OK
);
11760 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11762 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11764 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11768 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11771 u32
*digest
= (u32
*) hash_buf
->digest
;
11773 salt_t
*salt
= hash_buf
->salt
;
11775 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11776 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11777 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11778 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11780 digest
[0] = byte_swap_32 (digest
[0]);
11781 digest
[1] = byte_swap_32 (digest
[1]);
11782 digest
[2] = byte_swap_32 (digest
[2]);
11783 digest
[3] = byte_swap_32 (digest
[3]);
11785 digest
[0] -= MD4M_A
;
11786 digest
[1] -= MD4M_B
;
11787 digest
[2] -= MD4M_C
;
11788 digest
[3] -= MD4M_D
;
11790 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11792 uint salt_len
= input_len
- 32 - 1;
11794 char *salt_buf
= input_buf
+ 32 + 1;
11796 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11798 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11800 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11802 salt
->salt_len
= salt_len
;
11804 return (PARSER_OK
);
11807 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11809 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11811 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11815 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11818 u32
*digest
= (u32
*) hash_buf
->digest
;
11820 salt_t
*salt
= hash_buf
->salt
;
11822 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11823 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11824 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11825 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11827 digest
[0] = byte_swap_32 (digest
[0]);
11828 digest
[1] = byte_swap_32 (digest
[1]);
11829 digest
[2] = byte_swap_32 (digest
[2]);
11830 digest
[3] = byte_swap_32 (digest
[3]);
11832 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11834 uint salt_len
= input_len
- 32 - 1;
11836 char *salt_buf
= input_buf
+ 32 + 1;
11838 uint salt_pc_block
[16] = { 0 };
11840 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11842 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11844 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11846 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11848 salt_pc_block
[14] = salt_len
* 8;
11850 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11852 md5_64 (salt_pc_block
, salt_pc_digest
);
11854 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11855 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11856 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11857 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11859 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11861 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11863 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11865 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11866 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11867 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11868 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11870 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11872 return (PARSER_OK
);
11875 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11877 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11879 u32
*digest
= (u32
*) hash_buf
->digest
;
11881 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11882 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11883 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11884 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11885 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11887 digest
[0] -= SHA1M_A
;
11888 digest
[1] -= SHA1M_B
;
11889 digest
[2] -= SHA1M_C
;
11890 digest
[3] -= SHA1M_D
;
11891 digest
[4] -= SHA1M_E
;
11893 return (PARSER_OK
);
11896 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11898 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11900 u32
*digest
= (u32
*) hash_buf
->digest
;
11902 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11903 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11904 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11905 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11906 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11908 return (PARSER_OK
);
11911 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11913 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11915 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11917 u32
*digest
= (u32
*) hash_buf
->digest
;
11921 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11922 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11923 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11924 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11925 digest
[4] = 0x00000000;
11927 return (PARSER_OK
);
11930 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11932 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11934 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11938 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11941 u32
*digest
= (u32
*) hash_buf
->digest
;
11943 salt_t
*salt
= hash_buf
->salt
;
11945 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11946 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11947 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11948 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11949 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11951 digest
[0] -= SHA1M_A
;
11952 digest
[1] -= SHA1M_B
;
11953 digest
[2] -= SHA1M_C
;
11954 digest
[3] -= SHA1M_D
;
11955 digest
[4] -= SHA1M_E
;
11957 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11959 uint salt_len
= input_len
- 40 - 1;
11961 char *salt_buf
= input_buf
+ 40 + 1;
11963 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11965 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11967 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11969 salt
->salt_len
= salt_len
;
11971 return (PARSER_OK
);
11974 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11976 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
11978 u32
*digest
= (u32
*) hash_buf
->digest
;
11980 salt_t
*salt
= hash_buf
->salt
;
11982 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
11984 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11985 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11986 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11987 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11988 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11990 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11992 uint salt_len
= input_len
- 40 - 1;
11994 char *salt_buf
= input_buf
+ 40 + 1;
11996 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
11998 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12000 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12002 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12005 pstoken
->salt_len
= salt_len
/ 2;
12007 /* some fake salt for the sorting mechanisms */
12009 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12010 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12011 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12012 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12013 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12014 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12015 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12016 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12018 salt
->salt_len
= 32;
12020 /* we need to check if we can precompute some of the data --
12021 this is possible since the scheme is badly designed */
12023 pstoken
->pc_digest
[0] = SHA1M_A
;
12024 pstoken
->pc_digest
[1] = SHA1M_B
;
12025 pstoken
->pc_digest
[2] = SHA1M_C
;
12026 pstoken
->pc_digest
[3] = SHA1M_D
;
12027 pstoken
->pc_digest
[4] = SHA1M_E
;
12029 pstoken
->pc_offset
= 0;
12031 for (int i
= 0; i
< (int) pstoken
->salt_len
- 64; i
+= 64)
12035 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12036 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12037 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12038 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12039 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12040 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12041 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12042 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12043 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12044 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12045 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12046 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12047 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12048 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12049 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12050 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12052 sha1_64 (w
, pstoken
->pc_digest
);
12054 pstoken
->pc_offset
+= 16;
12057 return (PARSER_OK
);
12060 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12062 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12064 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12066 u32
*digest
= (u32
*) hash_buf
->digest
;
12068 u8 tmp_buf
[100] = { 0 };
12070 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12072 memcpy (digest
, tmp_buf
, 20);
12074 digest
[0] = byte_swap_32 (digest
[0]);
12075 digest
[1] = byte_swap_32 (digest
[1]);
12076 digest
[2] = byte_swap_32 (digest
[2]);
12077 digest
[3] = byte_swap_32 (digest
[3]);
12078 digest
[4] = byte_swap_32 (digest
[4]);
12080 digest
[0] -= SHA1M_A
;
12081 digest
[1] -= SHA1M_B
;
12082 digest
[2] -= SHA1M_C
;
12083 digest
[3] -= SHA1M_D
;
12084 digest
[4] -= SHA1M_E
;
12086 return (PARSER_OK
);
12089 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12091 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12093 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12095 u32
*digest
= (u32
*) hash_buf
->digest
;
12097 salt_t
*salt
= hash_buf
->salt
;
12099 u8 tmp_buf
[100] = { 0 };
12101 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12103 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12105 memcpy (digest
, tmp_buf
, 20);
12107 int salt_len
= tmp_len
- 20;
12109 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12111 salt
->salt_len
= salt_len
;
12113 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12115 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12117 char *ptr
= (char *) salt
->salt_buf
;
12119 ptr
[salt
->salt_len
] = 0x80;
12122 digest
[0] = byte_swap_32 (digest
[0]);
12123 digest
[1] = byte_swap_32 (digest
[1]);
12124 digest
[2] = byte_swap_32 (digest
[2]);
12125 digest
[3] = byte_swap_32 (digest
[3]);
12126 digest
[4] = byte_swap_32 (digest
[4]);
12128 digest
[0] -= SHA1M_A
;
12129 digest
[1] -= SHA1M_B
;
12130 digest
[2] -= SHA1M_C
;
12131 digest
[3] -= SHA1M_D
;
12132 digest
[4] -= SHA1M_E
;
12134 return (PARSER_OK
);
12137 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12139 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12141 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12143 u32
*digest
= (u32
*) hash_buf
->digest
;
12145 salt_t
*salt
= hash_buf
->salt
;
12147 char *salt_buf
= input_buf
+ 6;
12151 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12153 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12155 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12157 salt
->salt_len
= salt_len
;
12159 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12161 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12162 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12163 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12164 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12165 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12167 digest
[0] -= SHA1M_A
;
12168 digest
[1] -= SHA1M_B
;
12169 digest
[2] -= SHA1M_C
;
12170 digest
[3] -= SHA1M_D
;
12171 digest
[4] -= SHA1M_E
;
12173 return (PARSER_OK
);
12176 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12178 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12180 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12182 u32
*digest
= (u32
*) hash_buf
->digest
;
12184 salt_t
*salt
= hash_buf
->salt
;
12186 char *salt_buf
= input_buf
+ 6;
12190 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12192 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12194 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12196 salt
->salt_len
= salt_len
;
12198 char *hash_pos
= input_buf
+ 6 + 8;
12200 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12201 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12202 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12203 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12204 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12206 digest
[0] -= SHA1M_A
;
12207 digest
[1] -= SHA1M_B
;
12208 digest
[2] -= SHA1M_C
;
12209 digest
[3] -= SHA1M_D
;
12210 digest
[4] -= SHA1M_E
;
12212 return (PARSER_OK
);
12215 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12217 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12219 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12221 u64
*digest
= (u64
*) hash_buf
->digest
;
12223 salt_t
*salt
= hash_buf
->salt
;
12225 char *salt_buf
= input_buf
+ 6;
12229 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12231 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12233 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12235 salt
->salt_len
= salt_len
;
12237 char *hash_pos
= input_buf
+ 6 + 8;
12239 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12240 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12241 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12242 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12243 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12244 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12245 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12246 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12248 digest
[0] -= SHA512M_A
;
12249 digest
[1] -= SHA512M_B
;
12250 digest
[2] -= SHA512M_C
;
12251 digest
[3] -= SHA512M_D
;
12252 digest
[4] -= SHA512M_E
;
12253 digest
[5] -= SHA512M_F
;
12254 digest
[6] -= SHA512M_G
;
12255 digest
[7] -= SHA512M_H
;
12257 return (PARSER_OK
);
12260 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12262 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12264 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12268 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12271 u32
*digest
= (u32
*) hash_buf
->digest
;
12273 salt_t
*salt
= hash_buf
->salt
;
12275 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12276 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12280 digest
[0] = byte_swap_32 (digest
[0]);
12281 digest
[1] = byte_swap_32 (digest
[1]);
12283 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12285 uint salt_len
= input_len
- 16 - 1;
12287 char *salt_buf
= input_buf
+ 16 + 1;
12289 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12291 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12293 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12295 salt
->salt_len
= salt_len
;
12297 return (PARSER_OK
);
12300 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12302 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12304 u32
*digest
= (u32
*) hash_buf
->digest
;
12306 salt_t
*salt
= hash_buf
->salt
;
12308 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12309 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12310 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12311 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12312 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12314 digest
[0] -= SHA1M_A
;
12315 digest
[1] -= SHA1M_B
;
12316 digest
[2] -= SHA1M_C
;
12317 digest
[3] -= SHA1M_D
;
12318 digest
[4] -= SHA1M_E
;
12320 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12322 uint salt_len
= input_len
- 40 - 1;
12324 char *salt_buf
= input_buf
+ 40 + 1;
12326 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12328 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12330 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12332 salt
->salt_len
= salt_len
;
12334 return (PARSER_OK
);
12337 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12339 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12341 u32
*digest
= (u32
*) hash_buf
->digest
;
12343 salt_t
*salt
= hash_buf
->salt
;
12345 char *hash_pos
= input_buf
;
12347 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12348 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12349 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12350 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12351 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12352 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12353 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12354 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12355 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12356 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12357 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12358 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12359 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12360 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12361 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12362 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12364 char *salt_pos
= input_buf
+ 128;
12366 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12367 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12368 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12369 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12371 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12372 salt
->salt_len
= 16;
12374 return (PARSER_OK
);
12377 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12379 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12381 u32
*digest
= (u32
*) hash_buf
->digest
;
12383 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12384 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12385 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12386 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12387 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12388 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12389 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12390 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12392 digest
[0] -= SHA256M_A
;
12393 digest
[1] -= SHA256M_B
;
12394 digest
[2] -= SHA256M_C
;
12395 digest
[3] -= SHA256M_D
;
12396 digest
[4] -= SHA256M_E
;
12397 digest
[5] -= SHA256M_F
;
12398 digest
[6] -= SHA256M_G
;
12399 digest
[7] -= SHA256M_H
;
12401 return (PARSER_OK
);
12404 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12406 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12408 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12412 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12415 u32
*digest
= (u32
*) hash_buf
->digest
;
12417 salt_t
*salt
= hash_buf
->salt
;
12419 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12420 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12421 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12422 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12423 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12424 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12425 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12426 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12428 digest
[0] -= SHA256M_A
;
12429 digest
[1] -= SHA256M_B
;
12430 digest
[2] -= SHA256M_C
;
12431 digest
[3] -= SHA256M_D
;
12432 digest
[4] -= SHA256M_E
;
12433 digest
[5] -= SHA256M_F
;
12434 digest
[6] -= SHA256M_G
;
12435 digest
[7] -= SHA256M_H
;
12437 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12439 uint salt_len
= input_len
- 64 - 1;
12441 char *salt_buf
= input_buf
+ 64 + 1;
12443 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12445 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12447 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12449 salt
->salt_len
= salt_len
;
12451 return (PARSER_OK
);
12454 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12456 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12458 u64
*digest
= (u64
*) hash_buf
->digest
;
12460 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12461 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12462 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12463 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12464 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12465 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12469 digest
[0] -= SHA384M_A
;
12470 digest
[1] -= SHA384M_B
;
12471 digest
[2] -= SHA384M_C
;
12472 digest
[3] -= SHA384M_D
;
12473 digest
[4] -= SHA384M_E
;
12474 digest
[5] -= SHA384M_F
;
12478 return (PARSER_OK
);
12481 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12483 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12485 u64
*digest
= (u64
*) hash_buf
->digest
;
12487 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12488 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12489 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12490 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12491 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12492 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12493 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12494 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12496 digest
[0] -= SHA512M_A
;
12497 digest
[1] -= SHA512M_B
;
12498 digest
[2] -= SHA512M_C
;
12499 digest
[3] -= SHA512M_D
;
12500 digest
[4] -= SHA512M_E
;
12501 digest
[5] -= SHA512M_F
;
12502 digest
[6] -= SHA512M_G
;
12503 digest
[7] -= SHA512M_H
;
12505 return (PARSER_OK
);
12508 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12510 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12512 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12516 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12519 u64
*digest
= (u64
*) hash_buf
->digest
;
12521 salt_t
*salt
= hash_buf
->salt
;
12523 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12524 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12525 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12526 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12527 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12528 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12529 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12530 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12532 digest
[0] -= SHA512M_A
;
12533 digest
[1] -= SHA512M_B
;
12534 digest
[2] -= SHA512M_C
;
12535 digest
[3] -= SHA512M_D
;
12536 digest
[4] -= SHA512M_E
;
12537 digest
[5] -= SHA512M_F
;
12538 digest
[6] -= SHA512M_G
;
12539 digest
[7] -= SHA512M_H
;
12541 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12543 uint salt_len
= input_len
- 128 - 1;
12545 char *salt_buf
= input_buf
+ 128 + 1;
12547 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12549 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12551 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12553 salt
->salt_len
= salt_len
;
12555 return (PARSER_OK
);
12558 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12560 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12562 u64
*digest
= (u64
*) hash_buf
->digest
;
12564 salt_t
*salt
= hash_buf
->salt
;
12566 char *salt_pos
= input_buf
+ 3;
12568 uint iterations_len
= 0;
12570 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12574 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12576 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12577 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12581 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12585 iterations_len
+= 8;
12589 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12592 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12594 char *hash_pos
= strchr (salt_pos
, '$');
12596 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12598 uint salt_len
= hash_pos
- salt_pos
;
12600 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12602 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12604 salt
->salt_len
= salt_len
;
12608 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12610 return (PARSER_OK
);
12613 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12615 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12617 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12619 u64
*digest
= (u64
*) hash_buf
->digest
;
12621 salt_t
*salt
= hash_buf
->salt
;
12623 uint keccak_mdlen
= input_len
/ 2;
12625 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12627 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12629 digest
[i
] = byte_swap_64 (digest
[i
]);
12632 salt
->keccak_mdlen
= keccak_mdlen
;
12634 return (PARSER_OK
);
12637 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12639 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12641 u32
*digest
= (u32
*) hash_buf
->digest
;
12643 salt_t
*salt
= hash_buf
->salt
;
12645 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12648 * Parse that strange long line
12653 size_t in_len
[9] = { 0 };
12655 in_off
[0] = strtok (input_buf
, ":");
12657 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12659 in_len
[0] = strlen (in_off
[0]);
12663 for (i
= 1; i
< 9; i
++)
12665 in_off
[i
] = strtok (NULL
, ":");
12667 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12669 in_len
[i
] = strlen (in_off
[i
]);
12672 char *ptr
= (char *) ikepsk
->msg_buf
;
12674 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12675 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12676 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12677 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12678 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12679 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12683 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12685 ptr
= (char *) ikepsk
->nr_buf
;
12687 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12688 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12692 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12695 * Store to database
12700 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12701 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12702 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12703 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12705 digest
[0] = byte_swap_32 (digest
[0]);
12706 digest
[1] = byte_swap_32 (digest
[1]);
12707 digest
[2] = byte_swap_32 (digest
[2]);
12708 digest
[3] = byte_swap_32 (digest
[3]);
12710 salt
->salt_len
= 32;
12712 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12713 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12714 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12715 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12716 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12717 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12718 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12719 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12721 return (PARSER_OK
);
12724 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12726 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12728 u32
*digest
= (u32
*) hash_buf
->digest
;
12730 salt_t
*salt
= hash_buf
->salt
;
12732 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12735 * Parse that strange long line
12740 size_t in_len
[9] = { 0 };
12742 in_off
[0] = strtok (input_buf
, ":");
12744 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12746 in_len
[0] = strlen (in_off
[0]);
12750 for (i
= 1; i
< 9; i
++)
12752 in_off
[i
] = strtok (NULL
, ":");
12754 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12756 in_len
[i
] = strlen (in_off
[i
]);
12759 char *ptr
= (char *) ikepsk
->msg_buf
;
12761 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12762 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12763 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12764 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12765 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12766 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12770 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12772 ptr
= (char *) ikepsk
->nr_buf
;
12774 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12775 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12779 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12782 * Store to database
12787 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12788 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12789 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12790 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12791 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12793 salt
->salt_len
= 32;
12795 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12796 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12797 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12798 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12799 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12800 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12801 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12802 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12804 return (PARSER_OK
);
12807 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12809 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12811 u32
*digest
= (u32
*) hash_buf
->digest
;
12813 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12814 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12815 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12816 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12817 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12819 digest
[0] = byte_swap_32 (digest
[0]);
12820 digest
[1] = byte_swap_32 (digest
[1]);
12821 digest
[2] = byte_swap_32 (digest
[2]);
12822 digest
[3] = byte_swap_32 (digest
[3]);
12823 digest
[4] = byte_swap_32 (digest
[4]);
12825 return (PARSER_OK
);
12828 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12830 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12832 u32
*digest
= (u32
*) hash_buf
->digest
;
12834 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12835 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12836 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12837 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12838 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12839 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12840 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12841 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12842 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12843 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12844 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12845 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12846 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12847 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12848 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12849 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12851 return (PARSER_OK
);
12854 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12856 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12858 u32
*digest
= (u32
*) hash_buf
->digest
;
12860 salt_t
*salt
= hash_buf
->salt
;
12862 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12863 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12864 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12865 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12866 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12868 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12870 uint salt_len
= input_len
- 40 - 1;
12872 char *salt_buf
= input_buf
+ 40 + 1;
12874 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12876 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12878 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12880 salt
->salt_len
= salt_len
;
12882 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12884 return (PARSER_OK
);
12887 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12889 u32
*digest
= (u32
*) hash_buf
->digest
;
12891 salt_t
*salt
= hash_buf
->salt
;
12893 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12895 if (input_len
== 0)
12897 log_error ("TrueCrypt container not specified");
12902 FILE *fp
= fopen (input_buf
, "rb");
12906 log_error ("%s: %s", input_buf
, strerror (errno
));
12911 char buf
[512] = { 0 };
12913 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12917 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12919 memcpy (tc
->salt_buf
, buf
, 64);
12921 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12923 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12925 salt
->salt_len
= 4;
12927 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
12929 tc
->signature
= 0x45555254; // "TRUE"
12931 digest
[0] = tc
->data_buf
[0];
12933 return (PARSER_OK
);
12936 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12938 u32
*digest
= (u32
*) hash_buf
->digest
;
12940 salt_t
*salt
= hash_buf
->salt
;
12942 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12944 if (input_len
== 0)
12946 log_error ("TrueCrypt container not specified");
12951 FILE *fp
= fopen (input_buf
, "rb");
12955 log_error ("%s: %s", input_buf
, strerror (errno
));
12960 char buf
[512] = { 0 };
12962 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12966 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12968 memcpy (tc
->salt_buf
, buf
, 64);
12970 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12972 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12974 salt
->salt_len
= 4;
12976 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
12978 tc
->signature
= 0x45555254; // "TRUE"
12980 digest
[0] = tc
->data_buf
[0];
12982 return (PARSER_OK
);
12985 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12987 u32
*digest
= (u32
*) hash_buf
->digest
;
12989 salt_t
*salt
= hash_buf
->salt
;
12991 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12993 if (input_len
== 0)
12995 log_error ("VeraCrypt container not specified");
13000 FILE *fp
= fopen (input_buf
, "rb");
13004 log_error ("%s: %s", input_buf
, strerror (errno
));
13009 char buf
[512] = { 0 };
13011 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13015 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13017 memcpy (tc
->salt_buf
, buf
, 64);
13019 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13021 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13023 salt
->salt_len
= 4;
13025 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13027 tc
->signature
= 0x41524556; // "VERA"
13029 digest
[0] = tc
->data_buf
[0];
13031 return (PARSER_OK
);
13034 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13036 u32
*digest
= (u32
*) hash_buf
->digest
;
13038 salt_t
*salt
= hash_buf
->salt
;
13040 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13042 if (input_len
== 0)
13044 log_error ("VeraCrypt container not specified");
13049 FILE *fp
= fopen (input_buf
, "rb");
13053 log_error ("%s: %s", input_buf
, strerror (errno
));
13058 char buf
[512] = { 0 };
13060 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13064 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13066 memcpy (tc
->salt_buf
, buf
, 64);
13068 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13070 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13072 salt
->salt_len
= 4;
13074 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13076 tc
->signature
= 0x41524556; // "VERA"
13078 digest
[0] = tc
->data_buf
[0];
13080 return (PARSER_OK
);
13083 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13085 u32
*digest
= (u32
*) hash_buf
->digest
;
13087 salt_t
*salt
= hash_buf
->salt
;
13089 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13091 if (input_len
== 0)
13093 log_error ("VeraCrypt container not specified");
13098 FILE *fp
= fopen (input_buf
, "rb");
13102 log_error ("%s: %s", input_buf
, strerror (errno
));
13107 char buf
[512] = { 0 };
13109 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13113 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13115 memcpy (tc
->salt_buf
, buf
, 64);
13117 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13119 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13121 salt
->salt_len
= 4;
13123 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13125 tc
->signature
= 0x41524556; // "VERA"
13127 digest
[0] = tc
->data_buf
[0];
13129 return (PARSER_OK
);
13132 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13134 u32
*digest
= (u32
*) hash_buf
->digest
;
13136 salt_t
*salt
= hash_buf
->salt
;
13138 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13140 if (input_len
== 0)
13142 log_error ("VeraCrypt container not specified");
13147 FILE *fp
= fopen (input_buf
, "rb");
13151 log_error ("%s: %s", input_buf
, strerror (errno
));
13156 char buf
[512] = { 0 };
13158 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13162 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13164 memcpy (tc
->salt_buf
, buf
, 64);
13166 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13168 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13170 salt
->salt_len
= 4;
13172 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13174 tc
->signature
= 0x41524556; // "VERA"
13176 digest
[0] = tc
->data_buf
[0];
13178 return (PARSER_OK
);
13181 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13183 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13185 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13187 u32
*digest
= (u32
*) hash_buf
->digest
;
13189 salt_t
*salt
= hash_buf
->salt
;
13191 char *salt_pos
= input_buf
+ 6;
13193 char *hash_pos
= strchr (salt_pos
, '$');
13195 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13197 uint salt_len
= hash_pos
- salt_pos
;
13199 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13201 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13203 salt
->salt_len
= salt_len
;
13205 salt
->salt_iter
= 1000;
13209 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13211 return (PARSER_OK
);
13214 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13216 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13218 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13220 u32
*digest
= (u32
*) hash_buf
->digest
;
13222 salt_t
*salt
= hash_buf
->salt
;
13224 char *iter_pos
= input_buf
+ 7;
13226 char *salt_pos
= strchr (iter_pos
, '$');
13228 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13232 char *hash_pos
= strchr (salt_pos
, '$');
13234 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13236 uint salt_len
= hash_pos
- salt_pos
;
13238 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13240 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13242 salt
->salt_len
= salt_len
;
13244 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13246 salt
->salt_sign
[0] = atoi (salt_iter
);
13248 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13252 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13254 digest
[0] = byte_swap_32 (digest
[0]);
13255 digest
[1] = byte_swap_32 (digest
[1]);
13256 digest
[2] = byte_swap_32 (digest
[2]);
13257 digest
[3] = byte_swap_32 (digest
[3]);
13258 digest
[4] = byte_swap_32 (digest
[4]);
13260 return (PARSER_OK
);
13263 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13265 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13267 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13269 u32
*digest
= (u32
*) hash_buf
->digest
;
13271 salt_t
*salt
= hash_buf
->salt
;
13273 char *iter_pos
= input_buf
+ 9;
13275 char *salt_pos
= strchr (iter_pos
, '$');
13277 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13281 char *hash_pos
= strchr (salt_pos
, '$');
13283 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13285 uint salt_len
= hash_pos
- salt_pos
;
13287 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13289 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13291 salt
->salt_len
= salt_len
;
13293 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13295 salt
->salt_sign
[0] = atoi (salt_iter
);
13297 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13301 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13303 digest
[0] = byte_swap_32 (digest
[0]);
13304 digest
[1] = byte_swap_32 (digest
[1]);
13305 digest
[2] = byte_swap_32 (digest
[2]);
13306 digest
[3] = byte_swap_32 (digest
[3]);
13307 digest
[4] = byte_swap_32 (digest
[4]);
13308 digest
[5] = byte_swap_32 (digest
[5]);
13309 digest
[6] = byte_swap_32 (digest
[6]);
13310 digest
[7] = byte_swap_32 (digest
[7]);
13312 return (PARSER_OK
);
13315 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13317 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13319 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13321 u64
*digest
= (u64
*) hash_buf
->digest
;
13323 salt_t
*salt
= hash_buf
->salt
;
13325 char *iter_pos
= input_buf
+ 9;
13327 char *salt_pos
= strchr (iter_pos
, '$');
13329 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13333 char *hash_pos
= strchr (salt_pos
, '$');
13335 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13337 uint salt_len
= hash_pos
- salt_pos
;
13339 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13341 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13343 salt
->salt_len
= salt_len
;
13345 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13347 salt
->salt_sign
[0] = atoi (salt_iter
);
13349 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13353 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13355 digest
[0] = byte_swap_64 (digest
[0]);
13356 digest
[1] = byte_swap_64 (digest
[1]);
13357 digest
[2] = byte_swap_64 (digest
[2]);
13358 digest
[3] = byte_swap_64 (digest
[3]);
13359 digest
[4] = byte_swap_64 (digest
[4]);
13360 digest
[5] = byte_swap_64 (digest
[5]);
13361 digest
[6] = byte_swap_64 (digest
[6]);
13362 digest
[7] = byte_swap_64 (digest
[7]);
13364 return (PARSER_OK
);
13367 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13369 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13371 u32
*digest
= (u32
*) hash_buf
->digest
;
13373 salt_t
*salt
= hash_buf
->salt
;
13375 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13381 char *iterations_pos
= input_buf
;
13383 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13385 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13387 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13389 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13393 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13395 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13397 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13399 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13401 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13403 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13408 * pbkdf2 iterations
13411 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13414 * handle salt encoding
13417 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13419 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13421 const char p0
= saltbuf_pos
[i
+ 0];
13422 const char p1
= saltbuf_pos
[i
+ 1];
13424 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13425 | hex_convert (p0
) << 4;
13428 salt
->salt_len
= saltbuf_len
/ 2;
13431 * handle cipher encoding
13434 uint
*tmp
= (uint
*) mymalloc (32);
13436 char *cipherbuf_ptr
= (char *) tmp
;
13438 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13440 const char p0
= cipherbuf_pos
[i
+ 0];
13441 const char p1
= cipherbuf_pos
[i
+ 1];
13443 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13444 | hex_convert (p0
) << 4;
13447 // iv is stored at salt_buf 4 (length 16)
13448 // data is stored at salt_buf 8 (length 16)
13450 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13451 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13452 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13453 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13455 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13456 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13457 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13458 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13462 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13464 const char p0
= cipherbuf_pos
[j
+ 0];
13465 const char p1
= cipherbuf_pos
[j
+ 1];
13467 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13468 | hex_convert (p0
) << 4;
13475 digest
[0] = 0x10101010;
13476 digest
[1] = 0x10101010;
13477 digest
[2] = 0x10101010;
13478 digest
[3] = 0x10101010;
13480 return (PARSER_OK
);
13483 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13485 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13487 u32
*digest
= (u32
*) hash_buf
->digest
;
13489 salt_t
*salt
= hash_buf
->salt
;
13491 char *hashbuf_pos
= input_buf
;
13493 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13495 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13497 uint hash_len
= iterations_pos
- hashbuf_pos
;
13499 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13503 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13505 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13507 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13511 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13513 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13515 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13517 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13519 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13521 salt
->salt_len
= salt_len
;
13523 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13525 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13526 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13527 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13528 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13530 return (PARSER_OK
);
13533 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13535 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13537 u32
*digest
= (u32
*) hash_buf
->digest
;
13539 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13540 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13541 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13542 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13543 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13544 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13545 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13546 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13548 digest
[0] = byte_swap_32 (digest
[0]);
13549 digest
[1] = byte_swap_32 (digest
[1]);
13550 digest
[2] = byte_swap_32 (digest
[2]);
13551 digest
[3] = byte_swap_32 (digest
[3]);
13552 digest
[4] = byte_swap_32 (digest
[4]);
13553 digest
[5] = byte_swap_32 (digest
[5]);
13554 digest
[6] = byte_swap_32 (digest
[6]);
13555 digest
[7] = byte_swap_32 (digest
[7]);
13557 return (PARSER_OK
);
13560 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13562 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13564 u32
*digest
= (u32
*) hash_buf
->digest
;
13566 salt_t
*salt
= hash_buf
->salt
;
13568 char *salt_pos
= input_buf
+ 3;
13570 uint iterations_len
= 0;
13572 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13576 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13578 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13579 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13583 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13587 iterations_len
+= 8;
13591 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13594 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13596 char *hash_pos
= strchr (salt_pos
, '$');
13598 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13600 uint salt_len
= hash_pos
- salt_pos
;
13602 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13604 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13606 salt
->salt_len
= salt_len
;
13610 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13612 return (PARSER_OK
);
13615 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13617 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13619 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13621 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13623 u64
*digest
= (u64
*) hash_buf
->digest
;
13625 salt_t
*salt
= hash_buf
->salt
;
13627 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13629 char *iter_pos
= input_buf
+ 4;
13631 char *salt_pos
= strchr (iter_pos
, '$');
13633 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13637 char *hash_pos
= strchr (salt_pos
, '$');
13639 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13641 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13645 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13646 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13647 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13648 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13649 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13650 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13651 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13652 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13654 uint salt_len
= hash_pos
- salt_pos
- 1;
13656 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13658 salt
->salt_len
= salt_len
/ 2;
13660 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13661 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13662 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13663 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13664 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13665 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13666 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13667 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13669 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13670 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13671 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13672 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13673 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13674 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13675 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13676 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13677 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13678 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13680 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13682 salt
->salt_iter
= atoi (iter_pos
) - 1;
13684 return (PARSER_OK
);
13687 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13689 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13691 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13693 u32
*digest
= (u32
*) hash_buf
->digest
;
13695 salt_t
*salt
= hash_buf
->salt
;
13697 char *salt_pos
= input_buf
+ 14;
13699 char *hash_pos
= strchr (salt_pos
, '*');
13701 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13705 uint salt_len
= hash_pos
- salt_pos
- 1;
13707 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13709 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13711 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13713 salt
->salt_len
= salt_len
;
13715 u8 tmp_buf
[100] = { 0 };
13717 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13719 memcpy (digest
, tmp_buf
, 32);
13721 digest
[0] = byte_swap_32 (digest
[0]);
13722 digest
[1] = byte_swap_32 (digest
[1]);
13723 digest
[2] = byte_swap_32 (digest
[2]);
13724 digest
[3] = byte_swap_32 (digest
[3]);
13725 digest
[4] = byte_swap_32 (digest
[4]);
13726 digest
[5] = byte_swap_32 (digest
[5]);
13727 digest
[6] = byte_swap_32 (digest
[6]);
13728 digest
[7] = byte_swap_32 (digest
[7]);
13730 digest
[0] -= SHA256M_A
;
13731 digest
[1] -= SHA256M_B
;
13732 digest
[2] -= SHA256M_C
;
13733 digest
[3] -= SHA256M_D
;
13734 digest
[4] -= SHA256M_E
;
13735 digest
[5] -= SHA256M_F
;
13736 digest
[6] -= SHA256M_G
;
13737 digest
[7] -= SHA256M_H
;
13739 return (PARSER_OK
);
13742 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13744 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13746 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13748 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13750 u64
*digest
= (u64
*) hash_buf
->digest
;
13752 salt_t
*salt
= hash_buf
->salt
;
13754 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13756 char *iter_pos
= input_buf
+ 19;
13758 char *salt_pos
= strchr (iter_pos
, '.');
13760 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13764 char *hash_pos
= strchr (salt_pos
, '.');
13766 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13768 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13772 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13773 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13774 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13775 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13776 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13777 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13778 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13779 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13781 uint salt_len
= hash_pos
- salt_pos
- 1;
13785 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13789 for (i
= 0; i
< salt_len
; i
++)
13791 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13794 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13795 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13797 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13799 salt
->salt_len
= salt_len
;
13801 salt
->salt_iter
= atoi (iter_pos
) - 1;
13803 return (PARSER_OK
);
13806 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13808 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13810 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13812 u64
*digest
= (u64
*) hash_buf
->digest
;
13814 salt_t
*salt
= hash_buf
->salt
;
13816 u8 tmp_buf
[120] = { 0 };
13818 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13820 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13822 memcpy (digest
, tmp_buf
, 64);
13824 digest
[0] = byte_swap_64 (digest
[0]);
13825 digest
[1] = byte_swap_64 (digest
[1]);
13826 digest
[2] = byte_swap_64 (digest
[2]);
13827 digest
[3] = byte_swap_64 (digest
[3]);
13828 digest
[4] = byte_swap_64 (digest
[4]);
13829 digest
[5] = byte_swap_64 (digest
[5]);
13830 digest
[6] = byte_swap_64 (digest
[6]);
13831 digest
[7] = byte_swap_64 (digest
[7]);
13833 digest
[0] -= SHA512M_A
;
13834 digest
[1] -= SHA512M_B
;
13835 digest
[2] -= SHA512M_C
;
13836 digest
[3] -= SHA512M_D
;
13837 digest
[4] -= SHA512M_E
;
13838 digest
[5] -= SHA512M_F
;
13839 digest
[6] -= SHA512M_G
;
13840 digest
[7] -= SHA512M_H
;
13842 int salt_len
= tmp_len
- 64;
13844 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13846 salt
->salt_len
= salt_len
;
13848 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13850 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13852 char *ptr
= (char *) salt
->salt_buf
;
13854 ptr
[salt
->salt_len
] = 0x80;
13857 return (PARSER_OK
);
13860 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13862 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13864 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13868 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13871 u32
*digest
= (u32
*) hash_buf
->digest
;
13873 salt_t
*salt
= hash_buf
->salt
;
13875 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13876 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13877 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13878 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13880 digest
[0] = byte_swap_32 (digest
[0]);
13881 digest
[1] = byte_swap_32 (digest
[1]);
13882 digest
[2] = byte_swap_32 (digest
[2]);
13883 digest
[3] = byte_swap_32 (digest
[3]);
13885 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13887 uint salt_len
= input_len
- 32 - 1;
13889 char *salt_buf
= input_buf
+ 32 + 1;
13891 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13893 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13895 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13897 salt
->salt_len
= salt_len
;
13899 return (PARSER_OK
);
13902 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13904 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13906 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13910 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13913 u32
*digest
= (u32
*) hash_buf
->digest
;
13915 salt_t
*salt
= hash_buf
->salt
;
13917 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13918 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13919 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13920 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13921 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13923 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13925 uint salt_len
= input_len
- 40 - 1;
13927 char *salt_buf
= input_buf
+ 40 + 1;
13929 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13931 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13933 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13935 salt
->salt_len
= salt_len
;
13937 return (PARSER_OK
);
13940 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13942 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13944 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13948 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13951 u32
*digest
= (u32
*) hash_buf
->digest
;
13953 salt_t
*salt
= hash_buf
->salt
;
13955 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13956 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13957 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13958 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13959 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13960 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13961 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13962 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13964 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13966 uint salt_len
= input_len
- 64 - 1;
13968 char *salt_buf
= input_buf
+ 64 + 1;
13970 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13972 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13974 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13976 salt
->salt_len
= salt_len
;
13978 return (PARSER_OK
);
13981 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13983 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13985 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13989 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13992 u64
*digest
= (u64
*) hash_buf
->digest
;
13994 salt_t
*salt
= hash_buf
->salt
;
13996 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13997 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13998 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13999 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14000 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14001 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14002 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14003 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14005 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14007 uint salt_len
= input_len
- 128 - 1;
14009 char *salt_buf
= input_buf
+ 128 + 1;
14011 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14013 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14015 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14017 salt
->salt_len
= salt_len
;
14019 return (PARSER_OK
);
14022 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14024 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14026 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14028 u32
*digest
= (u32
*) hash_buf
->digest
;
14030 salt_t
*salt
= hash_buf
->salt
;
14032 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14038 char *user_pos
= input_buf
+ 10 + 1;
14040 char *realm_pos
= strchr (user_pos
, '$');
14042 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14044 uint user_len
= realm_pos
- user_pos
;
14046 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14050 char *salt_pos
= strchr (realm_pos
, '$');
14052 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14054 uint realm_len
= salt_pos
- realm_pos
;
14056 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14060 char *data_pos
= strchr (salt_pos
, '$');
14062 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14064 uint salt_len
= data_pos
- salt_pos
;
14066 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14070 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14072 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14078 memcpy (krb5pa
->user
, user_pos
, user_len
);
14079 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14080 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14082 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14084 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14086 const char p0
= data_pos
[i
+ 0];
14087 const char p1
= data_pos
[i
+ 1];
14089 *timestamp_ptr
++ = hex_convert (p1
) << 0
14090 | hex_convert (p0
) << 4;
14093 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14095 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14097 const char p0
= data_pos
[i
+ 0];
14098 const char p1
= data_pos
[i
+ 1];
14100 *checksum_ptr
++ = hex_convert (p1
) << 0
14101 | hex_convert (p0
) << 4;
14105 * copy some data to generic buffers to make sorting happy
14108 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14109 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14110 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14111 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14112 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14113 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14114 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14115 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14116 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14118 salt
->salt_len
= 36;
14120 digest
[0] = krb5pa
->checksum
[0];
14121 digest
[1] = krb5pa
->checksum
[1];
14122 digest
[2] = krb5pa
->checksum
[2];
14123 digest
[3] = krb5pa
->checksum
[3];
14125 return (PARSER_OK
);
14128 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14130 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14132 u32
*digest
= (u32
*) hash_buf
->digest
;
14134 salt_t
*salt
= hash_buf
->salt
;
14140 char *salt_pos
= input_buf
;
14142 char *hash_pos
= strchr (salt_pos
, '$');
14144 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14146 uint salt_len
= hash_pos
- salt_pos
;
14148 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14152 uint hash_len
= input_len
- 1 - salt_len
;
14154 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14162 for (uint i
= 0; i
< salt_len
; i
++)
14164 if (salt_pos
[i
] == ' ') continue;
14169 // SAP user names cannot be longer than 12 characters
14170 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14172 // SAP user name cannot start with ! or ?
14173 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14179 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14181 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14183 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14185 salt
->salt_len
= salt_len
;
14187 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14188 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14192 digest
[0] = byte_swap_32 (digest
[0]);
14193 digest
[1] = byte_swap_32 (digest
[1]);
14195 return (PARSER_OK
);
14198 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14200 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14202 u32
*digest
= (u32
*) hash_buf
->digest
;
14204 salt_t
*salt
= hash_buf
->salt
;
14210 char *salt_pos
= input_buf
;
14212 char *hash_pos
= strchr (salt_pos
, '$');
14214 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14216 uint salt_len
= hash_pos
- salt_pos
;
14218 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14222 uint hash_len
= input_len
- 1 - salt_len
;
14224 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14232 for (uint i
= 0; i
< salt_len
; i
++)
14234 if (salt_pos
[i
] == ' ') continue;
14239 // SAP user names cannot be longer than 12 characters
14240 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14241 // so far nobody complained so we stay with this because it helps in optimization
14242 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14244 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14246 // SAP user name cannot start with ! or ?
14247 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14253 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14255 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14257 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14259 salt
->salt_len
= salt_len
;
14261 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14262 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14263 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14264 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14265 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14267 return (PARSER_OK
);
14270 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14272 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14274 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14276 u64
*digest
= (u64
*) hash_buf
->digest
;
14278 salt_t
*salt
= hash_buf
->salt
;
14280 char *iter_pos
= input_buf
+ 3;
14282 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14284 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14286 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14288 salt
->salt_iter
= salt_iter
;
14290 char *salt_pos
= iter_pos
+ 1;
14294 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14296 salt
->salt_len
= salt_len
;
14298 char *hash_pos
= salt_pos
+ salt_len
;
14300 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14304 char *tmp
= (char *) salt
->salt_buf_pc
;
14306 tmp
[0] = hash_pos
[42];
14310 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14311 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14312 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14313 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14319 return (PARSER_OK
);
14322 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14324 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14326 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14328 u32
*digest
= (u32
*) hash_buf
->digest
;
14330 salt_t
*salt
= hash_buf
->salt
;
14332 char *salt_buf
= input_buf
+ 6;
14334 uint salt_len
= 16;
14336 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14338 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14340 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14342 salt
->salt_len
= salt_len
;
14344 char *hash_pos
= input_buf
+ 6 + 16;
14346 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14347 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14348 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14349 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14350 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14351 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14352 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14353 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14355 return (PARSER_OK
);
14358 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14360 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14362 u32
*digest
= (u32
*) hash_buf
->digest
;
14364 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14365 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14369 return (PARSER_OK
);
14372 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14374 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14376 u32
*digest
= (u32
*) hash_buf
->digest
;
14378 salt_t
*salt
= hash_buf
->salt
;
14380 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14382 char *saltbuf_pos
= input_buf
;
14384 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14386 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14388 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14390 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14391 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14393 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14397 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14399 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14401 char *salt_ptr
= (char *) saltbuf_pos
;
14402 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14407 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14409 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14412 rakp_ptr
[j
] = 0x80;
14414 rakp
->salt_len
= j
;
14416 for (i
= 0; i
< 64; i
++)
14418 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14421 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14422 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14423 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14424 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14425 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14426 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14427 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14428 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14430 salt
->salt_len
= 32; // muss min. 32 haben
14432 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14433 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14434 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14435 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14436 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14438 return (PARSER_OK
);
14441 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14443 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14445 u32
*digest
= (u32
*) hash_buf
->digest
;
14447 salt_t
*salt
= hash_buf
->salt
;
14449 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14451 char *salt_pos
= input_buf
+ 1;
14453 memcpy (salt
->salt_buf
, salt_pos
, 8);
14455 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14456 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14458 salt
->salt_len
= 8;
14460 char *hash_pos
= salt_pos
+ 8;
14462 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14463 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14464 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14465 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14466 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14468 digest
[0] -= SHA1M_A
;
14469 digest
[1] -= SHA1M_B
;
14470 digest
[2] -= SHA1M_C
;
14471 digest
[3] -= SHA1M_D
;
14472 digest
[4] -= SHA1M_E
;
14474 return (PARSER_OK
);
14477 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14479 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14481 u32
*digest
= (u32
*) hash_buf
->digest
;
14483 salt_t
*salt
= hash_buf
->salt
;
14485 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14486 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14487 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14488 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14490 digest
[0] = byte_swap_32 (digest
[0]);
14491 digest
[1] = byte_swap_32 (digest
[1]);
14492 digest
[2] = byte_swap_32 (digest
[2]);
14493 digest
[3] = byte_swap_32 (digest
[3]);
14495 digest
[0] -= MD5M_A
;
14496 digest
[1] -= MD5M_B
;
14497 digest
[2] -= MD5M_C
;
14498 digest
[3] -= MD5M_D
;
14500 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14502 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14504 u32
*salt_buf
= salt
->salt_buf
;
14506 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14507 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14508 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14509 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14511 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14512 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14513 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14514 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14516 salt
->salt_len
= 16 + 1;
14518 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14520 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14522 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14524 return (PARSER_OK
);
14527 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14529 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14531 u32
*digest
= (u32
*) hash_buf
->digest
;
14533 salt_t
*salt
= hash_buf
->salt
;
14535 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14541 char *hashbuf_pos
= input_buf
;
14543 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14545 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14547 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14549 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14553 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14555 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14557 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14559 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14563 char *databuf_pos
= strchr (iteration_pos
, ':');
14565 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14567 const uint iteration_len
= databuf_pos
- iteration_pos
;
14569 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14570 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14572 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14574 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14575 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14581 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14582 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14583 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14584 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14585 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14586 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14587 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14588 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14592 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14594 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14596 const char p0
= saltbuf_pos
[i
+ 0];
14597 const char p1
= saltbuf_pos
[i
+ 1];
14599 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14600 | hex_convert (p0
) << 4;
14603 salt
->salt_buf
[4] = 0x01000000;
14604 salt
->salt_buf
[5] = 0x80;
14606 salt
->salt_len
= saltbuf_len
/ 2;
14610 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14614 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14616 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14618 const char p0
= databuf_pos
[i
+ 0];
14619 const char p1
= databuf_pos
[i
+ 1];
14621 *databuf_ptr
++ = hex_convert (p1
) << 0
14622 | hex_convert (p0
) << 4;
14625 *databuf_ptr
++ = 0x80;
14627 for (uint i
= 0; i
< 512; i
++)
14629 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14632 cloudkey
->data_len
= databuf_len
/ 2;
14634 return (PARSER_OK
);
14637 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14639 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14641 u32
*digest
= (u32
*) hash_buf
->digest
;
14643 salt_t
*salt
= hash_buf
->salt
;
14649 char *hashbuf_pos
= input_buf
;
14651 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14653 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14655 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14657 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14661 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14663 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14665 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14667 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14669 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14673 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14675 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14677 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14679 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14681 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14685 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14687 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14688 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14690 // ok, the plan for this algorithm is the following:
14691 // we have 2 salts here, the domain-name and a random salt
14692 // while both are used in the initial transformation,
14693 // only the random salt is used in the following iterations
14694 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14695 // and one that includes only the real salt (stored into salt_buf[]).
14696 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14698 u8 tmp_buf
[100] = { 0 };
14700 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14702 memcpy (digest
, tmp_buf
, 20);
14704 digest
[0] = byte_swap_32 (digest
[0]);
14705 digest
[1] = byte_swap_32 (digest
[1]);
14706 digest
[2] = byte_swap_32 (digest
[2]);
14707 digest
[3] = byte_swap_32 (digest
[3]);
14708 digest
[4] = byte_swap_32 (digest
[4]);
14712 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14714 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14716 char *len_ptr
= NULL
;
14718 for (uint i
= 0; i
< domainbuf_len
; i
++)
14720 if (salt_buf_pc_ptr
[i
] == '.')
14722 len_ptr
= &salt_buf_pc_ptr
[i
];
14732 salt
->salt_buf_pc
[7] = domainbuf_len
;
14736 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14738 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14740 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14742 salt
->salt_len
= salt_len
;
14746 salt
->salt_iter
= atoi (iteration_pos
);
14748 return (PARSER_OK
);
14751 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14753 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14755 u32
*digest
= (u32
*) hash_buf
->digest
;
14757 salt_t
*salt
= hash_buf
->salt
;
14759 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14760 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14761 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14762 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14763 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14765 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14767 uint salt_len
= input_len
- 40 - 1;
14769 char *salt_buf
= input_buf
+ 40 + 1;
14771 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14773 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14775 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14777 salt
->salt_len
= salt_len
;
14779 return (PARSER_OK
);
14782 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14784 const u8 ascii_to_ebcdic
[] =
14786 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14787 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14788 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14789 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14790 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14791 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14792 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14793 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14794 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14795 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14796 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14797 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14798 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14799 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14800 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14801 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14804 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14806 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14808 u32
*digest
= (u32
*) hash_buf
->digest
;
14810 salt_t
*salt
= hash_buf
->salt
;
14812 char *salt_pos
= input_buf
+ 6 + 1;
14814 char *digest_pos
= strchr (salt_pos
, '*');
14816 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14818 uint salt_len
= digest_pos
- salt_pos
;
14820 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14822 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14824 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14828 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14829 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14831 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14833 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14835 salt
->salt_len
= salt_len
;
14837 for (uint i
= 0; i
< salt_len
; i
++)
14839 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14841 for (uint i
= salt_len
; i
< 8; i
++)
14843 salt_buf_pc_ptr
[i
] = 0x40;
14848 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14850 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14851 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14853 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14854 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14856 digest
[0] = byte_swap_32 (digest
[0]);
14857 digest
[1] = byte_swap_32 (digest
[1]);
14859 IP (digest
[0], digest
[1], tt
);
14861 digest
[0] = rotr32 (digest
[0], 29);
14862 digest
[1] = rotr32 (digest
[1], 29);
14866 return (PARSER_OK
);
14869 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14871 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14873 u32
*digest
= (u32
*) hash_buf
->digest
;
14875 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14876 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14877 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14878 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14880 digest
[0] = byte_swap_32 (digest
[0]);
14881 digest
[1] = byte_swap_32 (digest
[1]);
14882 digest
[2] = byte_swap_32 (digest
[2]);
14883 digest
[3] = byte_swap_32 (digest
[3]);
14885 return (PARSER_OK
);
14888 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14890 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14892 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14894 u32
*digest
= (u32
*) hash_buf
->digest
;
14896 salt_t
*salt
= hash_buf
->salt
;
14898 u8 tmp_buf
[120] = { 0 };
14900 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14902 tmp_buf
[3] += -4; // dont ask!
14904 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14906 salt
->salt_len
= 5;
14908 memcpy (digest
, tmp_buf
+ 5, 9);
14910 // yes, only 9 byte are needed to crack, but 10 to display
14912 salt
->salt_buf_pc
[7] = input_buf
[20];
14914 return (PARSER_OK
);
14917 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14919 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14921 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14923 u32
*digest
= (u32
*) hash_buf
->digest
;
14925 salt_t
*salt
= hash_buf
->salt
;
14927 u8 tmp_buf
[120] = { 0 };
14929 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14931 tmp_buf
[3] += -4; // dont ask!
14935 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14937 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)
14941 char tmp_iter_buf
[11] = { 0 };
14943 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14945 tmp_iter_buf
[10] = 0;
14947 salt
->salt_iter
= atoi (tmp_iter_buf
);
14949 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14951 return (PARSER_SALT_ITERATION
);
14954 salt
->salt_iter
--; // first round in init
14956 // 2 additional bytes for display only
14958 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14959 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14963 memcpy (digest
, tmp_buf
+ 28, 8);
14965 digest
[0] = byte_swap_32 (digest
[0]);
14966 digest
[1] = byte_swap_32 (digest
[1]);
14970 return (PARSER_OK
);
14973 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14975 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14977 u32
*digest
= (u32
*) hash_buf
->digest
;
14979 salt_t
*salt
= hash_buf
->salt
;
14981 char *salt_buf_pos
= input_buf
;
14983 char *hash_buf_pos
= salt_buf_pos
+ 6;
14985 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14986 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14987 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14988 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14989 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14990 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14991 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14992 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14994 digest
[0] -= SHA256M_A
;
14995 digest
[1] -= SHA256M_B
;
14996 digest
[2] -= SHA256M_C
;
14997 digest
[3] -= SHA256M_D
;
14998 digest
[4] -= SHA256M_E
;
14999 digest
[5] -= SHA256M_F
;
15000 digest
[6] -= SHA256M_G
;
15001 digest
[7] -= SHA256M_H
;
15003 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15005 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15007 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15009 salt
->salt_len
= salt_len
;
15011 return (PARSER_OK
);
15014 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15016 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15018 u32
*digest
= (u32
*) hash_buf
->digest
;
15020 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15022 salt_t
*salt
= hash_buf
->salt
;
15024 char *salt_buf
= input_buf
+ 6;
15026 char *digest_buf
= strchr (salt_buf
, '$');
15028 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15030 uint salt_len
= digest_buf
- salt_buf
;
15032 digest_buf
++; // skip the '$' symbol
15034 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15036 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15038 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15040 salt
->salt_len
= salt_len
;
15042 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15043 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15044 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15045 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15047 digest
[0] = byte_swap_32 (digest
[0]);
15048 digest
[1] = byte_swap_32 (digest
[1]);
15049 digest
[2] = byte_swap_32 (digest
[2]);
15050 digest
[3] = byte_swap_32 (digest
[3]);
15052 digest
[0] -= MD5M_A
;
15053 digest
[1] -= MD5M_B
;
15054 digest
[2] -= MD5M_C
;
15055 digest
[3] -= MD5M_D
;
15057 return (PARSER_OK
);
15060 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15062 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15064 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15066 u32
*digest
= (u32
*) hash_buf
->digest
;
15068 salt_t
*salt
= hash_buf
->salt
;
15070 char *salt_buf
= input_buf
+ 3;
15072 char *digest_buf
= strchr (salt_buf
, '$');
15074 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15076 uint salt_len
= digest_buf
- salt_buf
;
15078 digest_buf
++; // skip the '$' symbol
15080 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15082 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15084 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15086 salt_buf_ptr
[salt_len
] = 0x2d;
15088 salt
->salt_len
= salt_len
+ 1;
15090 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15091 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15092 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15093 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15095 digest
[0] = byte_swap_32 (digest
[0]);
15096 digest
[1] = byte_swap_32 (digest
[1]);
15097 digest
[2] = byte_swap_32 (digest
[2]);
15098 digest
[3] = byte_swap_32 (digest
[3]);
15100 digest
[0] -= MD5M_A
;
15101 digest
[1] -= MD5M_B
;
15102 digest
[2] -= MD5M_C
;
15103 digest
[3] -= MD5M_D
;
15105 return (PARSER_OK
);
15108 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15110 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15112 u32
*digest
= (u32
*) hash_buf
->digest
;
15114 salt_t
*salt
= hash_buf
->salt
;
15116 u8 tmp_buf
[100] = { 0 };
15118 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15120 memcpy (digest
, tmp_buf
, 20);
15122 digest
[0] = byte_swap_32 (digest
[0]);
15123 digest
[1] = byte_swap_32 (digest
[1]);
15124 digest
[2] = byte_swap_32 (digest
[2]);
15125 digest
[3] = byte_swap_32 (digest
[3]);
15126 digest
[4] = byte_swap_32 (digest
[4]);
15128 digest
[0] -= SHA1M_A
;
15129 digest
[1] -= SHA1M_B
;
15130 digest
[2] -= SHA1M_C
;
15131 digest
[3] -= SHA1M_D
;
15132 digest
[4] -= SHA1M_E
;
15134 salt
->salt_buf
[0] = 0x80;
15136 salt
->salt_len
= 0;
15138 return (PARSER_OK
);
15141 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15143 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15145 u32
*digest
= (u32
*) hash_buf
->digest
;
15147 salt_t
*salt
= hash_buf
->salt
;
15149 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15150 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15151 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15152 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15154 digest
[0] = byte_swap_32 (digest
[0]);
15155 digest
[1] = byte_swap_32 (digest
[1]);
15156 digest
[2] = byte_swap_32 (digest
[2]);
15157 digest
[3] = byte_swap_32 (digest
[3]);
15159 digest
[0] -= MD5M_A
;
15160 digest
[1] -= MD5M_B
;
15161 digest
[2] -= MD5M_C
;
15162 digest
[3] -= MD5M_D
;
15164 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15166 uint salt_len
= input_len
- 32 - 1;
15168 char *salt_buf
= input_buf
+ 32 + 1;
15170 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15172 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15174 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15177 * add static "salt" part
15180 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15184 salt
->salt_len
= salt_len
;
15186 return (PARSER_OK
);
15189 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15191 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15193 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15195 u32
*digest
= (u32
*) hash_buf
->digest
;
15197 salt_t
*salt
= hash_buf
->salt
;
15199 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15205 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15207 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15209 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15211 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15213 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15217 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15219 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15221 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15223 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15227 char *keybuf_pos
= strchr (keylen_pos
, '$');
15229 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15231 uint keylen_len
= keybuf_pos
- keylen_pos
;
15233 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15237 char *databuf_pos
= strchr (keybuf_pos
, '$');
15239 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15241 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15243 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15247 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15249 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15255 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15256 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15257 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15258 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15260 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15261 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15262 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15263 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15265 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15266 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15267 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15268 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15270 salt
->salt_len
= 16;
15271 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15273 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15275 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15278 return (PARSER_OK
);
15281 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15283 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15285 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15287 u32
*digest
= (u32
*) hash_buf
->digest
;
15289 salt_t
*salt
= hash_buf
->salt
;
15295 // first is the N salt parameter
15297 char *N_pos
= input_buf
+ 6;
15299 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15303 salt
->scrypt_N
= atoi (N_pos
);
15307 char *r_pos
= strchr (N_pos
, ':');
15309 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15313 salt
->scrypt_r
= atoi (r_pos
);
15317 char *p_pos
= strchr (r_pos
, ':');
15319 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15323 salt
->scrypt_p
= atoi (p_pos
);
15327 char *saltbuf_pos
= strchr (p_pos
, ':');
15329 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15333 char *hash_pos
= strchr (saltbuf_pos
, ':');
15335 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15341 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15343 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15345 u8 tmp_buf
[33] = { 0 };
15347 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15349 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15351 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15353 salt
->salt_len
= tmp_len
;
15354 salt
->salt_iter
= 1;
15356 // digest - base64 decode
15358 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15360 tmp_len
= input_len
- (hash_pos
- input_buf
);
15362 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15364 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15366 memcpy (digest
, tmp_buf
, 32);
15368 return (PARSER_OK
);
15371 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15373 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15375 u32
*digest
= (u32
*) hash_buf
->digest
;
15377 salt_t
*salt
= hash_buf
->salt
;
15383 char decrypted
[76] = { 0 }; // iv + hash
15385 juniper_decrypt_hash (input_buf
, decrypted
);
15387 char *md5crypt_hash
= decrypted
+ 12;
15389 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15391 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15393 char *salt_pos
= md5crypt_hash
+ 3;
15395 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15397 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15399 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15403 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15405 return (PARSER_OK
);
15408 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15410 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15412 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15414 u32
*digest
= (u32
*) hash_buf
->digest
;
15416 salt_t
*salt
= hash_buf
->salt
;
15418 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15424 // first is *raw* salt
15426 char *salt_pos
= input_buf
+ 3;
15428 char *hash_pos
= strchr (salt_pos
, '$');
15430 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15432 uint salt_len
= hash_pos
- salt_pos
;
15434 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15438 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15440 memcpy (salt_buf_ptr
, salt_pos
, 14);
15442 salt_buf_ptr
[17] = 0x01;
15443 salt_buf_ptr
[18] = 0x80;
15445 // add some stuff to normal salt to make sorted happy
15447 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15448 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15449 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15450 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15452 salt
->salt_len
= salt_len
;
15453 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15455 // base64 decode hash
15457 u8 tmp_buf
[100] = { 0 };
15459 uint hash_len
= input_len
- 3 - salt_len
- 1;
15461 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15463 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15465 memcpy (digest
, tmp_buf
, 32);
15467 digest
[0] = byte_swap_32 (digest
[0]);
15468 digest
[1] = byte_swap_32 (digest
[1]);
15469 digest
[2] = byte_swap_32 (digest
[2]);
15470 digest
[3] = byte_swap_32 (digest
[3]);
15471 digest
[4] = byte_swap_32 (digest
[4]);
15472 digest
[5] = byte_swap_32 (digest
[5]);
15473 digest
[6] = byte_swap_32 (digest
[6]);
15474 digest
[7] = byte_swap_32 (digest
[7]);
15476 return (PARSER_OK
);
15479 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15481 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15483 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15485 u32
*digest
= (u32
*) hash_buf
->digest
;
15487 salt_t
*salt
= hash_buf
->salt
;
15493 // first is *raw* salt
15495 char *salt_pos
= input_buf
+ 3;
15497 char *hash_pos
= strchr (salt_pos
, '$');
15499 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15501 uint salt_len
= hash_pos
- salt_pos
;
15503 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15505 salt
->salt_len
= salt_len
;
15508 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15510 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15511 salt_buf_ptr
[salt_len
] = 0;
15513 // base64 decode hash
15515 u8 tmp_buf
[100] = { 0 };
15517 uint hash_len
= input_len
- 3 - salt_len
- 1;
15519 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15521 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15523 memcpy (digest
, tmp_buf
, 32);
15526 salt
->scrypt_N
= 16384;
15527 salt
->scrypt_r
= 1;
15528 salt
->scrypt_p
= 1;
15529 salt
->salt_iter
= 1;
15531 return (PARSER_OK
);
15534 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15536 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15538 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15540 u32
*digest
= (u32
*) hash_buf
->digest
;
15542 salt_t
*salt
= hash_buf
->salt
;
15544 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15550 char *version_pos
= input_buf
+ 8 + 1;
15552 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15554 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15556 u32 version_len
= verifierHashSize_pos
- version_pos
;
15558 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15560 verifierHashSize_pos
++;
15562 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15564 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15566 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15568 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15572 char *saltSize_pos
= strchr (keySize_pos
, '*');
15574 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15576 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15578 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15582 char *osalt_pos
= strchr (saltSize_pos
, '*');
15584 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15586 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15588 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15592 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15594 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15596 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15598 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15600 encryptedVerifier_pos
++;
15602 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15604 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15606 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15608 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15610 encryptedVerifierHash_pos
++;
15612 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;
15614 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15616 const uint version
= atoi (version_pos
);
15618 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15620 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15622 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15624 const uint keySize
= atoi (keySize_pos
);
15626 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15628 office2007
->keySize
= keySize
;
15630 const uint saltSize
= atoi (saltSize_pos
);
15632 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15638 salt
->salt_len
= 16;
15639 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15641 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15642 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15643 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15644 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15650 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15651 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15652 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15653 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15655 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15656 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15657 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15658 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15659 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15665 digest
[0] = office2007
->encryptedVerifierHash
[0];
15666 digest
[1] = office2007
->encryptedVerifierHash
[1];
15667 digest
[2] = office2007
->encryptedVerifierHash
[2];
15668 digest
[3] = office2007
->encryptedVerifierHash
[3];
15670 return (PARSER_OK
);
15673 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15675 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15677 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15679 u32
*digest
= (u32
*) hash_buf
->digest
;
15681 salt_t
*salt
= hash_buf
->salt
;
15683 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15689 char *version_pos
= input_buf
+ 8 + 1;
15691 char *spinCount_pos
= strchr (version_pos
, '*');
15693 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15695 u32 version_len
= spinCount_pos
- version_pos
;
15697 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15701 char *keySize_pos
= strchr (spinCount_pos
, '*');
15703 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15705 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15707 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15711 char *saltSize_pos
= strchr (keySize_pos
, '*');
15713 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15715 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15717 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15721 char *osalt_pos
= strchr (saltSize_pos
, '*');
15723 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15725 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15727 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15731 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15733 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15735 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15737 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15739 encryptedVerifier_pos
++;
15741 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15743 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15745 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15747 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15749 encryptedVerifierHash_pos
++;
15751 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;
15753 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15755 const uint version
= atoi (version_pos
);
15757 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15759 const uint spinCount
= atoi (spinCount_pos
);
15761 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15763 const uint keySize
= atoi (keySize_pos
);
15765 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15767 const uint saltSize
= atoi (saltSize_pos
);
15769 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15775 salt
->salt_len
= 16;
15776 salt
->salt_iter
= spinCount
;
15778 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15779 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15780 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15781 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15787 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15788 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15789 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15790 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15792 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15793 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15794 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15795 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15796 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15797 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15798 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15799 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15805 digest
[0] = office2010
->encryptedVerifierHash
[0];
15806 digest
[1] = office2010
->encryptedVerifierHash
[1];
15807 digest
[2] = office2010
->encryptedVerifierHash
[2];
15808 digest
[3] = office2010
->encryptedVerifierHash
[3];
15810 return (PARSER_OK
);
15813 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15815 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15817 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15819 u32
*digest
= (u32
*) hash_buf
->digest
;
15821 salt_t
*salt
= hash_buf
->salt
;
15823 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15829 char *version_pos
= input_buf
+ 8 + 1;
15831 char *spinCount_pos
= strchr (version_pos
, '*');
15833 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15835 u32 version_len
= spinCount_pos
- version_pos
;
15837 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15841 char *keySize_pos
= strchr (spinCount_pos
, '*');
15843 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15845 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15847 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15851 char *saltSize_pos
= strchr (keySize_pos
, '*');
15853 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15855 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15857 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15861 char *osalt_pos
= strchr (saltSize_pos
, '*');
15863 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15865 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15867 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15871 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15873 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15875 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15877 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15879 encryptedVerifier_pos
++;
15881 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15883 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15885 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15887 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15889 encryptedVerifierHash_pos
++;
15891 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;
15893 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15895 const uint version
= atoi (version_pos
);
15897 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15899 const uint spinCount
= atoi (spinCount_pos
);
15901 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15903 const uint keySize
= atoi (keySize_pos
);
15905 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15907 const uint saltSize
= atoi (saltSize_pos
);
15909 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15915 salt
->salt_len
= 16;
15916 salt
->salt_iter
= spinCount
;
15918 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15919 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15920 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15921 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15927 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15928 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15929 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15930 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15932 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15933 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15934 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15935 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15936 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15937 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15938 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15939 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15945 digest
[0] = office2013
->encryptedVerifierHash
[0];
15946 digest
[1] = office2013
->encryptedVerifierHash
[1];
15947 digest
[2] = office2013
->encryptedVerifierHash
[2];
15948 digest
[3] = office2013
->encryptedVerifierHash
[3];
15950 return (PARSER_OK
);
15953 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15955 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15957 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15959 u32
*digest
= (u32
*) hash_buf
->digest
;
15961 salt_t
*salt
= hash_buf
->salt
;
15963 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15969 char *version_pos
= input_buf
+ 11;
15971 char *osalt_pos
= strchr (version_pos
, '*');
15973 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15975 u32 version_len
= osalt_pos
- version_pos
;
15977 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15981 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15983 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15985 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15987 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15989 encryptedVerifier_pos
++;
15991 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15993 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15995 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15997 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15999 encryptedVerifierHash_pos
++;
16001 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16003 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16005 const uint version
= *version_pos
- 0x30;
16007 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16013 oldoffice01
->version
= version
;
16015 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16016 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16017 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16018 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16020 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16021 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16022 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16023 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16025 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16026 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16027 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16028 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16030 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16031 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16032 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16033 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16039 salt
->salt_len
= 16;
16041 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16042 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16043 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16044 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16046 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16047 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16048 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16049 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16051 // this is a workaround as office produces multiple documents with the same salt
16053 salt
->salt_len
+= 32;
16055 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16056 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16057 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16058 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16059 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16060 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16061 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16062 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16068 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16069 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16070 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16071 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16073 return (PARSER_OK
);
16076 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16078 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16081 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16083 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16085 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16087 u32
*digest
= (u32
*) hash_buf
->digest
;
16089 salt_t
*salt
= hash_buf
->salt
;
16091 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16097 char *version_pos
= input_buf
+ 11;
16099 char *osalt_pos
= strchr (version_pos
, '*');
16101 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16103 u32 version_len
= osalt_pos
- version_pos
;
16105 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16109 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16111 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16113 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16115 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16117 encryptedVerifier_pos
++;
16119 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16121 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16123 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16125 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16127 encryptedVerifierHash_pos
++;
16129 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16131 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16133 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16135 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16139 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16141 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16143 const uint version
= *version_pos
- 0x30;
16145 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16151 oldoffice01
->version
= version
;
16153 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16154 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16155 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16156 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16158 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16159 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16160 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16161 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16163 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16164 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16165 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16166 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16168 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16169 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16170 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16171 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16173 oldoffice01
->rc4key
[1] = 0;
16174 oldoffice01
->rc4key
[0] = 0;
16176 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16177 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16178 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16179 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16180 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16181 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16182 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16183 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16184 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16185 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16187 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16188 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16194 salt
->salt_len
= 16;
16196 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16197 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16198 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16199 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16201 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16202 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16203 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16204 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16206 // this is a workaround as office produces multiple documents with the same salt
16208 salt
->salt_len
+= 32;
16210 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16211 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16212 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16213 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16214 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16215 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16216 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16217 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16223 digest
[0] = oldoffice01
->rc4key
[0];
16224 digest
[1] = oldoffice01
->rc4key
[1];
16228 return (PARSER_OK
);
16231 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16233 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16235 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16237 u32
*digest
= (u32
*) hash_buf
->digest
;
16239 salt_t
*salt
= hash_buf
->salt
;
16241 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16247 char *version_pos
= input_buf
+ 11;
16249 char *osalt_pos
= strchr (version_pos
, '*');
16251 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16253 u32 version_len
= osalt_pos
- version_pos
;
16255 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16259 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16261 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16263 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16265 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16267 encryptedVerifier_pos
++;
16269 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16271 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16273 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16275 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16277 encryptedVerifierHash_pos
++;
16279 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16281 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16283 const uint version
= *version_pos
- 0x30;
16285 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16291 oldoffice34
->version
= version
;
16293 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16294 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16295 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16296 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16298 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16299 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16300 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16301 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16303 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16304 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16305 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16306 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16307 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16309 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16310 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16311 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16312 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16313 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16319 salt
->salt_len
= 16;
16321 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16322 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16323 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16324 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16326 // this is a workaround as office produces multiple documents with the same salt
16328 salt
->salt_len
+= 32;
16330 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16331 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16332 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16333 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16334 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16335 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16336 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16337 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16343 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16344 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16345 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16346 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16348 return (PARSER_OK
);
16351 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16353 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16355 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16358 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16360 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16362 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16364 u32
*digest
= (u32
*) hash_buf
->digest
;
16366 salt_t
*salt
= hash_buf
->salt
;
16368 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16374 char *version_pos
= input_buf
+ 11;
16376 char *osalt_pos
= strchr (version_pos
, '*');
16378 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16380 u32 version_len
= osalt_pos
- version_pos
;
16382 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16386 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16388 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16390 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16392 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16394 encryptedVerifier_pos
++;
16396 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16398 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16400 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16402 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16404 encryptedVerifierHash_pos
++;
16406 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16408 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16410 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16412 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16416 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16418 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16420 const uint version
= *version_pos
- 0x30;
16422 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16428 oldoffice34
->version
= version
;
16430 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16431 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16432 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16433 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16435 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16436 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16437 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16438 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16440 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16441 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16442 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16443 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16444 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16446 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16447 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16448 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16449 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16450 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16452 oldoffice34
->rc4key
[1] = 0;
16453 oldoffice34
->rc4key
[0] = 0;
16455 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16456 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16457 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16458 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16459 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16460 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16461 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16462 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16463 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16464 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16466 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16467 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16473 salt
->salt_len
= 16;
16475 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16476 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16477 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16478 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16480 // this is a workaround as office produces multiple documents with the same salt
16482 salt
->salt_len
+= 32;
16484 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16485 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16486 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16487 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16488 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16489 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16490 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16491 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16497 digest
[0] = oldoffice34
->rc4key
[0];
16498 digest
[1] = oldoffice34
->rc4key
[1];
16502 return (PARSER_OK
);
16505 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16507 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16509 u32
*digest
= (u32
*) hash_buf
->digest
;
16511 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16512 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16513 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16514 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16516 digest
[0] = byte_swap_32 (digest
[0]);
16517 digest
[1] = byte_swap_32 (digest
[1]);
16518 digest
[2] = byte_swap_32 (digest
[2]);
16519 digest
[3] = byte_swap_32 (digest
[3]);
16521 return (PARSER_OK
);
16524 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16526 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16528 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16530 u32
*digest
= (u32
*) hash_buf
->digest
;
16532 salt_t
*salt
= hash_buf
->salt
;
16534 char *signature_pos
= input_buf
;
16536 char *salt_pos
= strchr (signature_pos
, '$');
16538 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16540 u32 signature_len
= salt_pos
- signature_pos
;
16542 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16546 char *hash_pos
= strchr (salt_pos
, '$');
16548 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16550 u32 salt_len
= hash_pos
- salt_pos
;
16552 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16556 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16558 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16560 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16561 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16562 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16563 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16564 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16566 digest
[0] -= SHA1M_A
;
16567 digest
[1] -= SHA1M_B
;
16568 digest
[2] -= SHA1M_C
;
16569 digest
[3] -= SHA1M_D
;
16570 digest
[4] -= SHA1M_E
;
16572 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16574 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16576 salt
->salt_len
= salt_len
;
16578 return (PARSER_OK
);
16581 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16583 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16585 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16587 u32
*digest
= (u32
*) hash_buf
->digest
;
16589 salt_t
*salt
= hash_buf
->salt
;
16591 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16597 char *iter_pos
= input_buf
+ 14;
16599 const int iter
= atoi (iter_pos
);
16601 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16603 salt
->salt_iter
= iter
- 1;
16605 char *salt_pos
= strchr (iter_pos
, '$');
16607 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16611 char *hash_pos
= strchr (salt_pos
, '$');
16613 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16615 const uint salt_len
= hash_pos
- salt_pos
;
16619 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16621 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16623 salt
->salt_len
= salt_len
;
16625 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16626 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16628 // add some stuff to normal salt to make sorted happy
16630 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16631 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16632 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16633 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16634 salt
->salt_buf
[4] = salt
->salt_iter
;
16636 // base64 decode hash
16638 u8 tmp_buf
[100] = { 0 };
16640 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16642 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16644 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16646 memcpy (digest
, tmp_buf
, 32);
16648 digest
[0] = byte_swap_32 (digest
[0]);
16649 digest
[1] = byte_swap_32 (digest
[1]);
16650 digest
[2] = byte_swap_32 (digest
[2]);
16651 digest
[3] = byte_swap_32 (digest
[3]);
16652 digest
[4] = byte_swap_32 (digest
[4]);
16653 digest
[5] = byte_swap_32 (digest
[5]);
16654 digest
[6] = byte_swap_32 (digest
[6]);
16655 digest
[7] = byte_swap_32 (digest
[7]);
16657 return (PARSER_OK
);
16660 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16662 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16664 u32
*digest
= (u32
*) hash_buf
->digest
;
16666 salt_t
*salt
= hash_buf
->salt
;
16668 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16669 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16673 digest
[0] = byte_swap_32 (digest
[0]);
16674 digest
[1] = byte_swap_32 (digest
[1]);
16676 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16677 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16678 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16680 char iter_c
= input_buf
[17];
16681 char iter_d
= input_buf
[19];
16683 // atm only defaults, let's see if there's more request
16684 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16685 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16687 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16689 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16690 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16691 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16692 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16694 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16695 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16696 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16697 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16699 salt
->salt_len
= 16;
16701 return (PARSER_OK
);
16704 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16706 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16708 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16710 u32
*digest
= (u32
*) hash_buf
->digest
;
16712 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16714 salt_t
*salt
= hash_buf
->salt
;
16716 char *salt_pos
= input_buf
+ 10;
16718 char *hash_pos
= strchr (salt_pos
, '$');
16720 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16722 uint salt_len
= hash_pos
- salt_pos
;
16726 uint hash_len
= input_len
- 10 - salt_len
- 1;
16728 // base64 decode salt
16730 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16732 u8 tmp_buf
[100] = { 0 };
16734 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16736 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16738 tmp_buf
[salt_len
] = 0x80;
16740 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16742 salt
->salt_len
= salt_len
;
16744 // base64 decode hash
16746 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16748 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16750 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16752 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16754 uint user_len
= hash_len
- 32;
16756 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16758 user_len
--; // skip the trailing space
16760 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16761 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16762 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16763 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16765 digest
[0] = byte_swap_32 (digest
[0]);
16766 digest
[1] = byte_swap_32 (digest
[1]);
16767 digest
[2] = byte_swap_32 (digest
[2]);
16768 digest
[3] = byte_swap_32 (digest
[3]);
16770 // store username for host only (output hash if cracked)
16772 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16773 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16775 return (PARSER_OK
);
16778 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16780 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16782 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16784 u32
*digest
= (u32
*) hash_buf
->digest
;
16786 salt_t
*salt
= hash_buf
->salt
;
16788 char *iter_pos
= input_buf
+ 10;
16790 u32 iter
= atoi (iter_pos
);
16794 return (PARSER_SALT_ITERATION
);
16797 iter
--; // first iteration is special
16799 salt
->salt_iter
= iter
;
16801 char *base64_pos
= strchr (iter_pos
, '}');
16803 if (base64_pos
== NULL
)
16805 return (PARSER_SIGNATURE_UNMATCHED
);
16810 // base64 decode salt
16812 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16814 u8 tmp_buf
[100] = { 0 };
16816 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16818 if (decoded_len
< 24)
16820 return (PARSER_SALT_LENGTH
);
16825 uint salt_len
= decoded_len
- 20;
16827 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16828 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16830 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16832 salt
->salt_len
= salt_len
;
16836 u32
*digest_ptr
= (u32
*) tmp_buf
;
16838 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16839 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16840 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16841 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16842 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16844 return (PARSER_OK
);
16847 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16849 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16851 u32
*digest
= (u32
*) hash_buf
->digest
;
16853 salt_t
*salt
= hash_buf
->salt
;
16855 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16856 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16857 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16858 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16859 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16861 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16863 uint salt_len
= input_len
- 40 - 1;
16865 char *salt_buf
= input_buf
+ 40 + 1;
16867 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16869 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16871 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16873 salt
->salt_len
= salt_len
;
16875 return (PARSER_OK
);
16878 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16880 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16882 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16884 u32
*digest
= (u32
*) hash_buf
->digest
;
16886 salt_t
*salt
= hash_buf
->salt
;
16888 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16894 char *V_pos
= input_buf
+ 5;
16896 char *R_pos
= strchr (V_pos
, '*');
16898 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16900 u32 V_len
= R_pos
- V_pos
;
16904 char *bits_pos
= strchr (R_pos
, '*');
16906 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16908 u32 R_len
= bits_pos
- R_pos
;
16912 char *P_pos
= strchr (bits_pos
, '*');
16914 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16916 u32 bits_len
= P_pos
- bits_pos
;
16920 char *enc_md_pos
= strchr (P_pos
, '*');
16922 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16924 u32 P_len
= enc_md_pos
- P_pos
;
16928 char *id_len_pos
= strchr (enc_md_pos
, '*');
16930 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16932 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16936 char *id_buf_pos
= strchr (id_len_pos
, '*');
16938 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16940 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16944 char *u_len_pos
= strchr (id_buf_pos
, '*');
16946 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16948 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16950 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16954 char *u_buf_pos
= strchr (u_len_pos
, '*');
16956 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16958 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16962 char *o_len_pos
= strchr (u_buf_pos
, '*');
16964 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16966 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16968 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16972 char *o_buf_pos
= strchr (o_len_pos
, '*');
16974 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16976 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16980 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;
16982 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16986 const int V
= atoi (V_pos
);
16987 const int R
= atoi (R_pos
);
16988 const int P
= atoi (P_pos
);
16990 if (V
!= 1) return (PARSER_SALT_VALUE
);
16991 if (R
!= 2) return (PARSER_SALT_VALUE
);
16993 const int enc_md
= atoi (enc_md_pos
);
16995 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16997 const int id_len
= atoi (id_len_pos
);
16998 const int u_len
= atoi (u_len_pos
);
16999 const int o_len
= atoi (o_len_pos
);
17001 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17002 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17003 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17005 const int bits
= atoi (bits_pos
);
17007 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17009 // copy data to esalt
17015 pdf
->enc_md
= enc_md
;
17017 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17018 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17019 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17020 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17021 pdf
->id_len
= id_len
;
17023 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17024 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17025 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17026 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17027 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17028 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17029 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17030 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17031 pdf
->u_len
= u_len
;
17033 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17034 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17035 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17036 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17037 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17038 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17039 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17040 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17041 pdf
->o_len
= o_len
;
17043 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17044 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17045 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17046 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17048 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17049 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17050 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17051 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17052 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17053 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17054 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17055 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17057 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17058 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17059 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17060 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17061 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17062 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17063 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17064 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17066 // we use ID for salt, maybe needs to change, we will see...
17068 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17069 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17070 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17071 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17072 salt
->salt_len
= pdf
->id_len
;
17074 digest
[0] = pdf
->u_buf
[0];
17075 digest
[1] = pdf
->u_buf
[1];
17076 digest
[2] = pdf
->u_buf
[2];
17077 digest
[3] = pdf
->u_buf
[3];
17079 return (PARSER_OK
);
17082 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17084 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17087 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17089 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17091 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17093 u32
*digest
= (u32
*) hash_buf
->digest
;
17095 salt_t
*salt
= hash_buf
->salt
;
17097 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17103 char *V_pos
= input_buf
+ 5;
17105 char *R_pos
= strchr (V_pos
, '*');
17107 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17109 u32 V_len
= R_pos
- V_pos
;
17113 char *bits_pos
= strchr (R_pos
, '*');
17115 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17117 u32 R_len
= bits_pos
- R_pos
;
17121 char *P_pos
= strchr (bits_pos
, '*');
17123 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17125 u32 bits_len
= P_pos
- bits_pos
;
17129 char *enc_md_pos
= strchr (P_pos
, '*');
17131 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17133 u32 P_len
= enc_md_pos
- P_pos
;
17137 char *id_len_pos
= strchr (enc_md_pos
, '*');
17139 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17141 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17145 char *id_buf_pos
= strchr (id_len_pos
, '*');
17147 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17149 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17153 char *u_len_pos
= strchr (id_buf_pos
, '*');
17155 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17157 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17159 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17163 char *u_buf_pos
= strchr (u_len_pos
, '*');
17165 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17167 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17171 char *o_len_pos
= strchr (u_buf_pos
, '*');
17173 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17175 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17177 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17181 char *o_buf_pos
= strchr (o_len_pos
, '*');
17183 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17185 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17189 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17191 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17193 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17195 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17199 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;
17201 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17205 const int V
= atoi (V_pos
);
17206 const int R
= atoi (R_pos
);
17207 const int P
= atoi (P_pos
);
17209 if (V
!= 1) return (PARSER_SALT_VALUE
);
17210 if (R
!= 2) return (PARSER_SALT_VALUE
);
17212 const int enc_md
= atoi (enc_md_pos
);
17214 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17216 const int id_len
= atoi (id_len_pos
);
17217 const int u_len
= atoi (u_len_pos
);
17218 const int o_len
= atoi (o_len_pos
);
17220 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17221 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17222 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17224 const int bits
= atoi (bits_pos
);
17226 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17228 // copy data to esalt
17234 pdf
->enc_md
= enc_md
;
17236 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17237 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17238 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17239 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17240 pdf
->id_len
= id_len
;
17242 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17243 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17244 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17245 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17246 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17247 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17248 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17249 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17250 pdf
->u_len
= u_len
;
17252 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17253 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17254 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17255 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17256 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17257 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17258 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17259 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17260 pdf
->o_len
= o_len
;
17262 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17263 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17264 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17265 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17267 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17268 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17269 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17270 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17271 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17272 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17273 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17274 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17276 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17277 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17278 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17279 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17280 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17281 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17282 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17283 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17285 pdf
->rc4key
[1] = 0;
17286 pdf
->rc4key
[0] = 0;
17288 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17289 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17290 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17291 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17292 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17293 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17294 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17295 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17296 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17297 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17299 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17300 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17302 // we use ID for salt, maybe needs to change, we will see...
17304 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17305 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17306 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17307 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17308 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17309 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17310 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17311 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17312 salt
->salt_len
= pdf
->id_len
+ 16;
17314 digest
[0] = pdf
->rc4key
[0];
17315 digest
[1] = pdf
->rc4key
[1];
17319 return (PARSER_OK
);
17322 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17324 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17326 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17328 u32
*digest
= (u32
*) hash_buf
->digest
;
17330 salt_t
*salt
= hash_buf
->salt
;
17332 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17338 char *V_pos
= input_buf
+ 5;
17340 char *R_pos
= strchr (V_pos
, '*');
17342 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17344 u32 V_len
= R_pos
- V_pos
;
17348 char *bits_pos
= strchr (R_pos
, '*');
17350 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17352 u32 R_len
= bits_pos
- R_pos
;
17356 char *P_pos
= strchr (bits_pos
, '*');
17358 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17360 u32 bits_len
= P_pos
- bits_pos
;
17364 char *enc_md_pos
= strchr (P_pos
, '*');
17366 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17368 u32 P_len
= enc_md_pos
- P_pos
;
17372 char *id_len_pos
= strchr (enc_md_pos
, '*');
17374 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17376 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17380 char *id_buf_pos
= strchr (id_len_pos
, '*');
17382 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17384 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17388 char *u_len_pos
= strchr (id_buf_pos
, '*');
17390 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17392 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17394 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17398 char *u_buf_pos
= strchr (u_len_pos
, '*');
17400 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17402 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17406 char *o_len_pos
= strchr (u_buf_pos
, '*');
17408 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17410 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17412 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17416 char *o_buf_pos
= strchr (o_len_pos
, '*');
17418 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17420 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17424 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;
17426 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17430 const int V
= atoi (V_pos
);
17431 const int R
= atoi (R_pos
);
17432 const int P
= atoi (P_pos
);
17436 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17437 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17439 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17441 const int id_len
= atoi (id_len_pos
);
17442 const int u_len
= atoi (u_len_pos
);
17443 const int o_len
= atoi (o_len_pos
);
17445 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17447 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17448 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17450 const int bits
= atoi (bits_pos
);
17452 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17458 enc_md
= atoi (enc_md_pos
);
17461 // copy data to esalt
17467 pdf
->enc_md
= enc_md
;
17469 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17470 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17471 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17472 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17476 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17477 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17478 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17479 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17482 pdf
->id_len
= id_len
;
17484 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17485 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17486 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17487 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17488 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17489 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17490 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17491 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17492 pdf
->u_len
= u_len
;
17494 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17495 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17496 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17497 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17498 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17499 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17500 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17501 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17502 pdf
->o_len
= o_len
;
17504 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17505 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17506 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17507 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17511 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17512 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17513 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17514 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17517 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17518 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17519 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17520 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17521 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17522 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17523 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17524 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17526 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17527 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17528 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17529 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17530 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17531 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17532 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17533 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17535 // precompute rc4 data for later use
17551 uint salt_pc_block
[32] = { 0 };
17553 char *salt_pc_ptr
= (char *) salt_pc_block
;
17555 memcpy (salt_pc_ptr
, padding
, 32);
17556 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17558 uint salt_pc_digest
[4] = { 0 };
17560 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17562 pdf
->rc4data
[0] = salt_pc_digest
[0];
17563 pdf
->rc4data
[1] = salt_pc_digest
[1];
17565 // we use ID for salt, maybe needs to change, we will see...
17567 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17568 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17569 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17570 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17571 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17572 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17573 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17574 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17575 salt
->salt_len
= pdf
->id_len
+ 16;
17577 salt
->salt_iter
= ROUNDS_PDF14
;
17579 digest
[0] = pdf
->u_buf
[0];
17580 digest
[1] = pdf
->u_buf
[1];
17584 return (PARSER_OK
);
17587 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17589 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17591 if (ret
!= PARSER_OK
)
17596 u32
*digest
= (u32
*) hash_buf
->digest
;
17598 salt_t
*salt
= hash_buf
->salt
;
17600 digest
[0] -= SHA256M_A
;
17601 digest
[1] -= SHA256M_B
;
17602 digest
[2] -= SHA256M_C
;
17603 digest
[3] -= SHA256M_D
;
17604 digest
[4] -= SHA256M_E
;
17605 digest
[5] -= SHA256M_F
;
17606 digest
[6] -= SHA256M_G
;
17607 digest
[7] -= SHA256M_H
;
17609 salt
->salt_buf
[2] = 0x80;
17611 return (PARSER_OK
);
17614 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17616 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17618 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17620 u32
*digest
= (u32
*) hash_buf
->digest
;
17622 salt_t
*salt
= hash_buf
->salt
;
17624 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17630 char *V_pos
= input_buf
+ 5;
17632 char *R_pos
= strchr (V_pos
, '*');
17634 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17636 u32 V_len
= R_pos
- V_pos
;
17640 char *bits_pos
= strchr (R_pos
, '*');
17642 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17644 u32 R_len
= bits_pos
- R_pos
;
17648 char *P_pos
= strchr (bits_pos
, '*');
17650 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17652 u32 bits_len
= P_pos
- bits_pos
;
17656 char *enc_md_pos
= strchr (P_pos
, '*');
17658 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17660 u32 P_len
= enc_md_pos
- P_pos
;
17664 char *id_len_pos
= strchr (enc_md_pos
, '*');
17666 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17668 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17672 char *id_buf_pos
= strchr (id_len_pos
, '*');
17674 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17676 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17680 char *u_len_pos
= strchr (id_buf_pos
, '*');
17682 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17684 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17688 char *u_buf_pos
= strchr (u_len_pos
, '*');
17690 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17692 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17696 char *o_len_pos
= strchr (u_buf_pos
, '*');
17698 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17700 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17704 char *o_buf_pos
= strchr (o_len_pos
, '*');
17706 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17708 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17712 char *last
= strchr (o_buf_pos
, '*');
17714 if (last
== NULL
) last
= input_buf
+ input_len
;
17716 u32 o_buf_len
= last
- o_buf_pos
;
17720 const int V
= atoi (V_pos
);
17721 const int R
= atoi (R_pos
);
17725 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17726 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17728 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17730 const int bits
= atoi (bits_pos
);
17732 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17734 int enc_md
= atoi (enc_md_pos
);
17736 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17738 const uint id_len
= atoi (id_len_pos
);
17739 const uint u_len
= atoi (u_len_pos
);
17740 const uint o_len
= atoi (o_len_pos
);
17742 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17743 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17744 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17745 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17746 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17747 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17748 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17749 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17751 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17752 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17753 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17755 // copy data to esalt
17757 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17759 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17761 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17764 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17765 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17767 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17768 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17770 salt
->salt_len
= 8;
17771 salt
->salt_iter
= ROUNDS_PDF17L8
;
17773 digest
[0] = pdf
->u_buf
[0];
17774 digest
[1] = pdf
->u_buf
[1];
17775 digest
[2] = pdf
->u_buf
[2];
17776 digest
[3] = pdf
->u_buf
[3];
17777 digest
[4] = pdf
->u_buf
[4];
17778 digest
[5] = pdf
->u_buf
[5];
17779 digest
[6] = pdf
->u_buf
[6];
17780 digest
[7] = pdf
->u_buf
[7];
17782 return (PARSER_OK
);
17785 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17787 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17789 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17791 u32
*digest
= (u32
*) hash_buf
->digest
;
17793 salt_t
*salt
= hash_buf
->salt
;
17795 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17803 char *iter_pos
= input_buf
+ 7;
17805 u32 iter
= atoi (iter_pos
);
17807 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17808 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17810 // first is *raw* salt
17812 char *salt_pos
= strchr (iter_pos
, ':');
17814 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17818 char *hash_pos
= strchr (salt_pos
, ':');
17820 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17822 u32 salt_len
= hash_pos
- salt_pos
;
17824 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17828 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17830 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17834 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17836 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17838 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17840 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17841 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17843 salt
->salt_len
= salt_len
;
17844 salt
->salt_iter
= iter
- 1;
17848 u8 tmp_buf
[100] = { 0 };
17850 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17852 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17854 memcpy (digest
, tmp_buf
, 16);
17856 digest
[0] = byte_swap_32 (digest
[0]);
17857 digest
[1] = byte_swap_32 (digest
[1]);
17858 digest
[2] = byte_swap_32 (digest
[2]);
17859 digest
[3] = byte_swap_32 (digest
[3]);
17861 // add some stuff to normal salt to make sorted happy
17863 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17864 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17865 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17866 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17867 salt
->salt_buf
[4] = salt
->salt_iter
;
17869 return (PARSER_OK
);
17872 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17874 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17876 u32
*digest
= (u32
*) hash_buf
->digest
;
17878 salt_t
*salt
= hash_buf
->salt
;
17880 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17881 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17882 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17883 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17885 digest
[0] = byte_swap_32 (digest
[0]);
17886 digest
[1] = byte_swap_32 (digest
[1]);
17887 digest
[2] = byte_swap_32 (digest
[2]);
17888 digest
[3] = byte_swap_32 (digest
[3]);
17890 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17892 uint salt_len
= input_len
- 32 - 1;
17894 char *salt_buf
= input_buf
+ 32 + 1;
17896 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17898 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17900 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17902 salt
->salt_len
= salt_len
;
17904 return (PARSER_OK
);
17907 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17909 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17911 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17913 u32
*digest
= (u32
*) hash_buf
->digest
;
17915 salt_t
*salt
= hash_buf
->salt
;
17917 char *user_pos
= input_buf
+ 10;
17919 char *salt_pos
= strchr (user_pos
, '*');
17921 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17925 char *hash_pos
= strchr (salt_pos
, '*');
17929 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17931 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17933 uint user_len
= salt_pos
- user_pos
- 1;
17935 uint salt_len
= hash_pos
- salt_pos
- 1;
17937 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17943 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17944 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17945 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17946 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17948 digest
[0] = byte_swap_32 (digest
[0]);
17949 digest
[1] = byte_swap_32 (digest
[1]);
17950 digest
[2] = byte_swap_32 (digest
[2]);
17951 digest
[3] = byte_swap_32 (digest
[3]);
17953 digest
[0] -= MD5M_A
;
17954 digest
[1] -= MD5M_B
;
17955 digest
[2] -= MD5M_C
;
17956 digest
[3] -= MD5M_D
;
17962 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17964 // first 4 bytes are the "challenge"
17966 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17967 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17968 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17969 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17971 // append the user name
17973 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17975 salt
->salt_len
= 4 + user_len
;
17977 return (PARSER_OK
);
17980 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17982 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17984 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17986 u32
*digest
= (u32
*) hash_buf
->digest
;
17988 salt_t
*salt
= hash_buf
->salt
;
17990 char *salt_pos
= input_buf
+ 9;
17992 char *hash_pos
= strchr (salt_pos
, '*');
17994 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17998 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18000 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18002 uint salt_len
= hash_pos
- salt_pos
- 1;
18004 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18010 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18011 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18012 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18013 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18014 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18020 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18022 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18024 salt
->salt_len
= salt_len
;
18026 return (PARSER_OK
);
18029 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18031 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18033 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18035 u32
*digest
= (u32
*) hash_buf
->digest
;
18037 salt_t
*salt
= hash_buf
->salt
;
18039 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18045 char *cry_master_len_pos
= input_buf
+ 9;
18047 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18049 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18051 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18053 cry_master_buf_pos
++;
18055 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18057 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18059 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18061 cry_salt_len_pos
++;
18063 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18065 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18067 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18069 cry_salt_buf_pos
++;
18071 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18073 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18075 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18079 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18081 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18083 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18087 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18089 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18091 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18095 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18097 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18099 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18101 public_key_len_pos
++;
18103 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18105 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18107 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18109 public_key_buf_pos
++;
18111 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;
18113 const uint cry_master_len
= atoi (cry_master_len_pos
);
18114 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18115 const uint ckey_len
= atoi (ckey_len_pos
);
18116 const uint public_key_len
= atoi (public_key_len_pos
);
18118 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18119 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18120 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18121 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18123 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18125 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18127 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18130 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18132 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18134 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18137 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18139 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18141 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18144 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18145 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18146 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18149 * store digest (should be unique enought, hopefully)
18152 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18153 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18154 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18155 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18161 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18163 const uint cry_rounds
= atoi (cry_rounds_pos
);
18165 salt
->salt_iter
= cry_rounds
- 1;
18167 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18169 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18171 salt
->salt_len
= salt_len
;
18173 return (PARSER_OK
);
18176 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18178 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18180 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18182 u32
*digest
= (u32
*) hash_buf
->digest
;
18184 salt_t
*salt
= hash_buf
->salt
;
18186 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18188 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18190 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18192 memcpy (temp_input_buf
, input_buf
, input_len
);
18196 char *URI_server_pos
= temp_input_buf
+ 6;
18198 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18200 if (URI_client_pos
== NULL
)
18202 myfree (temp_input_buf
);
18204 return (PARSER_SEPARATOR_UNMATCHED
);
18207 URI_client_pos
[0] = 0;
18210 uint URI_server_len
= strlen (URI_server_pos
);
18212 if (URI_server_len
> 512)
18214 myfree (temp_input_buf
);
18216 return (PARSER_SALT_LENGTH
);
18221 char *user_pos
= strchr (URI_client_pos
, '*');
18223 if (user_pos
== NULL
)
18225 myfree (temp_input_buf
);
18227 return (PARSER_SEPARATOR_UNMATCHED
);
18233 uint URI_client_len
= strlen (URI_client_pos
);
18235 if (URI_client_len
> 512)
18237 myfree (temp_input_buf
);
18239 return (PARSER_SALT_LENGTH
);
18244 char *realm_pos
= strchr (user_pos
, '*');
18246 if (realm_pos
== NULL
)
18248 myfree (temp_input_buf
);
18250 return (PARSER_SEPARATOR_UNMATCHED
);
18256 uint user_len
= strlen (user_pos
);
18258 if (user_len
> 116)
18260 myfree (temp_input_buf
);
18262 return (PARSER_SALT_LENGTH
);
18267 char *method_pos
= strchr (realm_pos
, '*');
18269 if (method_pos
== NULL
)
18271 myfree (temp_input_buf
);
18273 return (PARSER_SEPARATOR_UNMATCHED
);
18279 uint realm_len
= strlen (realm_pos
);
18281 if (realm_len
> 116)
18283 myfree (temp_input_buf
);
18285 return (PARSER_SALT_LENGTH
);
18290 char *URI_prefix_pos
= strchr (method_pos
, '*');
18292 if (URI_prefix_pos
== NULL
)
18294 myfree (temp_input_buf
);
18296 return (PARSER_SEPARATOR_UNMATCHED
);
18299 URI_prefix_pos
[0] = 0;
18302 uint method_len
= strlen (method_pos
);
18304 if (method_len
> 246)
18306 myfree (temp_input_buf
);
18308 return (PARSER_SALT_LENGTH
);
18313 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18315 if (URI_resource_pos
== NULL
)
18317 myfree (temp_input_buf
);
18319 return (PARSER_SEPARATOR_UNMATCHED
);
18322 URI_resource_pos
[0] = 0;
18323 URI_resource_pos
++;
18325 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18327 if (URI_prefix_len
> 245)
18329 myfree (temp_input_buf
);
18331 return (PARSER_SALT_LENGTH
);
18336 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18338 if (URI_suffix_pos
== NULL
)
18340 myfree (temp_input_buf
);
18342 return (PARSER_SEPARATOR_UNMATCHED
);
18345 URI_suffix_pos
[0] = 0;
18348 uint URI_resource_len
= strlen (URI_resource_pos
);
18350 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18352 myfree (temp_input_buf
);
18354 return (PARSER_SALT_LENGTH
);
18359 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18361 if (nonce_pos
== NULL
)
18363 myfree (temp_input_buf
);
18365 return (PARSER_SEPARATOR_UNMATCHED
);
18371 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18373 if (URI_suffix_len
> 245)
18375 myfree (temp_input_buf
);
18377 return (PARSER_SALT_LENGTH
);
18382 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18384 if (nonce_client_pos
== NULL
)
18386 myfree (temp_input_buf
);
18388 return (PARSER_SEPARATOR_UNMATCHED
);
18391 nonce_client_pos
[0] = 0;
18392 nonce_client_pos
++;
18394 uint nonce_len
= strlen (nonce_pos
);
18396 if (nonce_len
< 1 || nonce_len
> 50)
18398 myfree (temp_input_buf
);
18400 return (PARSER_SALT_LENGTH
);
18405 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18407 if (nonce_count_pos
== NULL
)
18409 myfree (temp_input_buf
);
18411 return (PARSER_SEPARATOR_UNMATCHED
);
18414 nonce_count_pos
[0] = 0;
18417 uint nonce_client_len
= strlen (nonce_client_pos
);
18419 if (nonce_client_len
> 50)
18421 myfree (temp_input_buf
);
18423 return (PARSER_SALT_LENGTH
);
18428 char *qop_pos
= strchr (nonce_count_pos
, '*');
18430 if (qop_pos
== NULL
)
18432 myfree (temp_input_buf
);
18434 return (PARSER_SEPARATOR_UNMATCHED
);
18440 uint nonce_count_len
= strlen (nonce_count_pos
);
18442 if (nonce_count_len
> 50)
18444 myfree (temp_input_buf
);
18446 return (PARSER_SALT_LENGTH
);
18451 char *directive_pos
= strchr (qop_pos
, '*');
18453 if (directive_pos
== NULL
)
18455 myfree (temp_input_buf
);
18457 return (PARSER_SEPARATOR_UNMATCHED
);
18460 directive_pos
[0] = 0;
18463 uint qop_len
= strlen (qop_pos
);
18467 myfree (temp_input_buf
);
18469 return (PARSER_SALT_LENGTH
);
18474 char *digest_pos
= strchr (directive_pos
, '*');
18476 if (digest_pos
== NULL
)
18478 myfree (temp_input_buf
);
18480 return (PARSER_SEPARATOR_UNMATCHED
);
18486 uint directive_len
= strlen (directive_pos
);
18488 if (directive_len
!= 3)
18490 myfree (temp_input_buf
);
18492 return (PARSER_SALT_LENGTH
);
18495 if (memcmp (directive_pos
, "MD5", 3))
18497 log_info ("ERROR: only the MD5 directive is currently supported\n");
18499 myfree (temp_input_buf
);
18501 return (PARSER_SIP_AUTH_DIRECTIVE
);
18505 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18510 uint md5_max_len
= 4 * 64;
18512 uint md5_remaining_len
= md5_max_len
;
18514 uint tmp_md5_buf
[64] = { 0 };
18516 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18518 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18520 md5_len
+= method_len
+ 1;
18521 tmp_md5_ptr
+= method_len
+ 1;
18523 if (URI_prefix_len
> 0)
18525 md5_remaining_len
= md5_max_len
- md5_len
;
18527 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18529 md5_len
+= URI_prefix_len
+ 1;
18530 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18533 md5_remaining_len
= md5_max_len
- md5_len
;
18535 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18537 md5_len
+= URI_resource_len
;
18538 tmp_md5_ptr
+= URI_resource_len
;
18540 if (URI_suffix_len
> 0)
18542 md5_remaining_len
= md5_max_len
- md5_len
;
18544 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18546 md5_len
+= 1 + URI_suffix_len
;
18549 uint tmp_digest
[4] = { 0 };
18551 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18553 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18554 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18555 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18556 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18562 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18564 uint esalt_len
= 0;
18566 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18568 // there are 2 possibilities for the esalt:
18570 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18572 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18574 if (esalt_len
> max_esalt_len
)
18576 myfree (temp_input_buf
);
18578 return (PARSER_SALT_LENGTH
);
18581 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18593 esalt_len
= 1 + nonce_len
+ 1 + 32;
18595 if (esalt_len
> max_esalt_len
)
18597 myfree (temp_input_buf
);
18599 return (PARSER_SALT_LENGTH
);
18602 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18610 // add 0x80 to esalt
18612 esalt_buf_ptr
[esalt_len
] = 0x80;
18614 sip
->esalt_len
= esalt_len
;
18620 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18622 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18624 uint max_salt_len
= 119;
18626 if (salt_len
> max_salt_len
)
18628 myfree (temp_input_buf
);
18630 return (PARSER_SALT_LENGTH
);
18633 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18635 sip
->salt_len
= salt_len
;
18638 * fake salt (for sorting)
18641 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18645 uint fake_salt_len
= salt_len
;
18647 if (fake_salt_len
> max_salt_len
)
18649 fake_salt_len
= max_salt_len
;
18652 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18654 salt
->salt_len
= fake_salt_len
;
18660 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18661 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18662 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18663 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18665 digest
[0] = byte_swap_32 (digest
[0]);
18666 digest
[1] = byte_swap_32 (digest
[1]);
18667 digest
[2] = byte_swap_32 (digest
[2]);
18668 digest
[3] = byte_swap_32 (digest
[3]);
18670 myfree (temp_input_buf
);
18672 return (PARSER_OK
);
18675 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18677 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18679 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18681 u32
*digest
= (u32
*) hash_buf
->digest
;
18683 salt_t
*salt
= hash_buf
->salt
;
18687 char *digest_pos
= input_buf
;
18689 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18696 char *salt_buf
= input_buf
+ 8 + 1;
18700 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18702 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18704 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18706 salt
->salt_len
= salt_len
;
18708 return (PARSER_OK
);
18711 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18713 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18715 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18717 u32
*digest
= (u32
*) hash_buf
->digest
;
18719 salt_t
*salt
= hash_buf
->salt
;
18721 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18727 char *p_buf_pos
= input_buf
+ 4;
18729 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18731 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18733 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18735 NumCyclesPower_pos
++;
18737 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18739 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18741 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18745 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18747 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18749 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18753 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18755 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18757 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18761 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18763 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18765 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18769 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18771 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18773 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18777 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18779 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18781 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18785 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18787 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18789 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18793 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18795 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18797 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18801 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;
18803 const uint iter
= atoi (NumCyclesPower_pos
);
18804 const uint crc
= atoi (crc_buf_pos
);
18805 const uint p_buf
= atoi (p_buf_pos
);
18806 const uint salt_len
= atoi (salt_len_pos
);
18807 const uint iv_len
= atoi (iv_len_pos
);
18808 const uint unpack_size
= atoi (unpack_size_pos
);
18809 const uint data_len
= atoi (data_len_pos
);
18815 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18816 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18818 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18820 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18822 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18828 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18829 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18830 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18831 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18833 seven_zip
->iv_len
= iv_len
;
18835 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18837 seven_zip
->salt_len
= 0;
18839 seven_zip
->crc
= crc
;
18841 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18843 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18845 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18848 seven_zip
->data_len
= data_len
;
18850 seven_zip
->unpack_size
= unpack_size
;
18854 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18855 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18856 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18857 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18859 salt
->salt_len
= 16;
18861 salt
->salt_sign
[0] = iter
;
18863 salt
->salt_iter
= 1 << iter
;
18874 return (PARSER_OK
);
18877 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18879 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18881 u32
*digest
= (u32
*) hash_buf
->digest
;
18883 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18884 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18885 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18886 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18887 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18888 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18889 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18890 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18892 digest
[0] = byte_swap_32 (digest
[0]);
18893 digest
[1] = byte_swap_32 (digest
[1]);
18894 digest
[2] = byte_swap_32 (digest
[2]);
18895 digest
[3] = byte_swap_32 (digest
[3]);
18896 digest
[4] = byte_swap_32 (digest
[4]);
18897 digest
[5] = byte_swap_32 (digest
[5]);
18898 digest
[6] = byte_swap_32 (digest
[6]);
18899 digest
[7] = byte_swap_32 (digest
[7]);
18901 return (PARSER_OK
);
18904 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18906 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18908 u32
*digest
= (u32
*) hash_buf
->digest
;
18910 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18911 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18912 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18913 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18914 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18915 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18916 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18917 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18918 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18919 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18920 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18921 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18922 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18923 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18924 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18925 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18927 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18928 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18929 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18930 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18931 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18932 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18933 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18934 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18935 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18936 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18937 digest
[10] = byte_swap_32 (digest
[10]);
18938 digest
[11] = byte_swap_32 (digest
[11]);
18939 digest
[12] = byte_swap_32 (digest
[12]);
18940 digest
[13] = byte_swap_32 (digest
[13]);
18941 digest
[14] = byte_swap_32 (digest
[14]);
18942 digest
[15] = byte_swap_32 (digest
[15]);
18944 return (PARSER_OK
);
18947 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18949 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18951 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18953 u32
*digest
= (u32
*) hash_buf
->digest
;
18955 salt_t
*salt
= hash_buf
->salt
;
18957 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18965 char *iter_pos
= input_buf
+ 4;
18967 u32 iter
= atoi (iter_pos
);
18969 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18970 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18972 // first is *raw* salt
18974 char *salt_pos
= strchr (iter_pos
, ':');
18976 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18980 char *hash_pos
= strchr (salt_pos
, ':');
18982 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18984 u32 salt_len
= hash_pos
- salt_pos
;
18986 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18990 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18992 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18996 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18998 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19000 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19002 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19003 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19005 salt
->salt_len
= salt_len
;
19006 salt
->salt_iter
= iter
- 1;
19010 u8 tmp_buf
[100] = { 0 };
19012 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19014 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19016 memcpy (digest
, tmp_buf
, 16);
19018 // add some stuff to normal salt to make sorted happy
19020 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19021 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19022 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19023 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19024 salt
->salt_buf
[4] = salt
->salt_iter
;
19026 return (PARSER_OK
);
19029 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19031 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19033 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19035 u32
*digest
= (u32
*) hash_buf
->digest
;
19037 salt_t
*salt
= hash_buf
->salt
;
19039 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19047 char *iter_pos
= input_buf
+ 5;
19049 u32 iter
= atoi (iter_pos
);
19051 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19052 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19054 // first is *raw* salt
19056 char *salt_pos
= strchr (iter_pos
, ':');
19058 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19062 char *hash_pos
= strchr (salt_pos
, ':');
19064 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19066 u32 salt_len
= hash_pos
- salt_pos
;
19068 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19072 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19074 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19078 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19080 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19082 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19084 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19085 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19087 salt
->salt_len
= salt_len
;
19088 salt
->salt_iter
= iter
- 1;
19092 u8 tmp_buf
[100] = { 0 };
19094 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19096 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19098 memcpy (digest
, tmp_buf
, 16);
19100 digest
[0] = byte_swap_32 (digest
[0]);
19101 digest
[1] = byte_swap_32 (digest
[1]);
19102 digest
[2] = byte_swap_32 (digest
[2]);
19103 digest
[3] = byte_swap_32 (digest
[3]);
19105 // add some stuff to normal salt to make sorted happy
19107 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19108 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19109 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19110 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19111 salt
->salt_buf
[4] = salt
->salt_iter
;
19113 return (PARSER_OK
);
19116 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19118 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19120 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19122 u64
*digest
= (u64
*) hash_buf
->digest
;
19124 salt_t
*salt
= hash_buf
->salt
;
19126 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19134 char *iter_pos
= input_buf
+ 7;
19136 u32 iter
= atoi (iter_pos
);
19138 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19139 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19141 // first is *raw* salt
19143 char *salt_pos
= strchr (iter_pos
, ':');
19145 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19149 char *hash_pos
= strchr (salt_pos
, ':');
19151 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19153 u32 salt_len
= hash_pos
- salt_pos
;
19155 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19159 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19161 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19165 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19167 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19169 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19171 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19172 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19174 salt
->salt_len
= salt_len
;
19175 salt
->salt_iter
= iter
- 1;
19179 u8 tmp_buf
[100] = { 0 };
19181 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19183 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19185 memcpy (digest
, tmp_buf
, 64);
19187 digest
[0] = byte_swap_64 (digest
[0]);
19188 digest
[1] = byte_swap_64 (digest
[1]);
19189 digest
[2] = byte_swap_64 (digest
[2]);
19190 digest
[3] = byte_swap_64 (digest
[3]);
19191 digest
[4] = byte_swap_64 (digest
[4]);
19192 digest
[5] = byte_swap_64 (digest
[5]);
19193 digest
[6] = byte_swap_64 (digest
[6]);
19194 digest
[7] = byte_swap_64 (digest
[7]);
19196 // add some stuff to normal salt to make sorted happy
19198 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19199 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19200 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19201 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19202 salt
->salt_buf
[4] = salt
->salt_iter
;
19204 return (PARSER_OK
);
19207 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19209 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19211 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19213 uint
*digest
= (uint
*) hash_buf
->digest
;
19215 salt_t
*salt
= hash_buf
->salt
;
19221 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19223 char *hash_pos
= strchr (salt_pos
, '$');
19225 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19227 u32 salt_len
= hash_pos
- salt_pos
;
19229 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19233 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19235 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19239 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19240 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19258 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19259 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19261 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19262 salt
->salt_len
= 8;
19264 return (PARSER_OK
);
19267 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19269 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19271 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19273 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19275 if (c19
& 3) return (PARSER_HASH_VALUE
);
19277 salt_t
*salt
= hash_buf
->salt
;
19279 u32
*digest
= (u32
*) hash_buf
->digest
;
19283 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19284 | itoa64_to_int (input_buf
[2]) << 6
19285 | itoa64_to_int (input_buf
[3]) << 12
19286 | itoa64_to_int (input_buf
[4]) << 18;
19290 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19291 | itoa64_to_int (input_buf
[6]) << 6
19292 | itoa64_to_int (input_buf
[7]) << 12
19293 | itoa64_to_int (input_buf
[8]) << 18;
19295 salt
->salt_len
= 4;
19297 u8 tmp_buf
[100] = { 0 };
19299 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19301 memcpy (digest
, tmp_buf
, 8);
19305 IP (digest
[0], digest
[1], tt
);
19307 digest
[0] = rotr32 (digest
[0], 31);
19308 digest
[1] = rotr32 (digest
[1], 31);
19312 return (PARSER_OK
);
19315 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19317 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19319 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19321 u32
*digest
= (u32
*) hash_buf
->digest
;
19323 salt_t
*salt
= hash_buf
->salt
;
19329 char *type_pos
= input_buf
+ 6 + 1;
19331 char *salt_pos
= strchr (type_pos
, '*');
19333 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19335 u32 type_len
= salt_pos
- type_pos
;
19337 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19341 char *crypted_pos
= strchr (salt_pos
, '*');
19343 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19345 u32 salt_len
= crypted_pos
- salt_pos
;
19347 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19351 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19353 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19359 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19360 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19362 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19363 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19365 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19366 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19367 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19368 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19370 salt
->salt_len
= 24;
19371 salt
->salt_iter
= ROUNDS_RAR3
;
19373 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19374 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19376 digest
[0] = 0xc43d7b00;
19377 digest
[1] = 0x40070000;
19381 return (PARSER_OK
);
19384 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19386 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19388 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19390 u32
*digest
= (u32
*) hash_buf
->digest
;
19392 salt_t
*salt
= hash_buf
->salt
;
19394 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19400 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19402 char *param1_pos
= strchr (param0_pos
, '$');
19404 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19406 u32 param0_len
= param1_pos
- param0_pos
;
19410 char *param2_pos
= strchr (param1_pos
, '$');
19412 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19414 u32 param1_len
= param2_pos
- param1_pos
;
19418 char *param3_pos
= strchr (param2_pos
, '$');
19420 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19422 u32 param2_len
= param3_pos
- param2_pos
;
19426 char *param4_pos
= strchr (param3_pos
, '$');
19428 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19430 u32 param3_len
= param4_pos
- param3_pos
;
19434 char *param5_pos
= strchr (param4_pos
, '$');
19436 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19438 u32 param4_len
= param5_pos
- param4_pos
;
19442 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19444 char *salt_buf
= param1_pos
;
19445 char *iv
= param3_pos
;
19446 char *pswcheck
= param5_pos
;
19448 const uint salt_len
= atoi (param0_pos
);
19449 const uint iterations
= atoi (param2_pos
);
19450 const uint pswcheck_len
= atoi (param4_pos
);
19456 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19457 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19458 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19460 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19461 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19462 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19468 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19469 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19470 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19471 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19473 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19474 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19475 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19476 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19478 salt
->salt_len
= 16;
19480 salt
->salt_sign
[0] = iterations
;
19482 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19488 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19489 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19493 return (PARSER_OK
);
19496 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19498 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19500 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19502 u32
*digest
= (u32
*) hash_buf
->digest
;
19504 salt_t
*salt
= hash_buf
->salt
;
19506 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19513 char *account_pos
= input_buf
+ 11 + 1;
19519 if (account_pos
[0] == '*')
19523 data_pos
= strchr (account_pos
, '*');
19528 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19530 uint account_len
= data_pos
- account_pos
+ 1;
19532 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19537 data_len
= input_len
- 11 - 1 - account_len
- 2;
19539 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19543 /* assume $krb5tgs$23$checksum$edata2 */
19544 data_pos
= account_pos
;
19546 memcpy (krb5tgs
->account_info
, "**", 3);
19548 data_len
= input_len
- 11 - 1 - 1;
19551 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19553 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19555 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19557 const char p0
= data_pos
[i
+ 0];
19558 const char p1
= data_pos
[i
+ 1];
19560 *checksum_ptr
++ = hex_convert (p1
) << 0
19561 | hex_convert (p0
) << 4;
19564 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19566 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19569 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19571 const char p0
= data_pos
[i
+ 0];
19572 const char p1
= data_pos
[i
+ 1];
19573 *edata_ptr
++ = hex_convert (p1
) << 0
19574 | hex_convert (p0
) << 4;
19577 /* this is needed for hmac_md5 */
19578 *edata_ptr
++ = 0x80;
19580 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19581 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19582 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19583 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19585 salt
->salt_len
= 32;
19587 digest
[0] = krb5tgs
->checksum
[0];
19588 digest
[1] = krb5tgs
->checksum
[1];
19589 digest
[2] = krb5tgs
->checksum
[2];
19590 digest
[3] = krb5tgs
->checksum
[3];
19592 return (PARSER_OK
);
19595 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19597 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19599 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19601 u32
*digest
= (u32
*) hash_buf
->digest
;
19603 salt_t
*salt
= hash_buf
->salt
;
19610 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19614 char *wrapped_key_pos
;
19618 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19620 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19622 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19624 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19629 data_pos
= salt_pos
;
19631 wrapped_key_pos
= strchr (salt_pos
, '*');
19633 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19635 uint salt_len
= wrapped_key_pos
- salt_pos
;
19637 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19642 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19644 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19646 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19647 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19648 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19649 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19653 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19654 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19655 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19656 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19657 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19658 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19660 salt
->salt_len
= 40;
19662 digest
[0] = salt
->salt_buf
[0];
19663 digest
[1] = salt
->salt_buf
[1];
19664 digest
[2] = salt
->salt_buf
[2];
19665 digest
[3] = salt
->salt_buf
[3];
19667 return (PARSER_OK
);
19670 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19672 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19674 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19676 u32
*digest
= (u32
*) hash_buf
->digest
;
19678 salt_t
*salt
= hash_buf
->salt
;
19680 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19690 char *algorithm_pos
;
19692 char *final_random_seed_pos
;
19693 u32 final_random_seed_len
;
19695 char *transf_random_seed_pos
;
19696 u32 transf_random_seed_len
;
19701 /* default is no keyfile provided */
19702 char *keyfile_len_pos
;
19703 u32 keyfile_len
= 0;
19704 u32 is_keyfile_present
= 0;
19705 char *keyfile_inline_pos
;
19708 /* specific to version 1 */
19709 char *contents_len_pos
;
19711 char *contents_pos
;
19713 /* specific to version 2 */
19714 char *expected_bytes_pos
;
19715 u32 expected_bytes_len
;
19717 char *contents_hash_pos
;
19718 u32 contents_hash_len
;
19720 version_pos
= input_buf
+ 8 + 1 + 1;
19722 keepass
->version
= atoi (version_pos
);
19724 rounds_pos
= strchr (version_pos
, '*');
19726 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19730 salt
->salt_iter
= (atoi (rounds_pos
));
19732 algorithm_pos
= strchr (rounds_pos
, '*');
19734 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19738 keepass
->algorithm
= atoi (algorithm_pos
);
19740 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19742 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19744 final_random_seed_pos
++;
19746 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19747 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19748 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19749 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19751 if (keepass
->version
== 2)
19753 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19754 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19755 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19756 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19759 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19761 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19763 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19765 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19766 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19768 transf_random_seed_pos
++;
19770 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19771 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19772 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19773 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19774 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19775 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19776 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19777 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19779 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19781 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19783 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19785 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19789 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19790 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19791 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19792 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19794 if (keepass
->version
== 1)
19796 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19798 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19800 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19802 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19804 contents_hash_pos
++;
19806 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19807 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19808 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19809 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19810 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19811 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19812 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19813 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19815 /* get length of contents following */
19816 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19818 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19820 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19822 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19826 u32 inline_flag
= atoi (inline_flag_pos
);
19828 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19830 contents_len_pos
= strchr (inline_flag_pos
, '*');
19832 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19834 contents_len_pos
++;
19836 contents_len
= atoi (contents_len_pos
);
19838 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19840 contents_pos
= strchr (contents_len_pos
, '*');
19842 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19848 keepass
->contents_len
= contents_len
;
19850 contents_len
= contents_len
/ 4;
19852 keyfile_inline_pos
= strchr (contents_pos
, '*');
19854 u32 real_contents_len
;
19856 if (keyfile_inline_pos
== NULL
)
19857 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19860 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19861 keyfile_inline_pos
++;
19862 is_keyfile_present
= 1;
19865 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19867 for (i
= 0; i
< contents_len
; i
++)
19868 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19870 else if (keepass
->version
== 2)
19872 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19874 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19876 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19878 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19880 expected_bytes_pos
++;
19882 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19883 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19884 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19885 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19886 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19887 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19888 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19889 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19891 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19893 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19895 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19897 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19899 contents_hash_pos
++;
19901 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19902 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19903 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19904 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19905 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19906 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19907 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19908 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19910 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19912 if (keyfile_inline_pos
== NULL
)
19913 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19916 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19917 keyfile_inline_pos
++;
19918 is_keyfile_present
= 1;
19920 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19923 if (is_keyfile_present
!= 0)
19925 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19929 keyfile_len
= atoi (keyfile_len_pos
);
19931 keepass
->keyfile_len
= keyfile_len
;
19933 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19935 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19937 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19941 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19943 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19945 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19946 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19947 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19948 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19949 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19950 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19951 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19952 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19955 digest
[0] = keepass
->enc_iv
[0];
19956 digest
[1] = keepass
->enc_iv
[1];
19957 digest
[2] = keepass
->enc_iv
[2];
19958 digest
[3] = keepass
->enc_iv
[3];
19960 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19961 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19962 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19963 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19964 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19965 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19966 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19967 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19969 return (PARSER_OK
);
19972 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19974 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19976 u32
*digest
= (u32
*) hash_buf
->digest
;
19978 salt_t
*salt
= hash_buf
->salt
;
19980 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19981 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19982 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19983 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19984 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19985 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19986 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19987 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19989 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19991 uint salt_len
= input_len
- 64 - 1;
19993 char *salt_buf
= input_buf
+ 64 + 1;
19995 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
19997 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
19999 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20001 salt
->salt_len
= salt_len
;
20004 * we can precompute the first sha256 transform
20007 uint w
[16] = { 0 };
20009 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20010 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20011 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20012 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20013 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20014 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20015 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20016 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20017 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20018 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20019 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20020 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20021 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20022 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20023 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20024 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20026 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20028 sha256_64 (w
, pc256
);
20030 salt
->salt_buf_pc
[0] = pc256
[0];
20031 salt
->salt_buf_pc
[1] = pc256
[1];
20032 salt
->salt_buf_pc
[2] = pc256
[2];
20033 salt
->salt_buf_pc
[3] = pc256
[3];
20034 salt
->salt_buf_pc
[4] = pc256
[4];
20035 salt
->salt_buf_pc
[5] = pc256
[5];
20036 salt
->salt_buf_pc
[6] = pc256
[6];
20037 salt
->salt_buf_pc
[7] = pc256
[7];
20039 digest
[0] -= pc256
[0];
20040 digest
[1] -= pc256
[1];
20041 digest
[2] -= pc256
[2];
20042 digest
[3] -= pc256
[3];
20043 digest
[4] -= pc256
[4];
20044 digest
[5] -= pc256
[5];
20045 digest
[6] -= pc256
[6];
20046 digest
[7] -= pc256
[7];
20048 return (PARSER_OK
);
20051 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20053 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20055 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20057 u32
*digest
= (u32
*) hash_buf
->digest
;
20059 salt_t
*salt
= hash_buf
->salt
;
20065 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20067 char *data_buf_pos
= strchr (data_len_pos
, '$');
20069 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20071 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20073 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20074 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20078 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20080 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20082 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20084 u32 data_len
= atoi (data_len_pos
);
20086 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20092 char *salt_pos
= data_buf_pos
;
20094 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20095 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20096 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20097 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20099 // this is actually the CT, which is also the hash later (if matched)
20101 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20102 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20103 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20104 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20106 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20108 salt
->salt_iter
= 10 - 1;
20114 digest
[0] = salt
->salt_buf
[4];
20115 digest
[1] = salt
->salt_buf
[5];
20116 digest
[2] = salt
->salt_buf
[6];
20117 digest
[3] = salt
->salt_buf
[7];
20119 return (PARSER_OK
);
20122 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20124 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20126 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20128 u32
*digest
= (u32
*) hash_buf
->digest
;
20130 salt_t
*salt
= hash_buf
->salt
;
20136 char *salt_pos
= input_buf
+ 11 + 1;
20138 char *iter_pos
= strchr (salt_pos
, ',');
20140 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20142 u32 salt_len
= iter_pos
- salt_pos
;
20144 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20148 char *hash_pos
= strchr (iter_pos
, ',');
20150 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20152 u32 iter_len
= hash_pos
- iter_pos
;
20154 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20158 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20160 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20166 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20167 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20168 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20169 salt
->salt_buf
[3] = 0x00018000;
20171 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20172 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20173 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20174 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20176 salt
->salt_len
= salt_len
/ 2;
20178 salt
->salt_iter
= atoi (iter_pos
) - 1;
20184 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20185 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20186 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20187 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20188 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20189 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20190 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20191 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20193 return (PARSER_OK
);
20196 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20198 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20200 u32
*digest
= (u32
*) hash_buf
->digest
;
20202 salt_t
*salt
= hash_buf
->salt
;
20208 char *hash_pos
= input_buf
+ 64;
20209 char *salt1_pos
= input_buf
+ 128;
20210 char *salt2_pos
= input_buf
;
20216 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20217 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20218 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20219 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20221 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20222 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20223 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20224 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20226 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20227 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20228 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20229 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20231 salt
->salt_len
= 48;
20233 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20239 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20240 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20241 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20242 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20243 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20244 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20245 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20246 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20248 return (PARSER_OK
);
20251 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20253 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20255 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20256 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20258 u32
*digest
= (u32
*) hash_buf
->digest
;
20260 salt_t
*salt
= hash_buf
->salt
;
20262 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20268 char *param0_pos
= input_buf
+ 6 + 1;
20270 char *param1_pos
= strchr (param0_pos
, '*');
20272 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20274 u32 param0_len
= param1_pos
- param0_pos
;
20278 char *param2_pos
= strchr (param1_pos
, '*');
20280 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20282 u32 param1_len
= param2_pos
- param1_pos
;
20286 char *param3_pos
= strchr (param2_pos
, '*');
20288 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20290 u32 param2_len
= param3_pos
- param2_pos
;
20294 char *param4_pos
= strchr (param3_pos
, '*');
20296 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20298 u32 param3_len
= param4_pos
- param3_pos
;
20302 char *param5_pos
= strchr (param4_pos
, '*');
20304 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20306 u32 param4_len
= param5_pos
- param4_pos
;
20310 char *param6_pos
= strchr (param5_pos
, '*');
20312 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20314 u32 param5_len
= param6_pos
- param5_pos
;
20318 char *param7_pos
= strchr (param6_pos
, '*');
20320 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20322 u32 param6_len
= param7_pos
- param6_pos
;
20326 char *param8_pos
= strchr (param7_pos
, '*');
20328 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20330 u32 param7_len
= param8_pos
- param7_pos
;
20334 const uint type
= atoi (param0_pos
);
20335 const uint mode
= atoi (param1_pos
);
20336 const uint magic
= atoi (param2_pos
);
20338 char *salt_buf
= param3_pos
;
20340 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20342 const uint compress_length
= atoi (param5_pos
);
20344 char *data_buf
= param6_pos
;
20345 char *auth
= param7_pos
;
20351 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20353 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20355 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20357 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20359 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20361 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20363 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20365 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20367 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20369 if (type
!= 0) return (PARSER_SALT_VALUE
);
20371 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20373 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20375 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20383 zip2
->magic
= magic
;
20387 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20388 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20389 zip2
->salt_buf
[2] = 0;
20390 zip2
->salt_buf
[3] = 0;
20392 zip2
->salt_len
= 8;
20394 else if (mode
== 2)
20396 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20397 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20398 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20399 zip2
->salt_buf
[3] = 0;
20401 zip2
->salt_len
= 12;
20403 else if (mode
== 3)
20405 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20406 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20407 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20408 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20410 zip2
->salt_len
= 16;
20413 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20414 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20415 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20416 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20418 zip2
->verify_bytes
= verify_bytes
;
20420 zip2
->compress_length
= compress_length
;
20422 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20424 for (uint i
= 0; i
< param6_len
; i
+= 2)
20426 const char p0
= data_buf
[i
+ 0];
20427 const char p1
= data_buf
[i
+ 1];
20429 *data_buf_ptr
++ = hex_convert (p1
) << 0
20430 | hex_convert (p0
) << 4;
20435 *data_buf_ptr
= 0x80;
20437 char *auth_ptr
= (char *) zip2
->auth_buf
;
20439 for (uint i
= 0; i
< param7_len
; i
+= 2)
20441 const char p0
= auth
[i
+ 0];
20442 const char p1
= auth
[i
+ 1];
20444 *auth_ptr
++ = hex_convert (p1
) << 0
20445 | hex_convert (p0
) << 4;
20454 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20455 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20456 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20457 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20458 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20459 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20460 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20461 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20463 salt
->salt_len
= 32;
20465 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20468 * digest buf (fake)
20471 digest
[0] = zip2
->auth_buf
[0];
20472 digest
[1] = zip2
->auth_buf
[1];
20473 digest
[2] = zip2
->auth_buf
[2];
20474 digest
[3] = zip2
->auth_buf
[3];
20476 return (PARSER_OK
);
20480 * parallel running threads
20485 BOOL WINAPI
sigHandler_default (DWORD sig
)
20489 case CTRL_CLOSE_EVENT
:
20492 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20493 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20494 * function otherwise it is too late (e.g. after returning from this function)
20499 SetConsoleCtrlHandler (NULL
, TRUE
);
20506 case CTRL_LOGOFF_EVENT
:
20507 case CTRL_SHUTDOWN_EVENT
:
20511 SetConsoleCtrlHandler (NULL
, TRUE
);
20519 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20523 case CTRL_CLOSE_EVENT
:
20527 SetConsoleCtrlHandler (NULL
, TRUE
);
20534 case CTRL_LOGOFF_EVENT
:
20535 case CTRL_SHUTDOWN_EVENT
:
20539 SetConsoleCtrlHandler (NULL
, TRUE
);
20547 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20549 if (callback
== NULL
)
20551 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20555 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20561 void sigHandler_default (int sig
)
20565 signal (sig
, NULL
);
20568 void sigHandler_benchmark (int sig
)
20572 signal (sig
, NULL
);
20575 void hc_signal (void (callback
) (int))
20577 if (callback
== NULL
) callback
= SIG_DFL
;
20579 signal (SIGINT
, callback
);
20580 signal (SIGTERM
, callback
);
20581 signal (SIGABRT
, callback
);
20586 void status_display ();
20588 void *thread_keypress (void *p
)
20590 int benchmark
= *((int *) p
);
20592 uint quiet
= data
.quiet
;
20596 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20598 int ch
= tty_getchar();
20600 if (ch
== -1) break;
20602 if (ch
== 0) continue;
20604 //https://github.com/hashcat/hashcat/issues/302
20609 hc_thread_mutex_lock (mux_display
);
20625 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20626 if (quiet
== 0) fflush (stdout
);
20638 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20639 if (quiet
== 0) fflush (stdout
);
20651 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20652 if (quiet
== 0) fflush (stdout
);
20664 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20665 if (quiet
== 0) fflush (stdout
);
20673 if (benchmark
== 1) break;
20675 stop_at_checkpoint ();
20679 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20680 if (quiet
== 0) fflush (stdout
);
20688 if (benchmark
== 1)
20700 //https://github.com/hashcat/hashcat/issues/302
20705 hc_thread_mutex_unlock (mux_display
);
20717 bool class_num (const u8 c
)
20719 return ((c
>= '0') && (c
<= '9'));
20722 bool class_lower (const u8 c
)
20724 return ((c
>= 'a') && (c
<= 'z'));
20727 bool class_upper (const u8 c
)
20729 return ((c
>= 'A') && (c
<= 'Z'));
20732 bool class_alpha (const u8 c
)
20734 return (class_lower (c
) || class_upper (c
));
20737 int conv_ctoi (const u8 c
)
20743 else if (class_upper (c
))
20745 return c
- 'A' + 10;
20751 int conv_itoc (const u8 c
)
20759 return c
+ 'A' - 10;
20769 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20770 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20771 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20772 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20773 #define MAX_KERNEL_RULES 255
20774 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20775 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20776 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20778 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20779 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20780 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20781 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20783 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20788 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20790 switch (rule_buf
[rule_pos
])
20796 case RULE_OP_MANGLE_NOOP
:
20797 SET_NAME (rule
, rule_buf
[rule_pos
]);
20800 case RULE_OP_MANGLE_LREST
:
20801 SET_NAME (rule
, rule_buf
[rule_pos
]);
20804 case RULE_OP_MANGLE_UREST
:
20805 SET_NAME (rule
, rule_buf
[rule_pos
]);
20808 case RULE_OP_MANGLE_LREST_UFIRST
:
20809 SET_NAME (rule
, rule_buf
[rule_pos
]);
20812 case RULE_OP_MANGLE_UREST_LFIRST
:
20813 SET_NAME (rule
, rule_buf
[rule_pos
]);
20816 case RULE_OP_MANGLE_TREST
:
20817 SET_NAME (rule
, rule_buf
[rule_pos
]);
20820 case RULE_OP_MANGLE_TOGGLE_AT
:
20821 SET_NAME (rule
, rule_buf
[rule_pos
]);
20822 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20825 case RULE_OP_MANGLE_REVERSE
:
20826 SET_NAME (rule
, rule_buf
[rule_pos
]);
20829 case RULE_OP_MANGLE_DUPEWORD
:
20830 SET_NAME (rule
, rule_buf
[rule_pos
]);
20833 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20834 SET_NAME (rule
, rule_buf
[rule_pos
]);
20835 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20838 case RULE_OP_MANGLE_REFLECT
:
20839 SET_NAME (rule
, rule_buf
[rule_pos
]);
20842 case RULE_OP_MANGLE_ROTATE_LEFT
:
20843 SET_NAME (rule
, rule_buf
[rule_pos
]);
20846 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20847 SET_NAME (rule
, rule_buf
[rule_pos
]);
20850 case RULE_OP_MANGLE_APPEND
:
20851 SET_NAME (rule
, rule_buf
[rule_pos
]);
20852 SET_P0 (rule
, rule_buf
[rule_pos
]);
20855 case RULE_OP_MANGLE_PREPEND
:
20856 SET_NAME (rule
, rule_buf
[rule_pos
]);
20857 SET_P0 (rule
, rule_buf
[rule_pos
]);
20860 case RULE_OP_MANGLE_DELETE_FIRST
:
20861 SET_NAME (rule
, rule_buf
[rule_pos
]);
20864 case RULE_OP_MANGLE_DELETE_LAST
:
20865 SET_NAME (rule
, rule_buf
[rule_pos
]);
20868 case RULE_OP_MANGLE_DELETE_AT
:
20869 SET_NAME (rule
, rule_buf
[rule_pos
]);
20870 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20873 case RULE_OP_MANGLE_EXTRACT
:
20874 SET_NAME (rule
, rule_buf
[rule_pos
]);
20875 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20876 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20879 case RULE_OP_MANGLE_OMIT
:
20880 SET_NAME (rule
, rule_buf
[rule_pos
]);
20881 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20882 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20885 case RULE_OP_MANGLE_INSERT
:
20886 SET_NAME (rule
, rule_buf
[rule_pos
]);
20887 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20888 SET_P1 (rule
, rule_buf
[rule_pos
]);
20891 case RULE_OP_MANGLE_OVERSTRIKE
:
20892 SET_NAME (rule
, rule_buf
[rule_pos
]);
20893 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20894 SET_P1 (rule
, rule_buf
[rule_pos
]);
20897 case RULE_OP_MANGLE_TRUNCATE_AT
:
20898 SET_NAME (rule
, rule_buf
[rule_pos
]);
20899 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20902 case RULE_OP_MANGLE_REPLACE
:
20903 SET_NAME (rule
, rule_buf
[rule_pos
]);
20904 SET_P0 (rule
, rule_buf
[rule_pos
]);
20905 SET_P1 (rule
, rule_buf
[rule_pos
]);
20908 case RULE_OP_MANGLE_PURGECHAR
:
20912 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20916 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20917 SET_NAME (rule
, rule_buf
[rule_pos
]);
20918 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20921 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20922 SET_NAME (rule
, rule_buf
[rule_pos
]);
20923 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20926 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20927 SET_NAME (rule
, rule_buf
[rule_pos
]);
20930 case RULE_OP_MANGLE_SWITCH_FIRST
:
20931 SET_NAME (rule
, rule_buf
[rule_pos
]);
20934 case RULE_OP_MANGLE_SWITCH_LAST
:
20935 SET_NAME (rule
, rule_buf
[rule_pos
]);
20938 case RULE_OP_MANGLE_SWITCH_AT
:
20939 SET_NAME (rule
, rule_buf
[rule_pos
]);
20940 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20941 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20944 case RULE_OP_MANGLE_CHR_SHIFTL
:
20945 SET_NAME (rule
, rule_buf
[rule_pos
]);
20946 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20949 case RULE_OP_MANGLE_CHR_SHIFTR
:
20950 SET_NAME (rule
, rule_buf
[rule_pos
]);
20951 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20954 case RULE_OP_MANGLE_CHR_INCR
:
20955 SET_NAME (rule
, rule_buf
[rule_pos
]);
20956 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20959 case RULE_OP_MANGLE_CHR_DECR
:
20960 SET_NAME (rule
, rule_buf
[rule_pos
]);
20961 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20964 case RULE_OP_MANGLE_REPLACE_NP1
:
20965 SET_NAME (rule
, rule_buf
[rule_pos
]);
20966 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20969 case RULE_OP_MANGLE_REPLACE_NM1
:
20970 SET_NAME (rule
, rule_buf
[rule_pos
]);
20971 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20974 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20975 SET_NAME (rule
, rule_buf
[rule_pos
]);
20976 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20979 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20980 SET_NAME (rule
, rule_buf
[rule_pos
]);
20981 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20984 case RULE_OP_MANGLE_TITLE
:
20985 SET_NAME (rule
, rule_buf
[rule_pos
]);
20994 if (rule_pos
< rule_len
) return (-1);
20999 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21003 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21007 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21011 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21015 case RULE_OP_MANGLE_NOOP
:
21016 rule_buf
[rule_pos
] = rule_cmd
;
21019 case RULE_OP_MANGLE_LREST
:
21020 rule_buf
[rule_pos
] = rule_cmd
;
21023 case RULE_OP_MANGLE_UREST
:
21024 rule_buf
[rule_pos
] = rule_cmd
;
21027 case RULE_OP_MANGLE_LREST_UFIRST
:
21028 rule_buf
[rule_pos
] = rule_cmd
;
21031 case RULE_OP_MANGLE_UREST_LFIRST
:
21032 rule_buf
[rule_pos
] = rule_cmd
;
21035 case RULE_OP_MANGLE_TREST
:
21036 rule_buf
[rule_pos
] = rule_cmd
;
21039 case RULE_OP_MANGLE_TOGGLE_AT
:
21040 rule_buf
[rule_pos
] = rule_cmd
;
21041 GET_P0_CONV (rule
);
21044 case RULE_OP_MANGLE_REVERSE
:
21045 rule_buf
[rule_pos
] = rule_cmd
;
21048 case RULE_OP_MANGLE_DUPEWORD
:
21049 rule_buf
[rule_pos
] = rule_cmd
;
21052 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21053 rule_buf
[rule_pos
] = rule_cmd
;
21054 GET_P0_CONV (rule
);
21057 case RULE_OP_MANGLE_REFLECT
:
21058 rule_buf
[rule_pos
] = rule_cmd
;
21061 case RULE_OP_MANGLE_ROTATE_LEFT
:
21062 rule_buf
[rule_pos
] = rule_cmd
;
21065 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21066 rule_buf
[rule_pos
] = rule_cmd
;
21069 case RULE_OP_MANGLE_APPEND
:
21070 rule_buf
[rule_pos
] = rule_cmd
;
21074 case RULE_OP_MANGLE_PREPEND
:
21075 rule_buf
[rule_pos
] = rule_cmd
;
21079 case RULE_OP_MANGLE_DELETE_FIRST
:
21080 rule_buf
[rule_pos
] = rule_cmd
;
21083 case RULE_OP_MANGLE_DELETE_LAST
:
21084 rule_buf
[rule_pos
] = rule_cmd
;
21087 case RULE_OP_MANGLE_DELETE_AT
:
21088 rule_buf
[rule_pos
] = rule_cmd
;
21089 GET_P0_CONV (rule
);
21092 case RULE_OP_MANGLE_EXTRACT
:
21093 rule_buf
[rule_pos
] = rule_cmd
;
21094 GET_P0_CONV (rule
);
21095 GET_P1_CONV (rule
);
21098 case RULE_OP_MANGLE_OMIT
:
21099 rule_buf
[rule_pos
] = rule_cmd
;
21100 GET_P0_CONV (rule
);
21101 GET_P1_CONV (rule
);
21104 case RULE_OP_MANGLE_INSERT
:
21105 rule_buf
[rule_pos
] = rule_cmd
;
21106 GET_P0_CONV (rule
);
21110 case RULE_OP_MANGLE_OVERSTRIKE
:
21111 rule_buf
[rule_pos
] = rule_cmd
;
21112 GET_P0_CONV (rule
);
21116 case RULE_OP_MANGLE_TRUNCATE_AT
:
21117 rule_buf
[rule_pos
] = rule_cmd
;
21118 GET_P0_CONV (rule
);
21121 case RULE_OP_MANGLE_REPLACE
:
21122 rule_buf
[rule_pos
] = rule_cmd
;
21127 case RULE_OP_MANGLE_PURGECHAR
:
21131 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21135 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21136 rule_buf
[rule_pos
] = rule_cmd
;
21137 GET_P0_CONV (rule
);
21140 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21141 rule_buf
[rule_pos
] = rule_cmd
;
21142 GET_P0_CONV (rule
);
21145 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21146 rule_buf
[rule_pos
] = rule_cmd
;
21149 case RULE_OP_MANGLE_SWITCH_FIRST
:
21150 rule_buf
[rule_pos
] = rule_cmd
;
21153 case RULE_OP_MANGLE_SWITCH_LAST
:
21154 rule_buf
[rule_pos
] = rule_cmd
;
21157 case RULE_OP_MANGLE_SWITCH_AT
:
21158 rule_buf
[rule_pos
] = rule_cmd
;
21159 GET_P0_CONV (rule
);
21160 GET_P1_CONV (rule
);
21163 case RULE_OP_MANGLE_CHR_SHIFTL
:
21164 rule_buf
[rule_pos
] = rule_cmd
;
21165 GET_P0_CONV (rule
);
21168 case RULE_OP_MANGLE_CHR_SHIFTR
:
21169 rule_buf
[rule_pos
] = rule_cmd
;
21170 GET_P0_CONV (rule
);
21173 case RULE_OP_MANGLE_CHR_INCR
:
21174 rule_buf
[rule_pos
] = rule_cmd
;
21175 GET_P0_CONV (rule
);
21178 case RULE_OP_MANGLE_CHR_DECR
:
21179 rule_buf
[rule_pos
] = rule_cmd
;
21180 GET_P0_CONV (rule
);
21183 case RULE_OP_MANGLE_REPLACE_NP1
:
21184 rule_buf
[rule_pos
] = rule_cmd
;
21185 GET_P0_CONV (rule
);
21188 case RULE_OP_MANGLE_REPLACE_NM1
:
21189 rule_buf
[rule_pos
] = rule_cmd
;
21190 GET_P0_CONV (rule
);
21193 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21194 rule_buf
[rule_pos
] = rule_cmd
;
21195 GET_P0_CONV (rule
);
21198 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21199 rule_buf
[rule_pos
] = rule_cmd
;
21200 GET_P0_CONV (rule
);
21203 case RULE_OP_MANGLE_TITLE
:
21204 rule_buf
[rule_pos
] = rule_cmd
;
21208 return rule_pos
- 1;
21226 * CPU rules : this is from hashcat sources, cpu based rules
21229 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21230 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21232 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21233 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21234 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21236 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21237 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21238 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21240 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21244 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21249 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21253 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21258 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21262 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21267 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21272 for (l
= 0; l
< arr_len
; l
++)
21274 r
= arr_len
- 1 - l
;
21278 MANGLE_SWITCH (arr
, l
, r
);
21284 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21286 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21288 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21290 return (arr_len
* 2);
21293 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21295 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21297 int orig_len
= arr_len
;
21301 for (i
= 0; i
< times
; i
++)
21303 memcpy (&arr
[arr_len
], arr
, orig_len
);
21305 arr_len
+= orig_len
;
21311 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21313 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21315 mangle_double (arr
, arr_len
);
21317 mangle_reverse (arr
+ arr_len
, arr_len
);
21319 return (arr_len
* 2);
21322 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21327 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21329 MANGLE_SWITCH (arr
, l
, r
);
21335 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21340 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21342 MANGLE_SWITCH (arr
, l
, r
);
21348 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21350 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21354 return (arr_len
+ 1);
21357 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21359 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21363 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21365 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21370 return (arr_len
+ 1);
21373 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21375 if (upos
>= arr_len
) return (arr_len
);
21379 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21381 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21384 return (arr_len
- 1);
21387 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21389 if (upos
>= arr_len
) return (arr_len
);
21391 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21395 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21397 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21403 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21405 if (upos
>= arr_len
) return (arr_len
);
21407 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21411 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21413 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21416 return (arr_len
- ulen
);
21419 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21421 if (upos
>= arr_len
) return (arr_len
);
21423 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21427 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21429 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21434 return (arr_len
+ 1);
21437 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
)
21439 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21441 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21443 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21445 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21447 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21449 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21451 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21453 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21455 return (arr_len
+ arr2_cpy
);
21458 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21460 if (upos
>= arr_len
) return (arr_len
);
21467 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21469 if (upos
>= arr_len
) return (arr_len
);
21471 memset (arr
+ upos
, 0, arr_len
- upos
);
21476 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21480 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21482 if (arr
[arr_pos
] != oldc
) continue;
21484 arr
[arr_pos
] = newc
;
21490 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21496 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21498 if (arr
[arr_pos
] == c
) continue;
21500 arr
[ret_len
] = arr
[arr_pos
];
21508 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21510 if (ulen
> arr_len
) return (arr_len
);
21512 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21514 char cs
[100] = { 0 };
21516 memcpy (cs
, arr
, ulen
);
21520 for (i
= 0; i
< ulen
; i
++)
21524 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21530 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21532 if (ulen
> arr_len
) return (arr_len
);
21534 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21536 int upos
= arr_len
- ulen
;
21540 for (i
= 0; i
< ulen
; i
++)
21542 char c
= arr
[upos
+ i
];
21544 arr_len
= mangle_append (arr
, arr_len
, c
);
21550 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21552 if ( arr_len
== 0) return (arr_len
);
21553 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21555 char c
= arr
[upos
];
21559 for (i
= 0; i
< ulen
; i
++)
21561 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21567 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21569 if ( arr_len
== 0) return (arr_len
);
21570 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21574 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21576 int new_pos
= arr_pos
* 2;
21578 arr
[new_pos
] = arr
[arr_pos
];
21580 arr
[new_pos
+ 1] = arr
[arr_pos
];
21583 return (arr_len
* 2);
21586 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21588 if (upos
>= arr_len
) return (arr_len
);
21589 if (upos2
>= arr_len
) return (arr_len
);
21591 MANGLE_SWITCH (arr
, upos
, upos2
);
21596 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21598 MANGLE_SWITCH (arr
, upos
, upos2
);
21603 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21605 if (upos
>= arr_len
) return (arr_len
);
21612 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21614 if (upos
>= arr_len
) return (arr_len
);
21621 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21623 if (upos
>= arr_len
) return (arr_len
);
21630 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21632 if (upos
>= arr_len
) return (arr_len
);
21639 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21641 int upper_next
= 1;
21645 for (pos
= 0; pos
< arr_len
; pos
++)
21647 if (arr
[pos
] == ' ')
21658 MANGLE_UPPER_AT (arr
, pos
);
21662 MANGLE_LOWER_AT (arr
, pos
);
21669 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21671 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21677 for (j
= 0; j
< rp_gen_num
; j
++)
21684 switch ((char) get_random_num (0, 9))
21687 r
= get_random_num (0, sizeof (grp_op_nop
));
21688 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21692 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21693 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21694 p1
= get_random_num (0, sizeof (grp_pos
));
21695 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21699 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21700 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21701 p1
= get_random_num (1, 6);
21702 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21706 r
= get_random_num (0, sizeof (grp_op_chr
));
21707 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21708 p1
= get_random_num (0x20, 0x7e);
21709 rule_buf
[rule_pos
++] = (char) p1
;
21713 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21714 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21715 p1
= get_random_num (0x20, 0x7e);
21716 rule_buf
[rule_pos
++] = (char) p1
;
21717 p2
= get_random_num (0x20, 0x7e);
21719 p2
= get_random_num (0x20, 0x7e);
21720 rule_buf
[rule_pos
++] = (char) p2
;
21724 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21725 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21726 p1
= get_random_num (0, sizeof (grp_pos
));
21727 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21728 p2
= get_random_num (0x20, 0x7e);
21729 rule_buf
[rule_pos
++] = (char) p2
;
21733 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21734 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21735 p1
= get_random_num (0, sizeof (grp_pos
));
21736 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21737 p2
= get_random_num (0, sizeof (grp_pos
));
21739 p2
= get_random_num (0, sizeof (grp_pos
));
21740 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21744 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21745 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21746 p1
= get_random_num (0, sizeof (grp_pos
));
21747 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21748 p2
= get_random_num (1, sizeof (grp_pos
));
21750 p2
= get_random_num (1, sizeof (grp_pos
));
21751 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21755 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21756 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21757 p1
= get_random_num (0, sizeof (grp_pos
));
21758 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21759 p2
= get_random_num (1, sizeof (grp_pos
));
21760 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21761 p3
= get_random_num (0, sizeof (grp_pos
));
21762 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21770 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21772 char mem
[BLOCK_SIZE
] = { 0 };
21774 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21776 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21778 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21780 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21782 int out_len
= in_len
;
21783 int mem_len
= in_len
;
21785 memcpy (out
, in
, out_len
);
21789 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21794 switch (rule
[rule_pos
])
21799 case RULE_OP_MANGLE_NOOP
:
21802 case RULE_OP_MANGLE_LREST
:
21803 out_len
= mangle_lrest (out
, out_len
);
21806 case RULE_OP_MANGLE_UREST
:
21807 out_len
= mangle_urest (out
, out_len
);
21810 case RULE_OP_MANGLE_LREST_UFIRST
:
21811 out_len
= mangle_lrest (out
, out_len
);
21812 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21815 case RULE_OP_MANGLE_UREST_LFIRST
:
21816 out_len
= mangle_urest (out
, out_len
);
21817 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21820 case RULE_OP_MANGLE_TREST
:
21821 out_len
= mangle_trest (out
, out_len
);
21824 case RULE_OP_MANGLE_TOGGLE_AT
:
21825 NEXT_RULEPOS (rule_pos
);
21826 NEXT_RPTOI (rule
, rule_pos
, upos
);
21827 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21830 case RULE_OP_MANGLE_REVERSE
:
21831 out_len
= mangle_reverse (out
, out_len
);
21834 case RULE_OP_MANGLE_DUPEWORD
:
21835 out_len
= mangle_double (out
, out_len
);
21838 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21839 NEXT_RULEPOS (rule_pos
);
21840 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21841 out_len
= mangle_double_times (out
, out_len
, ulen
);
21844 case RULE_OP_MANGLE_REFLECT
:
21845 out_len
= mangle_reflect (out
, out_len
);
21848 case RULE_OP_MANGLE_ROTATE_LEFT
:
21849 mangle_rotate_left (out
, out_len
);
21852 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21853 mangle_rotate_right (out
, out_len
);
21856 case RULE_OP_MANGLE_APPEND
:
21857 NEXT_RULEPOS (rule_pos
);
21858 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21861 case RULE_OP_MANGLE_PREPEND
:
21862 NEXT_RULEPOS (rule_pos
);
21863 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21866 case RULE_OP_MANGLE_DELETE_FIRST
:
21867 out_len
= mangle_delete_at (out
, out_len
, 0);
21870 case RULE_OP_MANGLE_DELETE_LAST
:
21871 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21874 case RULE_OP_MANGLE_DELETE_AT
:
21875 NEXT_RULEPOS (rule_pos
);
21876 NEXT_RPTOI (rule
, rule_pos
, upos
);
21877 out_len
= mangle_delete_at (out
, out_len
, upos
);
21880 case RULE_OP_MANGLE_EXTRACT
:
21881 NEXT_RULEPOS (rule_pos
);
21882 NEXT_RPTOI (rule
, rule_pos
, upos
);
21883 NEXT_RULEPOS (rule_pos
);
21884 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21885 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21888 case RULE_OP_MANGLE_OMIT
:
21889 NEXT_RULEPOS (rule_pos
);
21890 NEXT_RPTOI (rule
, rule_pos
, upos
);
21891 NEXT_RULEPOS (rule_pos
);
21892 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21893 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21896 case RULE_OP_MANGLE_INSERT
:
21897 NEXT_RULEPOS (rule_pos
);
21898 NEXT_RPTOI (rule
, rule_pos
, upos
);
21899 NEXT_RULEPOS (rule_pos
);
21900 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21903 case RULE_OP_MANGLE_OVERSTRIKE
:
21904 NEXT_RULEPOS (rule_pos
);
21905 NEXT_RPTOI (rule
, rule_pos
, upos
);
21906 NEXT_RULEPOS (rule_pos
);
21907 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21910 case RULE_OP_MANGLE_TRUNCATE_AT
:
21911 NEXT_RULEPOS (rule_pos
);
21912 NEXT_RPTOI (rule
, rule_pos
, upos
);
21913 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21916 case RULE_OP_MANGLE_REPLACE
:
21917 NEXT_RULEPOS (rule_pos
);
21918 NEXT_RULEPOS (rule_pos
);
21919 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21922 case RULE_OP_MANGLE_PURGECHAR
:
21923 NEXT_RULEPOS (rule_pos
);
21924 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21927 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21931 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21932 NEXT_RULEPOS (rule_pos
);
21933 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21934 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21937 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21938 NEXT_RULEPOS (rule_pos
);
21939 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21940 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21943 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21944 out_len
= mangle_dupechar (out
, out_len
);
21947 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21948 NEXT_RULEPOS (rule_pos
);
21949 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21950 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21953 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21954 NEXT_RULEPOS (rule_pos
);
21955 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21956 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21959 case RULE_OP_MANGLE_SWITCH_FIRST
:
21960 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21963 case RULE_OP_MANGLE_SWITCH_LAST
:
21964 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21967 case RULE_OP_MANGLE_SWITCH_AT
:
21968 NEXT_RULEPOS (rule_pos
);
21969 NEXT_RPTOI (rule
, rule_pos
, upos
);
21970 NEXT_RULEPOS (rule_pos
);
21971 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21972 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
21975 case RULE_OP_MANGLE_CHR_SHIFTL
:
21976 NEXT_RULEPOS (rule_pos
);
21977 NEXT_RPTOI (rule
, rule_pos
, upos
);
21978 mangle_chr_shiftl (out
, out_len
, upos
);
21981 case RULE_OP_MANGLE_CHR_SHIFTR
:
21982 NEXT_RULEPOS (rule_pos
);
21983 NEXT_RPTOI (rule
, rule_pos
, upos
);
21984 mangle_chr_shiftr (out
, out_len
, upos
);
21987 case RULE_OP_MANGLE_CHR_INCR
:
21988 NEXT_RULEPOS (rule_pos
);
21989 NEXT_RPTOI (rule
, rule_pos
, upos
);
21990 mangle_chr_incr (out
, out_len
, upos
);
21993 case RULE_OP_MANGLE_CHR_DECR
:
21994 NEXT_RULEPOS (rule_pos
);
21995 NEXT_RPTOI (rule
, rule_pos
, upos
);
21996 mangle_chr_decr (out
, out_len
, upos
);
21999 case RULE_OP_MANGLE_REPLACE_NP1
:
22000 NEXT_RULEPOS (rule_pos
);
22001 NEXT_RPTOI (rule
, rule_pos
, upos
);
22002 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22005 case RULE_OP_MANGLE_REPLACE_NM1
:
22006 NEXT_RULEPOS (rule_pos
);
22007 NEXT_RPTOI (rule
, rule_pos
, upos
);
22008 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22011 case RULE_OP_MANGLE_TITLE
:
22012 out_len
= mangle_title (out
, out_len
);
22015 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22016 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22017 NEXT_RULEPOS (rule_pos
);
22018 NEXT_RPTOI (rule
, rule_pos
, upos
);
22019 NEXT_RULEPOS (rule_pos
);
22020 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22021 NEXT_RULEPOS (rule_pos
);
22022 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22023 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22026 case RULE_OP_MANGLE_APPEND_MEMORY
:
22027 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22028 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22029 memcpy (out
+ out_len
, mem
, mem_len
);
22030 out_len
+= mem_len
;
22033 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22034 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22035 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22036 memcpy (mem
+ mem_len
, out
, out_len
);
22037 out_len
+= mem_len
;
22038 memcpy (out
, mem
, out_len
);
22041 case RULE_OP_MEMORIZE_WORD
:
22042 memcpy (mem
, out
, out_len
);
22046 case RULE_OP_REJECT_LESS
:
22047 NEXT_RULEPOS (rule_pos
);
22048 NEXT_RPTOI (rule
, rule_pos
, upos
);
22049 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22052 case RULE_OP_REJECT_GREATER
:
22053 NEXT_RULEPOS (rule_pos
);
22054 NEXT_RPTOI (rule
, rule_pos
, upos
);
22055 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22058 case RULE_OP_REJECT_CONTAIN
:
22059 NEXT_RULEPOS (rule_pos
);
22060 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22063 case RULE_OP_REJECT_NOT_CONTAIN
:
22064 NEXT_RULEPOS (rule_pos
);
22065 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22068 case RULE_OP_REJECT_EQUAL_FIRST
:
22069 NEXT_RULEPOS (rule_pos
);
22070 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22073 case RULE_OP_REJECT_EQUAL_LAST
:
22074 NEXT_RULEPOS (rule_pos
);
22075 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22078 case RULE_OP_REJECT_EQUAL_AT
:
22079 NEXT_RULEPOS (rule_pos
);
22080 NEXT_RPTOI (rule
, rule_pos
, upos
);
22081 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22082 NEXT_RULEPOS (rule_pos
);
22083 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22086 case RULE_OP_REJECT_CONTAINS
:
22087 NEXT_RULEPOS (rule_pos
);
22088 NEXT_RPTOI (rule
, rule_pos
, upos
);
22089 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22090 NEXT_RULEPOS (rule_pos
);
22091 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22092 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22095 case RULE_OP_REJECT_MEMORY
:
22096 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22100 return (RULE_RC_SYNTAX_ERROR
);
22105 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);