2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
19 #define GET_ACCEL(x) KERNEL_ACCEL_ ## x
20 #define GET_LOOPS(x) KERNEL_LOOPS_ ## x
26 u32
rotl32 (const u32 a
, const u32 n
)
28 return ((a
<< n
) | (a
>> (32 - n
)));
31 u32
rotr32 (const u32 a
, const u32 n
)
33 return ((a
>> n
) | (a
<< (32 - n
)));
36 u64
rotl64 (const u64 a
, const u64 n
)
38 return ((a
<< n
) | (a
>> (64 - n
)));
41 u64
rotr64 (const u64 a
, const u64 n
)
43 return ((a
>> n
) | (a
<< (64 - n
)));
46 u32
byte_swap_32 (const u32 n
)
48 return (n
& 0xff000000) >> 24
49 | (n
& 0x00ff0000) >> 8
50 | (n
& 0x0000ff00) << 8
51 | (n
& 0x000000ff) << 24;
54 u64
byte_swap_64 (const u64 n
)
56 return (n
& 0xff00000000000000ULL
) >> 56
57 | (n
& 0x00ff000000000000ULL
) >> 40
58 | (n
& 0x0000ff0000000000ULL
) >> 24
59 | (n
& 0x000000ff00000000ULL
) >> 8
60 | (n
& 0x00000000ff000000ULL
) << 8
61 | (n
& 0x0000000000ff0000ULL
) << 24
62 | (n
& 0x000000000000ff00ULL
) << 40
63 | (n
& 0x00000000000000ffULL
) << 56;
67 * ciphers for use on cpu
74 * 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
++)
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
)
675 memset (base64_buf
, 0, sizeof (base64_buf
));
677 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
681 u32 juniper_iv
[4] = { 0 };
683 memcpy (juniper_iv
, base64_buf
, 12);
685 memcpy (out
, juniper_iv
, 12);
691 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
692 juniper_key
[1] = byte_swap_32 (0x8df91059);
693 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
694 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
698 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
699 u32
*out_ptr
= (u32
*) (out
+ 12);
701 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
704 void phpass_decode (u8 digest
[16], u8 buf
[22])
708 l
= itoa64_to_int (buf
[ 0]) << 0;
709 l
|= itoa64_to_int (buf
[ 1]) << 6;
710 l
|= itoa64_to_int (buf
[ 2]) << 12;
711 l
|= itoa64_to_int (buf
[ 3]) << 18;
713 digest
[ 0] = (l
>> 0) & 0xff;
714 digest
[ 1] = (l
>> 8) & 0xff;
715 digest
[ 2] = (l
>> 16) & 0xff;
717 l
= itoa64_to_int (buf
[ 4]) << 0;
718 l
|= itoa64_to_int (buf
[ 5]) << 6;
719 l
|= itoa64_to_int (buf
[ 6]) << 12;
720 l
|= itoa64_to_int (buf
[ 7]) << 18;
722 digest
[ 3] = (l
>> 0) & 0xff;
723 digest
[ 4] = (l
>> 8) & 0xff;
724 digest
[ 5] = (l
>> 16) & 0xff;
726 l
= itoa64_to_int (buf
[ 8]) << 0;
727 l
|= itoa64_to_int (buf
[ 9]) << 6;
728 l
|= itoa64_to_int (buf
[10]) << 12;
729 l
|= itoa64_to_int (buf
[11]) << 18;
731 digest
[ 6] = (l
>> 0) & 0xff;
732 digest
[ 7] = (l
>> 8) & 0xff;
733 digest
[ 8] = (l
>> 16) & 0xff;
735 l
= itoa64_to_int (buf
[12]) << 0;
736 l
|= itoa64_to_int (buf
[13]) << 6;
737 l
|= itoa64_to_int (buf
[14]) << 12;
738 l
|= itoa64_to_int (buf
[15]) << 18;
740 digest
[ 9] = (l
>> 0) & 0xff;
741 digest
[10] = (l
>> 8) & 0xff;
742 digest
[11] = (l
>> 16) & 0xff;
744 l
= itoa64_to_int (buf
[16]) << 0;
745 l
|= itoa64_to_int (buf
[17]) << 6;
746 l
|= itoa64_to_int (buf
[18]) << 12;
747 l
|= itoa64_to_int (buf
[19]) << 18;
749 digest
[12] = (l
>> 0) & 0xff;
750 digest
[13] = (l
>> 8) & 0xff;
751 digest
[14] = (l
>> 16) & 0xff;
753 l
= itoa64_to_int (buf
[20]) << 0;
754 l
|= itoa64_to_int (buf
[21]) << 6;
756 digest
[15] = (l
>> 0) & 0xff;
759 void phpass_encode (u8 digest
[16], u8 buf
[22])
763 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
765 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
766 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
767 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
768 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
770 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
772 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
773 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
774 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
775 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
777 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
779 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
781 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
782 buf
[11] = int_to_itoa64 (l
& 0x3f);
784 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
786 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
788 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
789 buf
[15] = int_to_itoa64 (l
& 0x3f);
791 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
793 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
795 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
796 buf
[19] = int_to_itoa64 (l
& 0x3f);
798 l
= (digest
[15] << 0);
800 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
801 buf
[21] = int_to_itoa64 (l
& 0x3f);
804 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
808 l
= itoa64_to_int (buf
[ 0]) << 0;
809 l
|= itoa64_to_int (buf
[ 1]) << 6;
810 l
|= itoa64_to_int (buf
[ 2]) << 12;
811 l
|= itoa64_to_int (buf
[ 3]) << 18;
813 digest
[ 0] = (l
>> 16) & 0xff;
814 digest
[ 6] = (l
>> 8) & 0xff;
815 digest
[12] = (l
>> 0) & 0xff;
817 l
= itoa64_to_int (buf
[ 4]) << 0;
818 l
|= itoa64_to_int (buf
[ 5]) << 6;
819 l
|= itoa64_to_int (buf
[ 6]) << 12;
820 l
|= itoa64_to_int (buf
[ 7]) << 18;
822 digest
[ 1] = (l
>> 16) & 0xff;
823 digest
[ 7] = (l
>> 8) & 0xff;
824 digest
[13] = (l
>> 0) & 0xff;
826 l
= itoa64_to_int (buf
[ 8]) << 0;
827 l
|= itoa64_to_int (buf
[ 9]) << 6;
828 l
|= itoa64_to_int (buf
[10]) << 12;
829 l
|= itoa64_to_int (buf
[11]) << 18;
831 digest
[ 2] = (l
>> 16) & 0xff;
832 digest
[ 8] = (l
>> 8) & 0xff;
833 digest
[14] = (l
>> 0) & 0xff;
835 l
= itoa64_to_int (buf
[12]) << 0;
836 l
|= itoa64_to_int (buf
[13]) << 6;
837 l
|= itoa64_to_int (buf
[14]) << 12;
838 l
|= itoa64_to_int (buf
[15]) << 18;
840 digest
[ 3] = (l
>> 16) & 0xff;
841 digest
[ 9] = (l
>> 8) & 0xff;
842 digest
[15] = (l
>> 0) & 0xff;
844 l
= itoa64_to_int (buf
[16]) << 0;
845 l
|= itoa64_to_int (buf
[17]) << 6;
846 l
|= itoa64_to_int (buf
[18]) << 12;
847 l
|= itoa64_to_int (buf
[19]) << 18;
849 digest
[ 4] = (l
>> 16) & 0xff;
850 digest
[10] = (l
>> 8) & 0xff;
851 digest
[ 5] = (l
>> 0) & 0xff;
853 l
= itoa64_to_int (buf
[20]) << 0;
854 l
|= itoa64_to_int (buf
[21]) << 6;
856 digest
[11] = (l
>> 0) & 0xff;
859 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
863 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
865 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
866 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
867 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
870 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
872 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
873 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
874 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
877 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
879 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
881 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
884 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
886 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
888 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
891 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
893 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
895 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
898 l
= (digest
[11] << 0);
900 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
901 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
904 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
908 l
= itoa64_to_int (buf
[ 0]) << 0;
909 l
|= itoa64_to_int (buf
[ 1]) << 6;
910 l
|= itoa64_to_int (buf
[ 2]) << 12;
911 l
|= itoa64_to_int (buf
[ 3]) << 18;
913 digest
[ 0] = (l
>> 16) & 0xff;
914 digest
[21] = (l
>> 8) & 0xff;
915 digest
[42] = (l
>> 0) & 0xff;
917 l
= itoa64_to_int (buf
[ 4]) << 0;
918 l
|= itoa64_to_int (buf
[ 5]) << 6;
919 l
|= itoa64_to_int (buf
[ 6]) << 12;
920 l
|= itoa64_to_int (buf
[ 7]) << 18;
922 digest
[22] = (l
>> 16) & 0xff;
923 digest
[43] = (l
>> 8) & 0xff;
924 digest
[ 1] = (l
>> 0) & 0xff;
926 l
= itoa64_to_int (buf
[ 8]) << 0;
927 l
|= itoa64_to_int (buf
[ 9]) << 6;
928 l
|= itoa64_to_int (buf
[10]) << 12;
929 l
|= itoa64_to_int (buf
[11]) << 18;
931 digest
[44] = (l
>> 16) & 0xff;
932 digest
[ 2] = (l
>> 8) & 0xff;
933 digest
[23] = (l
>> 0) & 0xff;
935 l
= itoa64_to_int (buf
[12]) << 0;
936 l
|= itoa64_to_int (buf
[13]) << 6;
937 l
|= itoa64_to_int (buf
[14]) << 12;
938 l
|= itoa64_to_int (buf
[15]) << 18;
940 digest
[ 3] = (l
>> 16) & 0xff;
941 digest
[24] = (l
>> 8) & 0xff;
942 digest
[45] = (l
>> 0) & 0xff;
944 l
= itoa64_to_int (buf
[16]) << 0;
945 l
|= itoa64_to_int (buf
[17]) << 6;
946 l
|= itoa64_to_int (buf
[18]) << 12;
947 l
|= itoa64_to_int (buf
[19]) << 18;
949 digest
[25] = (l
>> 16) & 0xff;
950 digest
[46] = (l
>> 8) & 0xff;
951 digest
[ 4] = (l
>> 0) & 0xff;
953 l
= itoa64_to_int (buf
[20]) << 0;
954 l
|= itoa64_to_int (buf
[21]) << 6;
955 l
|= itoa64_to_int (buf
[22]) << 12;
956 l
|= itoa64_to_int (buf
[23]) << 18;
958 digest
[47] = (l
>> 16) & 0xff;
959 digest
[ 5] = (l
>> 8) & 0xff;
960 digest
[26] = (l
>> 0) & 0xff;
962 l
= itoa64_to_int (buf
[24]) << 0;
963 l
|= itoa64_to_int (buf
[25]) << 6;
964 l
|= itoa64_to_int (buf
[26]) << 12;
965 l
|= itoa64_to_int (buf
[27]) << 18;
967 digest
[ 6] = (l
>> 16) & 0xff;
968 digest
[27] = (l
>> 8) & 0xff;
969 digest
[48] = (l
>> 0) & 0xff;
971 l
= itoa64_to_int (buf
[28]) << 0;
972 l
|= itoa64_to_int (buf
[29]) << 6;
973 l
|= itoa64_to_int (buf
[30]) << 12;
974 l
|= itoa64_to_int (buf
[31]) << 18;
976 digest
[28] = (l
>> 16) & 0xff;
977 digest
[49] = (l
>> 8) & 0xff;
978 digest
[ 7] = (l
>> 0) & 0xff;
980 l
= itoa64_to_int (buf
[32]) << 0;
981 l
|= itoa64_to_int (buf
[33]) << 6;
982 l
|= itoa64_to_int (buf
[34]) << 12;
983 l
|= itoa64_to_int (buf
[35]) << 18;
985 digest
[50] = (l
>> 16) & 0xff;
986 digest
[ 8] = (l
>> 8) & 0xff;
987 digest
[29] = (l
>> 0) & 0xff;
989 l
= itoa64_to_int (buf
[36]) << 0;
990 l
|= itoa64_to_int (buf
[37]) << 6;
991 l
|= itoa64_to_int (buf
[38]) << 12;
992 l
|= itoa64_to_int (buf
[39]) << 18;
994 digest
[ 9] = (l
>> 16) & 0xff;
995 digest
[30] = (l
>> 8) & 0xff;
996 digest
[51] = (l
>> 0) & 0xff;
998 l
= itoa64_to_int (buf
[40]) << 0;
999 l
|= itoa64_to_int (buf
[41]) << 6;
1000 l
|= itoa64_to_int (buf
[42]) << 12;
1001 l
|= itoa64_to_int (buf
[43]) << 18;
1003 digest
[31] = (l
>> 16) & 0xff;
1004 digest
[52] = (l
>> 8) & 0xff;
1005 digest
[10] = (l
>> 0) & 0xff;
1007 l
= itoa64_to_int (buf
[44]) << 0;
1008 l
|= itoa64_to_int (buf
[45]) << 6;
1009 l
|= itoa64_to_int (buf
[46]) << 12;
1010 l
|= itoa64_to_int (buf
[47]) << 18;
1012 digest
[53] = (l
>> 16) & 0xff;
1013 digest
[11] = (l
>> 8) & 0xff;
1014 digest
[32] = (l
>> 0) & 0xff;
1016 l
= itoa64_to_int (buf
[48]) << 0;
1017 l
|= itoa64_to_int (buf
[49]) << 6;
1018 l
|= itoa64_to_int (buf
[50]) << 12;
1019 l
|= itoa64_to_int (buf
[51]) << 18;
1021 digest
[12] = (l
>> 16) & 0xff;
1022 digest
[33] = (l
>> 8) & 0xff;
1023 digest
[54] = (l
>> 0) & 0xff;
1025 l
= itoa64_to_int (buf
[52]) << 0;
1026 l
|= itoa64_to_int (buf
[53]) << 6;
1027 l
|= itoa64_to_int (buf
[54]) << 12;
1028 l
|= itoa64_to_int (buf
[55]) << 18;
1030 digest
[34] = (l
>> 16) & 0xff;
1031 digest
[55] = (l
>> 8) & 0xff;
1032 digest
[13] = (l
>> 0) & 0xff;
1034 l
= itoa64_to_int (buf
[56]) << 0;
1035 l
|= itoa64_to_int (buf
[57]) << 6;
1036 l
|= itoa64_to_int (buf
[58]) << 12;
1037 l
|= itoa64_to_int (buf
[59]) << 18;
1039 digest
[56] = (l
>> 16) & 0xff;
1040 digest
[14] = (l
>> 8) & 0xff;
1041 digest
[35] = (l
>> 0) & 0xff;
1043 l
= itoa64_to_int (buf
[60]) << 0;
1044 l
|= itoa64_to_int (buf
[61]) << 6;
1045 l
|= itoa64_to_int (buf
[62]) << 12;
1046 l
|= itoa64_to_int (buf
[63]) << 18;
1048 digest
[15] = (l
>> 16) & 0xff;
1049 digest
[36] = (l
>> 8) & 0xff;
1050 digest
[57] = (l
>> 0) & 0xff;
1052 l
= itoa64_to_int (buf
[64]) << 0;
1053 l
|= itoa64_to_int (buf
[65]) << 6;
1054 l
|= itoa64_to_int (buf
[66]) << 12;
1055 l
|= itoa64_to_int (buf
[67]) << 18;
1057 digest
[37] = (l
>> 16) & 0xff;
1058 digest
[58] = (l
>> 8) & 0xff;
1059 digest
[16] = (l
>> 0) & 0xff;
1061 l
= itoa64_to_int (buf
[68]) << 0;
1062 l
|= itoa64_to_int (buf
[69]) << 6;
1063 l
|= itoa64_to_int (buf
[70]) << 12;
1064 l
|= itoa64_to_int (buf
[71]) << 18;
1066 digest
[59] = (l
>> 16) & 0xff;
1067 digest
[17] = (l
>> 8) & 0xff;
1068 digest
[38] = (l
>> 0) & 0xff;
1070 l
= itoa64_to_int (buf
[72]) << 0;
1071 l
|= itoa64_to_int (buf
[73]) << 6;
1072 l
|= itoa64_to_int (buf
[74]) << 12;
1073 l
|= itoa64_to_int (buf
[75]) << 18;
1075 digest
[18] = (l
>> 16) & 0xff;
1076 digest
[39] = (l
>> 8) & 0xff;
1077 digest
[60] = (l
>> 0) & 0xff;
1079 l
= itoa64_to_int (buf
[76]) << 0;
1080 l
|= itoa64_to_int (buf
[77]) << 6;
1081 l
|= itoa64_to_int (buf
[78]) << 12;
1082 l
|= itoa64_to_int (buf
[79]) << 18;
1084 digest
[40] = (l
>> 16) & 0xff;
1085 digest
[61] = (l
>> 8) & 0xff;
1086 digest
[19] = (l
>> 0) & 0xff;
1088 l
= itoa64_to_int (buf
[80]) << 0;
1089 l
|= itoa64_to_int (buf
[81]) << 6;
1090 l
|= itoa64_to_int (buf
[82]) << 12;
1091 l
|= itoa64_to_int (buf
[83]) << 18;
1093 digest
[62] = (l
>> 16) & 0xff;
1094 digest
[20] = (l
>> 8) & 0xff;
1095 digest
[41] = (l
>> 0) & 0xff;
1097 l
= itoa64_to_int (buf
[84]) << 0;
1098 l
|= itoa64_to_int (buf
[85]) << 6;
1100 digest
[63] = (l
>> 0) & 0xff;
1103 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1107 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1109 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1110 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1111 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1114 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1116 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1117 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1118 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1121 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1123 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1125 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1128 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1130 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1132 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1135 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1137 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1139 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1142 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1144 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1146 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1149 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1151 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1153 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1156 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1158 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1160 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1163 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1165 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1167 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1170 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1172 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1174 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1177 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1179 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1181 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1184 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1186 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1188 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1191 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1193 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1195 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1198 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1200 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1202 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1205 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1207 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1209 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1212 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1214 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1216 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1219 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1221 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1223 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1226 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1228 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1230 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1233 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1235 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1237 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1240 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1242 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1244 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1247 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1249 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1251 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1254 l
= 0 | 0 | (digest
[63] << 0);
1256 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1257 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1260 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1264 l
= itoa64_to_int (buf
[ 0]) << 0;
1265 l
|= itoa64_to_int (buf
[ 1]) << 6;
1266 l
|= itoa64_to_int (buf
[ 2]) << 12;
1267 l
|= itoa64_to_int (buf
[ 3]) << 18;
1269 digest
[ 2] = (l
>> 0) & 0xff;
1270 digest
[ 1] = (l
>> 8) & 0xff;
1271 digest
[ 0] = (l
>> 16) & 0xff;
1273 l
= itoa64_to_int (buf
[ 4]) << 0;
1274 l
|= itoa64_to_int (buf
[ 5]) << 6;
1275 l
|= itoa64_to_int (buf
[ 6]) << 12;
1276 l
|= itoa64_to_int (buf
[ 7]) << 18;
1278 digest
[ 5] = (l
>> 0) & 0xff;
1279 digest
[ 4] = (l
>> 8) & 0xff;
1280 digest
[ 3] = (l
>> 16) & 0xff;
1282 l
= itoa64_to_int (buf
[ 8]) << 0;
1283 l
|= itoa64_to_int (buf
[ 9]) << 6;
1284 l
|= itoa64_to_int (buf
[10]) << 12;
1285 l
|= itoa64_to_int (buf
[11]) << 18;
1287 digest
[ 8] = (l
>> 0) & 0xff;
1288 digest
[ 7] = (l
>> 8) & 0xff;
1289 digest
[ 6] = (l
>> 16) & 0xff;
1291 l
= itoa64_to_int (buf
[12]) << 0;
1292 l
|= itoa64_to_int (buf
[13]) << 6;
1293 l
|= itoa64_to_int (buf
[14]) << 12;
1294 l
|= itoa64_to_int (buf
[15]) << 18;
1296 digest
[11] = (l
>> 0) & 0xff;
1297 digest
[10] = (l
>> 8) & 0xff;
1298 digest
[ 9] = (l
>> 16) & 0xff;
1300 l
= itoa64_to_int (buf
[16]) << 0;
1301 l
|= itoa64_to_int (buf
[17]) << 6;
1302 l
|= itoa64_to_int (buf
[18]) << 12;
1303 l
|= itoa64_to_int (buf
[19]) << 18;
1305 digest
[14] = (l
>> 0) & 0xff;
1306 digest
[13] = (l
>> 8) & 0xff;
1307 digest
[12] = (l
>> 16) & 0xff;
1309 l
= itoa64_to_int (buf
[20]) << 0;
1310 l
|= itoa64_to_int (buf
[21]) << 6;
1311 l
|= itoa64_to_int (buf
[22]) << 12;
1312 l
|= itoa64_to_int (buf
[23]) << 18;
1314 digest
[17] = (l
>> 0) & 0xff;
1315 digest
[16] = (l
>> 8) & 0xff;
1316 digest
[15] = (l
>> 16) & 0xff;
1318 l
= itoa64_to_int (buf
[24]) << 0;
1319 l
|= itoa64_to_int (buf
[25]) << 6;
1320 l
|= itoa64_to_int (buf
[26]) << 12;
1322 digest
[19] = (l
>> 8) & 0xff;
1323 digest
[18] = (l
>> 16) & 0xff;
1326 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1330 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1332 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1333 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1334 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1335 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1337 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1339 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1340 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1341 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1342 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1344 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1346 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1348 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1349 buf
[11] = int_to_itoa64 (l
& 0x3f);
1351 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1353 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1355 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1356 buf
[15] = int_to_itoa64 (l
& 0x3f);
1358 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1360 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1362 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1363 buf
[19] = int_to_itoa64 (l
& 0x3f);
1365 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1367 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1369 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1370 buf
[23] = int_to_itoa64 (l
& 0x3f);
1372 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1374 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1375 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1376 buf
[26] = int_to_itoa64 (l
& 0x3f);
1379 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1383 l
= itoa64_to_int (buf
[ 0]) << 0;
1384 l
|= itoa64_to_int (buf
[ 1]) << 6;
1385 l
|= itoa64_to_int (buf
[ 2]) << 12;
1386 l
|= itoa64_to_int (buf
[ 3]) << 18;
1388 digest
[ 2] = (l
>> 0) & 0xff;
1389 digest
[ 1] = (l
>> 8) & 0xff;
1390 digest
[ 0] = (l
>> 16) & 0xff;
1392 l
= itoa64_to_int (buf
[ 4]) << 0;
1393 l
|= itoa64_to_int (buf
[ 5]) << 6;
1394 l
|= itoa64_to_int (buf
[ 6]) << 12;
1395 l
|= itoa64_to_int (buf
[ 7]) << 18;
1397 digest
[ 5] = (l
>> 0) & 0xff;
1398 digest
[ 4] = (l
>> 8) & 0xff;
1399 digest
[ 3] = (l
>> 16) & 0xff;
1401 l
= itoa64_to_int (buf
[ 8]) << 0;
1402 l
|= itoa64_to_int (buf
[ 9]) << 6;
1403 l
|= itoa64_to_int (buf
[10]) << 12;
1404 l
|= itoa64_to_int (buf
[11]) << 18;
1406 digest
[ 8] = (l
>> 0) & 0xff;
1407 digest
[ 7] = (l
>> 8) & 0xff;
1408 digest
[ 6] = (l
>> 16) & 0xff;
1410 l
= itoa64_to_int (buf
[12]) << 0;
1411 l
|= itoa64_to_int (buf
[13]) << 6;
1412 l
|= itoa64_to_int (buf
[14]) << 12;
1413 l
|= itoa64_to_int (buf
[15]) << 18;
1415 digest
[11] = (l
>> 0) & 0xff;
1416 digest
[10] = (l
>> 8) & 0xff;
1417 digest
[ 9] = (l
>> 16) & 0xff;
1419 l
= itoa64_to_int (buf
[16]) << 0;
1420 l
|= itoa64_to_int (buf
[17]) << 6;
1421 l
|= itoa64_to_int (buf
[18]) << 12;
1422 l
|= itoa64_to_int (buf
[19]) << 18;
1424 digest
[14] = (l
>> 0) & 0xff;
1425 digest
[13] = (l
>> 8) & 0xff;
1426 digest
[12] = (l
>> 16) & 0xff;
1428 l
= itoa64_to_int (buf
[20]) << 0;
1429 l
|= itoa64_to_int (buf
[21]) << 6;
1430 l
|= itoa64_to_int (buf
[22]) << 12;
1431 l
|= itoa64_to_int (buf
[23]) << 18;
1433 digest
[17] = (l
>> 0) & 0xff;
1434 digest
[16] = (l
>> 8) & 0xff;
1435 digest
[15] = (l
>> 16) & 0xff;
1437 l
= itoa64_to_int (buf
[24]) << 0;
1438 l
|= itoa64_to_int (buf
[25]) << 6;
1439 l
|= itoa64_to_int (buf
[26]) << 12;
1440 l
|= itoa64_to_int (buf
[27]) << 18;
1442 digest
[20] = (l
>> 0) & 0xff;
1443 digest
[19] = (l
>> 8) & 0xff;
1444 digest
[18] = (l
>> 16) & 0xff;
1446 l
= itoa64_to_int (buf
[28]) << 0;
1447 l
|= itoa64_to_int (buf
[29]) << 6;
1448 l
|= itoa64_to_int (buf
[30]) << 12;
1449 l
|= itoa64_to_int (buf
[31]) << 18;
1451 digest
[23] = (l
>> 0) & 0xff;
1452 digest
[22] = (l
>> 8) & 0xff;
1453 digest
[21] = (l
>> 16) & 0xff;
1455 l
= itoa64_to_int (buf
[32]) << 0;
1456 l
|= itoa64_to_int (buf
[33]) << 6;
1457 l
|= itoa64_to_int (buf
[34]) << 12;
1458 l
|= itoa64_to_int (buf
[35]) << 18;
1460 digest
[26] = (l
>> 0) & 0xff;
1461 digest
[25] = (l
>> 8) & 0xff;
1462 digest
[24] = (l
>> 16) & 0xff;
1464 l
= itoa64_to_int (buf
[36]) << 0;
1465 l
|= itoa64_to_int (buf
[37]) << 6;
1466 l
|= itoa64_to_int (buf
[38]) << 12;
1467 l
|= itoa64_to_int (buf
[39]) << 18;
1469 digest
[29] = (l
>> 0) & 0xff;
1470 digest
[28] = (l
>> 8) & 0xff;
1471 digest
[27] = (l
>> 16) & 0xff;
1473 l
= itoa64_to_int (buf
[40]) << 0;
1474 l
|= itoa64_to_int (buf
[41]) << 6;
1475 l
|= itoa64_to_int (buf
[42]) << 12;
1477 //digest[32] = (l >> 0) & 0xff;
1478 digest
[31] = (l
>> 8) & 0xff;
1479 digest
[30] = (l
>> 16) & 0xff;
1482 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1486 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1488 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1489 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1490 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1491 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1493 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1495 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1496 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1497 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1498 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1500 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1502 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1504 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1505 buf
[11] = int_to_itoa64 (l
& 0x3f);
1507 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1509 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1511 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1512 buf
[15] = int_to_itoa64 (l
& 0x3f);
1514 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1516 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1518 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1519 buf
[19] = int_to_itoa64 (l
& 0x3f);
1521 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1523 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1525 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1526 buf
[23] = int_to_itoa64 (l
& 0x3f);
1528 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1530 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1532 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1533 buf
[27] = int_to_itoa64 (l
& 0x3f);
1535 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1537 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1539 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1540 buf
[31] = int_to_itoa64 (l
& 0x3f);
1542 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1544 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1546 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1547 buf
[35] = int_to_itoa64 (l
& 0x3f);
1549 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1551 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1553 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1554 buf
[39] = int_to_itoa64 (l
& 0x3f);
1556 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1558 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1559 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1560 buf
[42] = int_to_itoa64 (l
& 0x3f);
1563 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1567 l
= itoa64_to_int (buf
[ 0]) << 0;
1568 l
|= itoa64_to_int (buf
[ 1]) << 6;
1569 l
|= itoa64_to_int (buf
[ 2]) << 12;
1570 l
|= itoa64_to_int (buf
[ 3]) << 18;
1572 digest
[ 2] = (l
>> 0) & 0xff;
1573 digest
[ 1] = (l
>> 8) & 0xff;
1574 digest
[ 0] = (l
>> 16) & 0xff;
1576 l
= itoa64_to_int (buf
[ 4]) << 0;
1577 l
|= itoa64_to_int (buf
[ 5]) << 6;
1578 l
|= itoa64_to_int (buf
[ 6]) << 12;
1579 l
|= itoa64_to_int (buf
[ 7]) << 18;
1581 digest
[ 5] = (l
>> 0) & 0xff;
1582 digest
[ 4] = (l
>> 8) & 0xff;
1583 digest
[ 3] = (l
>> 16) & 0xff;
1585 l
= itoa64_to_int (buf
[ 8]) << 0;
1586 l
|= itoa64_to_int (buf
[ 9]) << 6;
1587 l
|= itoa64_to_int (buf
[10]) << 12;
1588 l
|= itoa64_to_int (buf
[11]) << 18;
1590 digest
[ 8] = (l
>> 0) & 0xff;
1591 digest
[ 7] = (l
>> 8) & 0xff;
1592 digest
[ 6] = (l
>> 16) & 0xff;
1594 l
= itoa64_to_int (buf
[12]) << 0;
1595 l
|= itoa64_to_int (buf
[13]) << 6;
1596 l
|= itoa64_to_int (buf
[14]) << 12;
1597 l
|= itoa64_to_int (buf
[15]) << 18;
1599 digest
[11] = (l
>> 0) & 0xff;
1600 digest
[10] = (l
>> 8) & 0xff;
1601 digest
[ 9] = (l
>> 16) & 0xff;
1603 l
= itoa64_to_int (buf
[16]) << 0;
1604 l
|= itoa64_to_int (buf
[17]) << 6;
1605 l
|= itoa64_to_int (buf
[18]) << 12;
1606 l
|= itoa64_to_int (buf
[19]) << 18;
1608 digest
[14] = (l
>> 0) & 0xff;
1609 digest
[13] = (l
>> 8) & 0xff;
1610 digest
[12] = (l
>> 16) & 0xff;
1612 l
= itoa64_to_int (buf
[20]) << 0;
1613 l
|= itoa64_to_int (buf
[21]) << 6;
1614 l
|= itoa64_to_int (buf
[22]) << 12;
1615 l
|= itoa64_to_int (buf
[23]) << 18;
1617 digest
[17] = (l
>> 0) & 0xff;
1618 digest
[16] = (l
>> 8) & 0xff;
1619 digest
[15] = (l
>> 16) & 0xff;
1621 l
= itoa64_to_int (buf
[24]) << 0;
1622 l
|= itoa64_to_int (buf
[25]) << 6;
1623 l
|= itoa64_to_int (buf
[26]) << 12;
1624 l
|= itoa64_to_int (buf
[27]) << 18;
1626 digest
[20] = (l
>> 0) & 0xff;
1627 digest
[19] = (l
>> 8) & 0xff;
1628 digest
[18] = (l
>> 16) & 0xff;
1630 l
= itoa64_to_int (buf
[28]) << 0;
1631 l
|= itoa64_to_int (buf
[29]) << 6;
1632 l
|= itoa64_to_int (buf
[30]) << 12;
1633 l
|= itoa64_to_int (buf
[31]) << 18;
1635 digest
[23] = (l
>> 0) & 0xff;
1636 digest
[22] = (l
>> 8) & 0xff;
1637 digest
[21] = (l
>> 16) & 0xff;
1639 l
= itoa64_to_int (buf
[32]) << 0;
1640 l
|= itoa64_to_int (buf
[33]) << 6;
1641 l
|= itoa64_to_int (buf
[34]) << 12;
1642 l
|= itoa64_to_int (buf
[35]) << 18;
1644 digest
[26] = (l
>> 0) & 0xff;
1645 digest
[25] = (l
>> 8) & 0xff;
1646 digest
[24] = (l
>> 16) & 0xff;
1648 l
= itoa64_to_int (buf
[36]) << 0;
1649 l
|= itoa64_to_int (buf
[37]) << 6;
1650 l
|= itoa64_to_int (buf
[38]) << 12;
1651 l
|= itoa64_to_int (buf
[39]) << 18;
1653 digest
[29] = (l
>> 0) & 0xff;
1654 digest
[28] = (l
>> 8) & 0xff;
1655 digest
[27] = (l
>> 16) & 0xff;
1657 l
= itoa64_to_int (buf
[40]) << 0;
1658 l
|= itoa64_to_int (buf
[41]) << 6;
1659 l
|= itoa64_to_int (buf
[42]) << 12;
1660 l
|= itoa64_to_int (buf
[43]) << 18;
1662 digest
[32] = (l
>> 0) & 0xff;
1663 digest
[31] = (l
>> 8) & 0xff;
1664 digest
[30] = (l
>> 16) & 0xff;
1666 l
= itoa64_to_int (buf
[44]) << 0;
1667 l
|= itoa64_to_int (buf
[45]) << 6;
1668 l
|= itoa64_to_int (buf
[46]) << 12;
1669 l
|= itoa64_to_int (buf
[47]) << 18;
1671 digest
[35] = (l
>> 0) & 0xff;
1672 digest
[34] = (l
>> 8) & 0xff;
1673 digest
[33] = (l
>> 16) & 0xff;
1675 l
= itoa64_to_int (buf
[48]) << 0;
1676 l
|= itoa64_to_int (buf
[49]) << 6;
1677 l
|= itoa64_to_int (buf
[50]) << 12;
1678 l
|= itoa64_to_int (buf
[51]) << 18;
1680 digest
[38] = (l
>> 0) & 0xff;
1681 digest
[37] = (l
>> 8) & 0xff;
1682 digest
[36] = (l
>> 16) & 0xff;
1684 l
= itoa64_to_int (buf
[52]) << 0;
1685 l
|= itoa64_to_int (buf
[53]) << 6;
1686 l
|= itoa64_to_int (buf
[54]) << 12;
1687 l
|= itoa64_to_int (buf
[55]) << 18;
1689 digest
[41] = (l
>> 0) & 0xff;
1690 digest
[40] = (l
>> 8) & 0xff;
1691 digest
[39] = (l
>> 16) & 0xff;
1693 l
= itoa64_to_int (buf
[56]) << 0;
1694 l
|= itoa64_to_int (buf
[57]) << 6;
1695 l
|= itoa64_to_int (buf
[58]) << 12;
1696 l
|= itoa64_to_int (buf
[59]) << 18;
1698 digest
[44] = (l
>> 0) & 0xff;
1699 digest
[43] = (l
>> 8) & 0xff;
1700 digest
[42] = (l
>> 16) & 0xff;
1702 l
= itoa64_to_int (buf
[60]) << 0;
1703 l
|= itoa64_to_int (buf
[61]) << 6;
1704 l
|= itoa64_to_int (buf
[62]) << 12;
1705 l
|= itoa64_to_int (buf
[63]) << 18;
1707 digest
[47] = (l
>> 0) & 0xff;
1708 digest
[46] = (l
>> 8) & 0xff;
1709 digest
[45] = (l
>> 16) & 0xff;
1711 l
= itoa64_to_int (buf
[64]) << 0;
1712 l
|= itoa64_to_int (buf
[65]) << 6;
1713 l
|= itoa64_to_int (buf
[66]) << 12;
1714 l
|= itoa64_to_int (buf
[67]) << 18;
1716 digest
[50] = (l
>> 0) & 0xff;
1717 digest
[49] = (l
>> 8) & 0xff;
1718 digest
[48] = (l
>> 16) & 0xff;
1720 l
= itoa64_to_int (buf
[68]) << 0;
1721 l
|= itoa64_to_int (buf
[69]) << 6;
1722 l
|= itoa64_to_int (buf
[70]) << 12;
1723 l
|= itoa64_to_int (buf
[71]) << 18;
1725 digest
[53] = (l
>> 0) & 0xff;
1726 digest
[52] = (l
>> 8) & 0xff;
1727 digest
[51] = (l
>> 16) & 0xff;
1729 l
= itoa64_to_int (buf
[72]) << 0;
1730 l
|= itoa64_to_int (buf
[73]) << 6;
1731 l
|= itoa64_to_int (buf
[74]) << 12;
1732 l
|= itoa64_to_int (buf
[75]) << 18;
1734 digest
[56] = (l
>> 0) & 0xff;
1735 digest
[55] = (l
>> 8) & 0xff;
1736 digest
[54] = (l
>> 16) & 0xff;
1738 l
= itoa64_to_int (buf
[76]) << 0;
1739 l
|= itoa64_to_int (buf
[77]) << 6;
1740 l
|= itoa64_to_int (buf
[78]) << 12;
1741 l
|= itoa64_to_int (buf
[79]) << 18;
1743 digest
[59] = (l
>> 0) & 0xff;
1744 digest
[58] = (l
>> 8) & 0xff;
1745 digest
[57] = (l
>> 16) & 0xff;
1747 l
= itoa64_to_int (buf
[80]) << 0;
1748 l
|= itoa64_to_int (buf
[81]) << 6;
1749 l
|= itoa64_to_int (buf
[82]) << 12;
1750 l
|= itoa64_to_int (buf
[83]) << 18;
1752 digest
[62] = (l
>> 0) & 0xff;
1753 digest
[61] = (l
>> 8) & 0xff;
1754 digest
[60] = (l
>> 16) & 0xff;
1756 l
= itoa64_to_int (buf
[84]) << 0;
1757 l
|= itoa64_to_int (buf
[85]) << 6;
1759 digest
[63] = (l
>> 16) & 0xff;
1762 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1766 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1768 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1769 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1770 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1771 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1773 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1775 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1776 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1777 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1778 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1780 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1782 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1784 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1785 buf
[11] = int_to_itoa64 (l
& 0x3f);
1787 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1789 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1791 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1792 buf
[15] = int_to_itoa64 (l
& 0x3f);
1794 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1796 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1798 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1799 buf
[19] = int_to_itoa64 (l
& 0x3f);
1801 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1803 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1805 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1806 buf
[23] = int_to_itoa64 (l
& 0x3f);
1808 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1810 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1812 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1813 buf
[27] = int_to_itoa64 (l
& 0x3f);
1815 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1817 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1819 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1820 buf
[31] = int_to_itoa64 (l
& 0x3f);
1822 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1824 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1826 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1827 buf
[35] = int_to_itoa64 (l
& 0x3f);
1829 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1831 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1833 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1834 buf
[39] = int_to_itoa64 (l
& 0x3f);
1836 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1838 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1840 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1841 buf
[43] = int_to_itoa64 (l
& 0x3f);
1843 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1845 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1847 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1848 buf
[47] = int_to_itoa64 (l
& 0x3f);
1850 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1852 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1854 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1855 buf
[51] = int_to_itoa64 (l
& 0x3f);
1857 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1859 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1861 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1862 buf
[55] = int_to_itoa64 (l
& 0x3f);
1864 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1866 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1868 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1869 buf
[59] = int_to_itoa64 (l
& 0x3f);
1871 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1873 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1875 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1876 buf
[63] = int_to_itoa64 (l
& 0x3f);
1878 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1880 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1882 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1883 buf
[67] = int_to_itoa64 (l
& 0x3f);
1885 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1887 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1889 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1890 buf
[71] = int_to_itoa64 (l
& 0x3f);
1892 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1894 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1896 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1897 buf
[75] = int_to_itoa64 (l
& 0x3f);
1899 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1901 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1903 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1904 buf
[79] = int_to_itoa64 (l
& 0x3f);
1906 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1908 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1910 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1911 buf
[83] = int_to_itoa64 (l
& 0x3f);
1913 l
= 0 | 0 | (digest
[63] << 16);
1915 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1916 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1919 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1923 l
= itoa64_to_int (buf
[ 0]) << 0;
1924 l
|= itoa64_to_int (buf
[ 1]) << 6;
1925 l
|= itoa64_to_int (buf
[ 2]) << 12;
1926 l
|= itoa64_to_int (buf
[ 3]) << 18;
1928 digest
[ 0] = (l
>> 16) & 0xff;
1929 digest
[10] = (l
>> 8) & 0xff;
1930 digest
[20] = (l
>> 0) & 0xff;
1932 l
= itoa64_to_int (buf
[ 4]) << 0;
1933 l
|= itoa64_to_int (buf
[ 5]) << 6;
1934 l
|= itoa64_to_int (buf
[ 6]) << 12;
1935 l
|= itoa64_to_int (buf
[ 7]) << 18;
1937 digest
[21] = (l
>> 16) & 0xff;
1938 digest
[ 1] = (l
>> 8) & 0xff;
1939 digest
[11] = (l
>> 0) & 0xff;
1941 l
= itoa64_to_int (buf
[ 8]) << 0;
1942 l
|= itoa64_to_int (buf
[ 9]) << 6;
1943 l
|= itoa64_to_int (buf
[10]) << 12;
1944 l
|= itoa64_to_int (buf
[11]) << 18;
1946 digest
[12] = (l
>> 16) & 0xff;
1947 digest
[22] = (l
>> 8) & 0xff;
1948 digest
[ 2] = (l
>> 0) & 0xff;
1950 l
= itoa64_to_int (buf
[12]) << 0;
1951 l
|= itoa64_to_int (buf
[13]) << 6;
1952 l
|= itoa64_to_int (buf
[14]) << 12;
1953 l
|= itoa64_to_int (buf
[15]) << 18;
1955 digest
[ 3] = (l
>> 16) & 0xff;
1956 digest
[13] = (l
>> 8) & 0xff;
1957 digest
[23] = (l
>> 0) & 0xff;
1959 l
= itoa64_to_int (buf
[16]) << 0;
1960 l
|= itoa64_to_int (buf
[17]) << 6;
1961 l
|= itoa64_to_int (buf
[18]) << 12;
1962 l
|= itoa64_to_int (buf
[19]) << 18;
1964 digest
[24] = (l
>> 16) & 0xff;
1965 digest
[ 4] = (l
>> 8) & 0xff;
1966 digest
[14] = (l
>> 0) & 0xff;
1968 l
= itoa64_to_int (buf
[20]) << 0;
1969 l
|= itoa64_to_int (buf
[21]) << 6;
1970 l
|= itoa64_to_int (buf
[22]) << 12;
1971 l
|= itoa64_to_int (buf
[23]) << 18;
1973 digest
[15] = (l
>> 16) & 0xff;
1974 digest
[25] = (l
>> 8) & 0xff;
1975 digest
[ 5] = (l
>> 0) & 0xff;
1977 l
= itoa64_to_int (buf
[24]) << 0;
1978 l
|= itoa64_to_int (buf
[25]) << 6;
1979 l
|= itoa64_to_int (buf
[26]) << 12;
1980 l
|= itoa64_to_int (buf
[27]) << 18;
1982 digest
[ 6] = (l
>> 16) & 0xff;
1983 digest
[16] = (l
>> 8) & 0xff;
1984 digest
[26] = (l
>> 0) & 0xff;
1986 l
= itoa64_to_int (buf
[28]) << 0;
1987 l
|= itoa64_to_int (buf
[29]) << 6;
1988 l
|= itoa64_to_int (buf
[30]) << 12;
1989 l
|= itoa64_to_int (buf
[31]) << 18;
1991 digest
[27] = (l
>> 16) & 0xff;
1992 digest
[ 7] = (l
>> 8) & 0xff;
1993 digest
[17] = (l
>> 0) & 0xff;
1995 l
= itoa64_to_int (buf
[32]) << 0;
1996 l
|= itoa64_to_int (buf
[33]) << 6;
1997 l
|= itoa64_to_int (buf
[34]) << 12;
1998 l
|= itoa64_to_int (buf
[35]) << 18;
2000 digest
[18] = (l
>> 16) & 0xff;
2001 digest
[28] = (l
>> 8) & 0xff;
2002 digest
[ 8] = (l
>> 0) & 0xff;
2004 l
= itoa64_to_int (buf
[36]) << 0;
2005 l
|= itoa64_to_int (buf
[37]) << 6;
2006 l
|= itoa64_to_int (buf
[38]) << 12;
2007 l
|= itoa64_to_int (buf
[39]) << 18;
2009 digest
[ 9] = (l
>> 16) & 0xff;
2010 digest
[19] = (l
>> 8) & 0xff;
2011 digest
[29] = (l
>> 0) & 0xff;
2013 l
= itoa64_to_int (buf
[40]) << 0;
2014 l
|= itoa64_to_int (buf
[41]) << 6;
2015 l
|= itoa64_to_int (buf
[42]) << 12;
2017 digest
[31] = (l
>> 8) & 0xff;
2018 digest
[30] = (l
>> 0) & 0xff;
2021 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2025 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2027 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2028 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2029 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2032 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2034 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2035 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2036 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2039 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2041 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2043 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2046 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2048 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2050 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2053 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2055 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2057 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2060 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2062 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2064 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2067 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2069 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2071 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2074 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2076 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2078 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2081 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2083 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2085 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2088 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2090 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2092 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2095 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2097 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2098 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2099 buf
[42] = int_to_itoa64 (l
& 0x3f);
2102 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2106 l
= itoa64_to_int (buf
[ 0]) << 0;
2107 l
|= itoa64_to_int (buf
[ 1]) << 6;
2108 l
|= itoa64_to_int (buf
[ 2]) << 12;
2109 l
|= itoa64_to_int (buf
[ 3]) << 18;
2111 digest
[ 0] = (l
>> 0) & 0xff;
2112 digest
[ 1] = (l
>> 8) & 0xff;
2113 digest
[ 2] = (l
>> 16) & 0xff;
2115 l
= itoa64_to_int (buf
[ 4]) << 0;
2116 l
|= itoa64_to_int (buf
[ 5]) << 6;
2117 l
|= itoa64_to_int (buf
[ 6]) << 12;
2118 l
|= itoa64_to_int (buf
[ 7]) << 18;
2120 digest
[ 3] = (l
>> 0) & 0xff;
2121 digest
[ 4] = (l
>> 8) & 0xff;
2122 digest
[ 5] = (l
>> 16) & 0xff;
2124 l
= itoa64_to_int (buf
[ 8]) << 0;
2125 l
|= itoa64_to_int (buf
[ 9]) << 6;
2126 l
|= itoa64_to_int (buf
[10]) << 12;
2127 l
|= itoa64_to_int (buf
[11]) << 18;
2129 digest
[ 6] = (l
>> 0) & 0xff;
2130 digest
[ 7] = (l
>> 8) & 0xff;
2131 digest
[ 8] = (l
>> 16) & 0xff;
2133 l
= itoa64_to_int (buf
[12]) << 0;
2134 l
|= itoa64_to_int (buf
[13]) << 6;
2135 l
|= itoa64_to_int (buf
[14]) << 12;
2136 l
|= itoa64_to_int (buf
[15]) << 18;
2138 digest
[ 9] = (l
>> 0) & 0xff;
2139 digest
[10] = (l
>> 8) & 0xff;
2140 digest
[11] = (l
>> 16) & 0xff;
2142 l
= itoa64_to_int (buf
[16]) << 0;
2143 l
|= itoa64_to_int (buf
[17]) << 6;
2144 l
|= itoa64_to_int (buf
[18]) << 12;
2145 l
|= itoa64_to_int (buf
[19]) << 18;
2147 digest
[12] = (l
>> 0) & 0xff;
2148 digest
[13] = (l
>> 8) & 0xff;
2149 digest
[14] = (l
>> 16) & 0xff;
2151 l
= itoa64_to_int (buf
[20]) << 0;
2152 l
|= itoa64_to_int (buf
[21]) << 6;
2153 l
|= itoa64_to_int (buf
[22]) << 12;
2154 l
|= itoa64_to_int (buf
[23]) << 18;
2156 digest
[15] = (l
>> 0) & 0xff;
2157 digest
[16] = (l
>> 8) & 0xff;
2158 digest
[17] = (l
>> 16) & 0xff;
2160 l
= itoa64_to_int (buf
[24]) << 0;
2161 l
|= itoa64_to_int (buf
[25]) << 6;
2162 l
|= itoa64_to_int (buf
[26]) << 12;
2163 l
|= itoa64_to_int (buf
[27]) << 18;
2165 digest
[18] = (l
>> 0) & 0xff;
2166 digest
[19] = (l
>> 8) & 0xff;
2167 digest
[20] = (l
>> 16) & 0xff;
2169 l
= itoa64_to_int (buf
[28]) << 0;
2170 l
|= itoa64_to_int (buf
[29]) << 6;
2171 l
|= itoa64_to_int (buf
[30]) << 12;
2172 l
|= itoa64_to_int (buf
[31]) << 18;
2174 digest
[21] = (l
>> 0) & 0xff;
2175 digest
[22] = (l
>> 8) & 0xff;
2176 digest
[23] = (l
>> 16) & 0xff;
2178 l
= itoa64_to_int (buf
[32]) << 0;
2179 l
|= itoa64_to_int (buf
[33]) << 6;
2180 l
|= itoa64_to_int (buf
[34]) << 12;
2181 l
|= itoa64_to_int (buf
[35]) << 18;
2183 digest
[24] = (l
>> 0) & 0xff;
2184 digest
[25] = (l
>> 8) & 0xff;
2185 digest
[26] = (l
>> 16) & 0xff;
2187 l
= itoa64_to_int (buf
[36]) << 0;
2188 l
|= itoa64_to_int (buf
[37]) << 6;
2189 l
|= itoa64_to_int (buf
[38]) << 12;
2190 l
|= itoa64_to_int (buf
[39]) << 18;
2192 digest
[27] = (l
>> 0) & 0xff;
2193 digest
[28] = (l
>> 8) & 0xff;
2194 digest
[29] = (l
>> 16) & 0xff;
2196 l
= itoa64_to_int (buf
[40]) << 0;
2197 l
|= itoa64_to_int (buf
[41]) << 6;
2198 l
|= itoa64_to_int (buf
[42]) << 12;
2199 l
|= itoa64_to_int (buf
[43]) << 18;
2201 digest
[30] = (l
>> 0) & 0xff;
2202 digest
[31] = (l
>> 8) & 0xff;
2203 digest
[32] = (l
>> 16) & 0xff;
2238 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2242 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2244 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2245 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2246 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2247 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2249 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2251 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2252 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2253 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2254 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2256 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2258 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2260 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2261 buf
[11] = int_to_itoa64 (l
& 0x3f);
2263 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2265 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2267 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2268 buf
[15] = int_to_itoa64 (l
& 0x3f);
2270 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2272 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2274 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2275 buf
[19] = int_to_itoa64 (l
& 0x3f);
2277 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2279 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2281 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2282 buf
[23] = int_to_itoa64 (l
& 0x3f);
2284 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2286 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2288 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2289 buf
[27] = int_to_itoa64 (l
& 0x3f);
2291 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2293 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2295 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2296 buf
[31] = int_to_itoa64 (l
& 0x3f);
2298 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2300 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2302 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2303 buf
[35] = int_to_itoa64 (l
& 0x3f);
2305 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2307 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2309 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2310 buf
[39] = int_to_itoa64 (l
& 0x3f);
2312 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2314 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2315 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2316 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2317 //buf[43] = int_to_itoa64 (l & 0x3f);
2325 static struct termio savemodes
;
2326 static int havemodes
= 0;
2330 struct termio modmodes
;
2332 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2336 modmodes
= savemodes
;
2337 modmodes
.c_lflag
&= ~ICANON
;
2338 modmodes
.c_cc
[VMIN
] = 1;
2339 modmodes
.c_cc
[VTIME
] = 0;
2341 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2350 FD_SET (fileno (stdin
), &rfds
);
2357 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2359 if (retval
== 0) return 0;
2360 if (retval
== -1) return -1;
2367 if (!havemodes
) return 0;
2369 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2374 static struct termios savemodes
;
2375 static int havemodes
= 0;
2379 struct termios modmodes
;
2381 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2385 modmodes
= savemodes
;
2386 modmodes
.c_lflag
&= ~ICANON
;
2387 modmodes
.c_cc
[VMIN
] = 1;
2388 modmodes
.c_cc
[VTIME
] = 0;
2390 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2399 FD_SET (fileno (stdin
), &rfds
);
2406 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2408 if (retval
== 0) return 0;
2409 if (retval
== -1) return -1;
2416 if (!havemodes
) return 0;
2418 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2423 static DWORD saveMode
= 0;
2427 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2429 GetConsoleMode (stdinHandle
, &saveMode
);
2430 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2437 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2439 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2441 if (rc
== WAIT_TIMEOUT
) return 0;
2442 if (rc
== WAIT_ABANDONED
) return -1;
2443 if (rc
== WAIT_FAILED
) return -1;
2445 // The whole ReadConsoleInput () part is a workaround.
2446 // For some unknown reason, maybe a mingw bug, a random signal
2447 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2448 // Then it wants to read with getche () a keyboard input
2449 // which has never been made.
2451 INPUT_RECORD buf
[100];
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 sprintf (topid
, "TOP%08x", id
);
2615 char *logfile_generate_subid ()
2617 const int id
= logfile_generate_id ();
2619 char *subid
= (char *) mymalloc (1 + 16 + 1);
2621 sprintf (subid
, "SUB%08x", id
);
2633 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2635 FlushFileBuffers (h
);
2644 #if defined(_WIN) && defined(HAVE_NVAPI)
2645 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2649 if (hc_NvAPI_EnumPhysicalGPUs (nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2653 log_info ("WARN: No NvAPI adapters found");
2660 #endif // _WIN && HAVE_NVAPI
2662 #if defined(LINUX) && defined(HAVE_NVML)
2663 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2667 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2669 if (hc_NVML_nvmlDeviceGetHandleByIndex (data
.hm_dll_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2671 // can be used to determine if the device by index matches the cuda device by index
2672 // char name[100]; memset (name, 0, sizeof (name));
2673 // hc_NVML_nvmlDeviceGetName (data.hm_dll_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2680 log_info ("WARN: No NVML adapters found");
2687 #endif // LINUX && HAVE_NVML
2689 #if defined(HAVE_ADL) || defined(HAVE_NVML)
2690 void hm_close (HM_LIB hm_dll
)
2696 FreeLibrary (hm_dll
);
2701 HM_LIB
hm_init (const cl_uint vendor_id
)
2703 HM_LIB hm_dll
= NULL
;
2706 if (vendor_id
== VENDOR_ID_AMD
)
2709 hm_dll
= dlopen ("libatiadlxx.so", RTLD_LAZY
| RTLD_GLOBAL
);
2712 hm_dll
= LoadLibrary ("atiadlxx.dll");
2716 hm_dll
= LoadLibrary ("atiadlxy.dll");
2723 #if defined(LINUX) && defined(HAVE_NVML)
2724 if (vendor_id
== VENDOR_ID_NV
)
2726 hm_dll
= dlopen ("libnvidia-ml.so", RTLD_LAZY
| RTLD_GLOBAL
);
2732 #endif // HAVE_ADL || HAVE_NVML
2735 int get_adapters_num_amd (HM_LIB hm_dll_amd
, int *iNumberAdapters
)
2737 if (hc_ADL_Adapter_NumberOfAdapters_Get (hm_dll_amd
, iNumberAdapters
) != ADL_OK
) return -1;
2739 if (iNumberAdapters
== 0)
2741 log_info ("WARN: No ADL adapters found.");
2750 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2752 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2753 ADLODParameters lpOdParameters;
2755 lpOdParameters.iSize = sizeof (ADLODParameters);
2756 size_t plevels_size = 0;
2758 if (hc_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2760 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2761 __func__, iAdapterIndex,
2762 lpOdParameters.iNumberOfPerformanceLevels,
2763 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2764 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2766 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2768 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2770 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2772 if (hc_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2774 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2775 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2776 __func__, iAdapterIndex, j,
2777 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2779 myfree (lpOdPerformanceLevels);
2785 LPAdapterInfo
hm_get_adapter_info_amd (HM_LIB hm_dll_amd
, int iNumberAdapters
)
2787 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2789 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2791 if (hc_ADL_Adapter_AdapterInfo_Get (hm_dll_amd
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2793 return lpAdapterInfo
;
2798 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2801 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2805 for (uint i = 0; i < num_adl_adapters; i++)
2807 int opencl_bus_num = hm_device[i].busid;
2808 int opencl_dev_num = hm_device[i].devid;
2810 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2818 if (idx >= DEVICES_MAX) return -1;
2823 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2825 for (uint i = 0; i < opencl_num_devices; i++)
2827 cl_device_topology_amd device_topology;
2829 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2831 hm_device[i].busid = device_topology.pcie.bus;
2832 hm_device[i].devid = device_topology.pcie.device;
2837 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2839 // basically bubble sort
2841 for (int i
= 0; i
< num_adl_adapters
; i
++)
2843 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2845 // get info of adapter [x]
2847 u32 adapter_index_x
= valid_adl_device_list
[j
];
2848 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2850 u32 bus_num_x
= info_x
.iBusNumber
;
2851 u32 dev_num_x
= info_x
.iDeviceNumber
;
2853 // get info of adapter [y]
2855 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2856 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2858 u32 bus_num_y
= info_y
.iBusNumber
;
2859 u32 dev_num_y
= info_y
.iDeviceNumber
;
2863 if (bus_num_y
< bus_num_x
)
2867 else if (bus_num_y
== bus_num_x
)
2869 if (dev_num_y
< dev_num_x
)
2877 u32 temp
= valid_adl_device_list
[j
+ 1];
2879 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2880 valid_adl_device_list
[j
+ 0] = temp
;
2886 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2888 *num_adl_adapters
= 0;
2890 u32
*adl_adapters
= NULL
;
2892 int *bus_numbers
= NULL
;
2893 int *device_numbers
= NULL
;
2895 for (int i
= 0; i
< iNumberAdapters
; i
++)
2897 AdapterInfo info
= lpAdapterInfo
[i
];
2899 if (strlen (info
.strUDID
) < 1) continue;
2902 if (info
.iVendorID
!= 1002) continue;
2904 if (info
.iVendorID
!= 0x1002) continue;
2907 if (info
.iBusNumber
< 0) continue;
2908 if (info
.iDeviceNumber
< 0) continue;
2912 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2914 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2921 if (found
) continue;
2923 // add it to the list
2925 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2927 adl_adapters
[*num_adl_adapters
] = i
;
2929 // rest is just bookkeeping
2931 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2932 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2934 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2935 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2937 (*num_adl_adapters
)++;
2940 myfree (bus_numbers
);
2941 myfree (device_numbers
);
2943 // sort the list by increasing bus id, device id number
2945 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2947 return adl_adapters
;
2950 int hm_check_fanspeed_control (HM_LIB hm_dll_amd
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2952 // loop through all valid devices
2954 for (int i
= 0; i
< num_adl_adapters
; i
++)
2956 u32 adapter_index
= valid_adl_device_list
[i
];
2960 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2962 // unfortunately this doesn't work since bus id and dev id are not unique
2963 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2964 // if (opencl_device_index == -1) continue;
2966 int opencl_device_index
= i
;
2968 // if (hm_show_performance_level (hm_dll_amd, info.iAdapterIndex) != 0) return -1;
2970 // get fanspeed info
2972 if (hm_device
[opencl_device_index
].od_version
== 5)
2974 ADLFanSpeedInfo FanSpeedInfo
;
2976 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2978 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2980 if (hc_ADL_Overdrive5_FanSpeedInfo_Get (hm_dll_amd
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2982 // check read and write capability in fanspeedinfo
2984 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2985 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2987 hm_device
[opencl_device_index
].fan_supported
= 1;
2991 hm_device
[opencl_device_index
].fan_supported
= 0;
2994 else // od_version == 6
2996 ADLOD6FanSpeedInfo faninfo
;
2998 memset (&faninfo
, 0, sizeof (faninfo
));
3000 if (hc_ADL_Overdrive6_FanSpeed_Get (hm_dll_amd
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
3002 // check read capability in fanspeedinfo
3004 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
3006 hm_device
[opencl_device_index
].fan_supported
= 1;
3010 hm_device
[opencl_device_index
].fan_supported
= 0;
3018 int hm_get_overdrive_version (HM_LIB hm_dll_amd
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3020 for (int i
= 0; i
< num_adl_adapters
; i
++)
3022 u32 adapter_index
= valid_adl_device_list
[i
];
3026 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3028 // get overdrive version
3030 int od_supported
= 0;
3034 if (hc_ADL_Overdrive_Caps (hm_dll_amd
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3036 // store the overdrive version in hm_device
3038 // unfortunately this doesn't work since bus id and dev id are not unique
3039 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3040 // if (opencl_device_index == -1) continue;
3042 int opencl_device_index
= i
;
3044 hm_device
[opencl_device_index
].od_version
= od_version
;
3050 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3052 for (int i
= 0; i
< num_adl_adapters
; i
++)
3054 u32 adapter_index
= valid_adl_device_list
[i
];
3058 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3060 // store the iAdapterIndex in hm_device
3062 // unfortunately this doesn't work since bus id and dev id are not unique
3063 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3064 // if (opencl_device_index == -1) continue;
3066 int opencl_device_index
= i
;
3068 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3071 return num_adl_adapters
;
3075 int hm_get_temperature_with_device_id (const uint device_id
)
3077 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3080 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3082 if (data
.hm_dll_amd
)
3084 if (data
.hm_device
[device_id
].od_version
== 5)
3086 ADLTemperature Temperature
;
3088 Temperature
.iSize
= sizeof (ADLTemperature
);
3090 if (hc_ADL_Overdrive5_Temperature_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3092 return Temperature
.iTemperature
/ 1000;
3094 else if (data
.hm_device
[device_id
].od_version
== 6)
3096 int Temperature
= 0;
3098 if (hc_ADL_Overdrive6_Temperature_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3100 return Temperature
/ 1000;
3106 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3107 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3109 #if defined(LINUX) && defined(HAVE_NVML)
3110 int temperature
= 0;
3112 hc_NVML_nvmlDeviceGetTemperature (data
.hm_dll_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3117 #if defined(WIN) && defined(HAVE_NVAPI)
3118 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3120 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3121 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3122 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3123 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3125 if (hc_NvAPI_GPU_GetThermalSettings (data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3127 return pThermalSettings
.sensor
[0].currentTemp
;
3128 #endif // WIN && HAVE_NVAPI
3130 #endif // HAVE_NVML || HAVE_NVAPI
3135 int hm_get_fanspeed_with_device_id (const uint device_id
)
3137 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3138 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3140 if (data
.hm_device
[device_id
].fan_supported
== 1)
3143 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3145 if (data
.hm_dll_amd
)
3147 if (data
.hm_device
[device_id
].od_version
== 5)
3149 ADLFanSpeedValue lpFanSpeedValue
;
3151 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3153 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3154 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3155 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3157 if (hc_ADL_Overdrive5_FanSpeed_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3159 return lpFanSpeedValue
.iFanSpeed
;
3161 else // od_version == 6
3163 ADLOD6FanSpeedInfo faninfo
;
3165 memset (&faninfo
, 0, sizeof (faninfo
));
3167 if (hc_ADL_Overdrive6_FanSpeed_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3169 return faninfo
.iFanSpeedPercent
;
3175 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3176 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3178 #if defined(LINUX) && defined(HAVE_NVML)
3181 hc_NVML_nvmlDeviceGetFanSpeed (data
.hm_dll_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3186 #if defined(WIN) && defined(HAVE_NVAPI)
3189 hc_NvAPI_GPU_GetTachReading (data
.hm_device
[device_id
].adapter_index
.nv
, &speed
);
3194 #endif // HAVE_NVML || HAVE_NVAPI
3200 int hm_get_utilization_with_device_id (const uint device_id
)
3202 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3205 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3207 if (data
.hm_dll_amd
)
3209 ADLPMActivity PMActivity
;
3211 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3213 if (hc_ADL_Overdrive_CurrentActivity_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3215 return PMActivity
.iActivityPercent
;
3220 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3221 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3223 #if defined(LINUX) && defined(HAVE_NVML)
3224 nvmlUtilization_t utilization
;
3226 hc_NVML_nvmlDeviceGetUtilizationRates (data
.hm_dll_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3228 return utilization
.gpu
;
3231 #if defined(WIN) && defined(HAVE_NVAPI)
3232 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3234 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3236 if (hc_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3238 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3241 #endif // HAVE_NVML || HAVE_NVAPI
3247 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3249 if (data
.hm_device
[device_id
].fan_supported
== 1)
3251 if (data
.hm_dll_amd
)
3253 if (data
.hm_device
[device_id
].od_version
== 5)
3255 ADLFanSpeedValue lpFanSpeedValue
;
3257 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3259 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3260 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3261 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3262 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3264 if (hc_ADL_Overdrive5_FanSpeed_Set (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3268 else // od_version == 6
3270 ADLOD6FanSpeedValue fan_speed_value
;
3272 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3274 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3275 fan_speed_value
.iFanSpeed
= fanspeed
;
3277 if (hc_ADL_Overdrive6_FanSpeed_Set (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3288 // helper function for status display
3290 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3292 #define VALUE_NOT_AVAILABLE "N/A"
3296 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3300 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3303 #endif // HAVE_HWMON
3309 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3311 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3313 if (css_cnt
> SP_PW_MAX
)
3315 log_error ("ERROR: mask length is too long");
3320 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3322 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3324 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3325 uint cs_len
= css
[css_pos
].cs_len
;
3327 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3329 uint c
= cs_buf
[cs_pos
] & 0xff;
3336 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3338 cs_t
*cs
= &css
[css_cnt
];
3340 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3342 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3344 memset (css_uniq
, 0, css_uniq_sz
);
3348 for (i
= 0; i
< cs
->cs_len
; i
++)
3350 const uint u
= cs
->cs_buf
[i
];
3355 for (i
= 0; i
< in_len
; i
++)
3357 uint u
= in_buf
[i
] & 0xff;
3359 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3361 if (css_uniq
[u
] == 1) continue;
3365 cs
->cs_buf
[cs
->cs_len
] = u
;
3373 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3377 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3379 uint p0
= in_buf
[in_pos
] & 0xff;
3381 if (interpret
== 1 && p0
== '?')
3385 if (in_pos
== in_len
) break;
3387 uint p1
= in_buf
[in_pos
] & 0xff;
3391 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3393 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3395 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3397 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3399 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3401 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3403 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3404 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3406 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3407 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3409 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3410 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3412 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3413 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3415 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3417 default: log_error ("Syntax error: %s", in_buf
);
3423 if (data
.hex_charset
)
3427 if (in_pos
== in_len
)
3429 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3434 uint p1
= in_buf
[in_pos
] & 0xff;
3436 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3438 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3445 chr
= hex_convert (p1
) << 0;
3446 chr
|= hex_convert (p0
) << 4;
3448 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3454 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3460 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3464 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3466 sum
*= css
[css_pos
].cs_len
;
3472 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3474 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3479 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3481 char p0
= mask_buf
[mask_pos
];
3487 if (mask_pos
== mask_len
) break;
3489 char p1
= mask_buf
[mask_pos
];
3495 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3497 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3499 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3501 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3503 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3505 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3507 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3508 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3510 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3511 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3513 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3514 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3516 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3517 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3519 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3521 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3527 if (data
.hex_charset
)
3531 // if there is no 2nd hex character, show an error:
3533 if (mask_pos
== mask_len
)
3535 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3540 char p1
= mask_buf
[mask_pos
];
3542 // if they are not valid hex character, show an error:
3544 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3546 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3553 chr
|= hex_convert (p1
) << 0;
3554 chr
|= hex_convert (p0
) << 4;
3556 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3562 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3569 log_error ("ERROR: invalid mask length (0)");
3579 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3581 for (int i
= 0; i
< css_cnt
; i
++)
3583 uint len
= css
[i
].cs_len
;
3584 u64 next
= val
/ len
;
3585 uint pos
= val
% len
;
3586 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3591 void mp_cut_at (char *mask
, uint max
)
3595 uint mask_len
= strlen (mask
);
3597 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3599 if (mask
[i
] == '?') i
++;
3605 void mp_setup_sys (cs_t
*mp_sys
)
3609 uint donec
[CHARSIZ
];
3611 memset (donec
, 0, sizeof (donec
));
3613 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3614 mp_sys
[0].cs_buf
[pos
++] = chr
;
3615 mp_sys
[0].cs_len
= pos
; }
3617 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3618 mp_sys
[1].cs_buf
[pos
++] = chr
;
3619 mp_sys
[1].cs_len
= pos
; }
3621 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3622 mp_sys
[2].cs_buf
[pos
++] = chr
;
3623 mp_sys
[2].cs_len
= pos
; }
3625 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3626 mp_sys
[3].cs_buf
[pos
++] = chr
;
3627 mp_sys
[3].cs_len
= pos
; }
3629 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3630 mp_sys
[4].cs_len
= pos
; }
3632 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3633 mp_sys
[5].cs_len
= pos
; }
3636 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3638 FILE *fp
= fopen (buf
, "rb");
3640 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3642 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3648 memset (mp_file
, 0, sizeof (mp_file
));
3650 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3654 len
= in_superchop (mp_file
);
3658 log_info ("WARNING: charset file corrupted");
3660 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3664 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3669 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3671 mp_usr
[index
].cs_len
= 0;
3673 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3676 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3678 char *new_mask_buf
= (char *) mymalloc (256);
3684 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3686 if (css_pos
== len
) break;
3688 char p0
= mask_buf
[mask_pos
];
3690 new_mask_buf
[mask_pos
] = p0
;
3696 if (mask_pos
== mask_len
) break;
3698 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3702 if (data
.hex_charset
)
3706 if (mask_pos
== mask_len
)
3708 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3713 char p1
= mask_buf
[mask_pos
];
3715 // if they are not valid hex character, show an error:
3717 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3719 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3724 new_mask_buf
[mask_pos
] = p1
;
3729 if (css_pos
== len
) return (new_mask_buf
);
3731 myfree (new_mask_buf
);
3740 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3746 for (i
= start
; i
< stop
; i
++)
3748 sum
*= root_css_buf
[i
].cs_len
;
3754 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3758 cs_t
*cs
= &root_css_buf
[start
];
3762 for (i
= start
; i
< stop
; i
++)
3764 const u64 m
= v
% cs
->cs_len
;
3765 const u64 d
= v
/ cs
->cs_len
;
3769 const uint k
= cs
->cs_buf
[m
];
3771 pw_buf
[i
- start
] = (char) k
;
3773 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3777 int sp_comp_val (const void *p1
, const void *p2
)
3779 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3780 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3782 return b2
->val
- b1
->val
;
3785 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
)
3792 * Initialize hcstats
3795 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3797 u64
*root_stats_ptr
= root_stats_buf
;
3799 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3801 for (i
= 0; i
< SP_PW_MAX
; i
++)
3803 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3805 root_stats_ptr
+= CHARSIZ
;
3808 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3810 u64
*markov_stats_ptr
= markov_stats_buf
;
3812 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3814 for (i
= 0; i
< SP_PW_MAX
; i
++)
3816 for (j
= 0; j
< CHARSIZ
; j
++)
3818 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3820 markov_stats_ptr
+= CHARSIZ
;
3830 char hcstat_tmp
[256];
3832 memset (hcstat_tmp
, 0, sizeof (hcstat_tmp
));
3834 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3836 hcstat
= hcstat_tmp
;
3839 FILE *fd
= fopen (hcstat
, "rb");
3843 log_error ("%s: %s", hcstat
, strerror (errno
));
3848 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3850 log_error ("%s: Could not load data", hcstat
);
3855 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3857 log_error ("%s: Could not load data", hcstat
);
3865 * Markov modifier of hcstat_table on user request
3870 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3871 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3876 /* Add all stats to first position */
3878 for (i
= 1; i
< SP_PW_MAX
; i
++)
3880 u64
*out
= root_stats_buf_by_pos
[0];
3881 u64
*in
= root_stats_buf_by_pos
[i
];
3883 for (j
= 0; j
< CHARSIZ
; j
++)
3889 for (i
= 1; i
< SP_PW_MAX
; i
++)
3891 u64
*out
= markov_stats_buf_by_key
[0][0];
3892 u64
*in
= markov_stats_buf_by_key
[i
][0];
3894 for (j
= 0; j
< CHARSIZ
; j
++)
3896 for (k
= 0; k
< CHARSIZ
; k
++)
3903 /* copy them to all pw_positions */
3905 for (i
= 1; i
< SP_PW_MAX
; i
++)
3907 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3910 for (i
= 1; i
< SP_PW_MAX
; i
++)
3912 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3920 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3922 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3924 for (i
= 0; i
< SP_PW_MAX
; i
++)
3926 root_table_buf_by_pos
[i
] = root_table_ptr
;
3928 root_table_ptr
+= CHARSIZ
;
3931 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3933 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3935 for (i
= 0; i
< SP_PW_MAX
; i
++)
3937 for (j
= 0; j
< CHARSIZ
; j
++)
3939 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3941 markov_table_ptr
+= CHARSIZ
;
3946 * Convert hcstat to tables
3949 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3951 uint key
= i
% CHARSIZ
;
3953 root_table_buf
[i
].key
= key
;
3954 root_table_buf
[i
].val
= root_stats_buf
[i
];
3957 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3959 uint key
= i
% CHARSIZ
;
3961 markov_table_buf
[i
].key
= key
;
3962 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3965 myfree (root_stats_buf
);
3966 myfree (markov_stats_buf
);
3972 for (i
= 0; i
< SP_PW_MAX
; i
++)
3974 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3977 for (i
= 0; i
< SP_PW_MAX
; i
++)
3979 for (j
= 0; j
< CHARSIZ
; j
++)
3981 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3986 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
])
3989 * Convert tables to css
3992 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3994 uint pw_pos
= i
/ CHARSIZ
;
3996 cs_t
*cs
= &root_css_buf
[pw_pos
];
3998 if (cs
->cs_len
== threshold
) continue;
4000 uint key
= root_table_buf
[i
].key
;
4002 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4004 cs
->cs_buf
[cs
->cs_len
] = key
;
4010 * Convert table to css
4013 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4015 uint c
= i
/ CHARSIZ
;
4017 cs_t
*cs
= &markov_css_buf
[c
];
4019 if (cs
->cs_len
== threshold
) continue;
4021 uint pw_pos
= c
/ CHARSIZ
;
4023 uint key
= markov_table_buf
[i
].key
;
4025 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4027 cs
->cs_buf
[cs
->cs_len
] = key
;
4033 for (uint i = 0; i < 8; i++)
4035 for (uint j = 0x20; j < 0x80; j++)
4037 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4039 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4041 for (uint k = 0; k < 10; k++)
4043 printf (" %u\n", ptr->cs_buf[k]);
4050 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4052 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4054 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4064 for (uint j
= 1; j
< CHARSIZ
; j
++)
4074 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4076 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4078 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4080 out
+= CHARSIZ
* CHARSIZ
;
4081 in
+= CHARSIZ
* CHARSIZ
;
4083 for (uint j
= 0; j
< CHARSIZ
; j
++)
4090 for (uint k
= 1; k
< CHARSIZ
; k
++)
4102 * mixed shared functions
4105 void dump_hex (const u8
*s
, const int sz
)
4107 for (int i
= 0; i
< sz
; i
++)
4109 log_info_nn ("%02x ", s
[i
]);
4115 void usage_mini_print (const char *progname
)
4117 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4120 void usage_big_print (const char *progname
)
4122 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4125 char *get_exec_path ()
4127 int exec_path_len
= 1024;
4129 char *exec_path
= (char *) mymalloc (exec_path_len
);
4135 sprintf (tmp
, "/proc/%d/exe", getpid ());
4137 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4141 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4145 uint size
= exec_path_len
;
4147 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4149 log_error("! executable path buffer too small\n");
4154 const int len
= strlen (exec_path
);
4157 #error Your Operating System is not supported or detected
4165 char *get_install_dir (const char *progname
)
4167 char *install_dir
= mystrdup (progname
);
4168 char *last_slash
= NULL
;
4170 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4174 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4180 install_dir
[0] = '.';
4184 return (install_dir
);
4187 char *get_profile_dir (const char *homedir
)
4189 #define DOT_HASHCAT ".hashcat"
4191 char *profile_dir
= (char *) mymalloc (strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1);
4193 sprintf (profile_dir
, "%s/%s", homedir
, DOT_HASHCAT
);
4198 char *get_session_dir (const char *profile_dir
)
4200 #define SESSIONS_FOLDER "sessions"
4202 char *session_dir
= (char *) mymalloc (strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1);
4204 sprintf (session_dir
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4209 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4213 FILE *fd
= fopen (filename
, "rb");
4217 log_error ("%s: %s", filename
, strerror (errno
));
4222 #define MAX_KEY_SIZE (1024 * 1024)
4224 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4226 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4232 for (int fpos
= 0; fpos
< nread
; fpos
++)
4234 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4236 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4237 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4238 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4239 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4241 if (kpos
>= 64) kpos
= 0;
4247 void set_cpu_affinity (char *cpu_affinity
)
4250 DWORD_PTR aff_mask
= 0;
4258 char *devices
= strdup (cpu_affinity
);
4260 char *next
= strtok (devices
, ",");
4264 uint cpu_id
= atoi (next
);
4279 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4285 aff_mask
|= 1 << (cpu_id
- 1);
4287 CPU_SET ((cpu_id
- 1), &cpuset
);
4290 } while ((next
= strtok (NULL
, ",")) != NULL
);
4296 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4297 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4299 pthread_t thread
= pthread_self ();
4300 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4304 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4306 char *element
, *end
;
4308 end
= (char *) base
+ nmemb
* size
;
4310 for (element
= (char *) base
; element
< end
; element
+= size
)
4311 if (!compar (element
, key
))
4317 int sort_by_salt (const void *v1
, const void *v2
)
4319 const salt_t
*s1
= (const salt_t
*) v1
;
4320 const salt_t
*s2
= (const salt_t
*) v2
;
4322 const int res1
= s1
->salt_len
- s2
->salt_len
;
4324 if (res1
!= 0) return (res1
);
4326 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4328 if (res2
!= 0) return (res2
);
4336 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4337 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4344 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4345 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4351 int sort_by_salt_buf (const void *v1
, const void *v2
)
4353 const pot_t
*p1
= (const pot_t
*) v1
;
4354 const pot_t
*p2
= (const pot_t
*) v2
;
4356 const hash_t
*h1
= &p1
->hash
;
4357 const hash_t
*h2
= &p2
->hash
;
4359 const salt_t
*s1
= h1
->salt
;
4360 const salt_t
*s2
= h2
->salt
;
4366 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4367 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4373 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4375 const hash_t
*h1
= (const hash_t
*) v1
;
4376 const hash_t
*h2
= (const hash_t
*) v2
;
4378 const salt_t
*s1
= h1
->salt
;
4379 const salt_t
*s2
= h2
->salt
;
4381 // testphase: this should work
4386 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4387 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4390 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4391 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4392 if (s1->salt_len > s2->salt_len) return ( 1);
4393 if (s1->salt_len < s2->salt_len) return (-1);
4395 uint n = s1->salt_len;
4399 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4400 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4407 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4409 const hash_t
*h1
= (const hash_t
*) v1
;
4410 const hash_t
*h2
= (const hash_t
*) v2
;
4412 const salt_t
*s1
= h1
->salt
;
4413 const salt_t
*s2
= h2
->salt
;
4415 // 12 - 2 (since last 2 uints contain the digest)
4420 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4421 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4427 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4429 const hash_t
*h1
= (const hash_t
*) v1
;
4430 const hash_t
*h2
= (const hash_t
*) v2
;
4432 const void *d1
= h1
->digest
;
4433 const void *d2
= h2
->digest
;
4435 return data
.sort_by_digest (d1
, d2
);
4438 int sort_by_hash (const void *v1
, const void *v2
)
4440 const hash_t
*h1
= (const hash_t
*) v1
;
4441 const hash_t
*h2
= (const hash_t
*) v2
;
4445 const salt_t
*s1
= h1
->salt
;
4446 const salt_t
*s2
= h2
->salt
;
4448 int res
= sort_by_salt (s1
, s2
);
4450 if (res
!= 0) return (res
);
4453 const void *d1
= h1
->digest
;
4454 const void *d2
= h2
->digest
;
4456 return data
.sort_by_digest (d1
, d2
);
4459 int sort_by_pot (const void *v1
, const void *v2
)
4461 const pot_t
*p1
= (const pot_t
*) v1
;
4462 const pot_t
*p2
= (const pot_t
*) v2
;
4464 const hash_t
*h1
= &p1
->hash
;
4465 const hash_t
*h2
= &p2
->hash
;
4467 return sort_by_hash (h1
, h2
);
4470 int sort_by_mtime (const void *p1
, const void *p2
)
4472 const char **f1
= (const char **) p1
;
4473 const char **f2
= (const char **) p2
;
4475 struct stat s1
; stat (*f1
, &s1
);
4476 struct stat s2
; stat (*f2
, &s2
);
4478 return s2
.st_mtime
- s1
.st_mtime
;
4481 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4483 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4484 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4486 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4489 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4491 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4492 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4494 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4497 int sort_by_stringptr (const void *p1
, const void *p2
)
4499 const char **s1
= (const char **) p1
;
4500 const char **s2
= (const char **) p2
;
4502 return strcmp (*s1
, *s2
);
4505 int sort_by_dictstat (const void *s1
, const void *s2
)
4507 dictstat_t
*d1
= (dictstat_t
*) s1
;
4508 dictstat_t
*d2
= (dictstat_t
*) s2
;
4511 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4513 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4516 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4519 int sort_by_bitmap (const void *p1
, const void *p2
)
4521 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4522 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4524 return b1
->collisions
- b2
->collisions
;
4527 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4529 const u32
*d1
= (const u32
*) v1
;
4530 const u32
*d2
= (const u32
*) v2
;
4536 if (d1
[n
] > d2
[n
]) return ( 1);
4537 if (d1
[n
] < d2
[n
]) return (-1);
4543 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4545 const u32
*d1
= (const u32
*) v1
;
4546 const u32
*d2
= (const u32
*) v2
;
4552 if (d1
[n
] > d2
[n
]) return ( 1);
4553 if (d1
[n
] < d2
[n
]) return (-1);
4559 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4561 const u32
*d1
= (const u32
*) v1
;
4562 const u32
*d2
= (const u32
*) v2
;
4568 if (d1
[n
] > d2
[n
]) return ( 1);
4569 if (d1
[n
] < d2
[n
]) return (-1);
4575 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4577 const u32
*d1
= (const u32
*) v1
;
4578 const u32
*d2
= (const u32
*) v2
;
4584 if (d1
[n
] > d2
[n
]) return ( 1);
4585 if (d1
[n
] < d2
[n
]) return (-1);
4591 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4593 const u32
*d1
= (const u32
*) v1
;
4594 const u32
*d2
= (const u32
*) v2
;
4600 if (d1
[n
] > d2
[n
]) return ( 1);
4601 if (d1
[n
] < d2
[n
]) return (-1);
4607 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4609 const u32
*d1
= (const u32
*) v1
;
4610 const u32
*d2
= (const u32
*) v2
;
4616 if (d1
[n
] > d2
[n
]) return ( 1);
4617 if (d1
[n
] < d2
[n
]) return (-1);
4623 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4625 const u32
*d1
= (const u32
*) v1
;
4626 const u32
*d2
= (const u32
*) v2
;
4632 if (d1
[n
] > d2
[n
]) return ( 1);
4633 if (d1
[n
] < d2
[n
]) return (-1);
4639 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4641 const u32
*d1
= (const u32
*) v1
;
4642 const u32
*d2
= (const u32
*) v2
;
4648 if (d1
[n
] > d2
[n
]) return ( 1);
4649 if (d1
[n
] < d2
[n
]) return (-1);
4655 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4657 const u64
*d1
= (const u64
*) v1
;
4658 const u64
*d2
= (const u64
*) v2
;
4664 if (d1
[n
] > d2
[n
]) return ( 1);
4665 if (d1
[n
] < d2
[n
]) return (-1);
4671 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4673 const u64
*d1
= (const u64
*) v1
;
4674 const u64
*d2
= (const u64
*) v2
;
4680 if (d1
[n
] > d2
[n
]) return ( 1);
4681 if (d1
[n
] < d2
[n
]) return (-1);
4687 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4689 const u64
*d1
= (const u64
*) v1
;
4690 const u64
*d2
= (const u64
*) v2
;
4696 if (d1
[n
] > d2
[n
]) return ( 1);
4697 if (d1
[n
] < d2
[n
]) return (-1);
4703 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4705 const u32
*d1
= (const u32
*) v1
;
4706 const u32
*d2
= (const u32
*) v2
;
4708 const uint dgst_pos0
= data
.dgst_pos0
;
4709 const uint dgst_pos1
= data
.dgst_pos1
;
4710 const uint dgst_pos2
= data
.dgst_pos2
;
4711 const uint dgst_pos3
= data
.dgst_pos3
;
4713 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4714 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4715 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4716 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4717 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4718 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4719 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4720 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4725 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
)
4727 uint outfile_autohex
= data
.outfile_autohex
;
4729 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4731 FILE *debug_fp
= NULL
;
4733 if (debug_file
!= NULL
)
4735 debug_fp
= fopen (debug_file
, "ab");
4742 if (debug_fp
== NULL
)
4744 log_info ("WARNING: Could not open debug-file for writing");
4748 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4750 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4752 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4755 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4757 if (debug_mode
== 4)
4759 fputc (':', debug_fp
);
4761 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4764 fputc ('\n', debug_fp
);
4766 if (debug_file
!= NULL
) fclose (debug_fp
);
4770 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4772 int needs_hexify
= 0;
4774 if (outfile_autohex
== 1)
4776 for (uint i
= 0; i
< plain_len
; i
++)
4778 if (plain_ptr
[i
] < 0x20)
4785 if (plain_ptr
[i
] > 0x7f)
4794 if (needs_hexify
== 1)
4796 fprintf (fp
, "$HEX[");
4798 for (uint i
= 0; i
< plain_len
; i
++)
4800 fprintf (fp
, "%02x", plain_ptr
[i
]);
4807 fwrite (plain_ptr
, plain_len
, 1, fp
);
4811 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
)
4813 uint outfile_format
= data
.outfile_format
;
4815 char separator
= data
.separator
;
4817 if (outfile_format
& OUTFILE_FMT_HASH
)
4819 fprintf (out_fp
, "%s", out_buf
);
4821 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4823 fputc (separator
, out_fp
);
4826 else if (data
.username
)
4828 if (username
!= NULL
)
4830 for (uint i
= 0; i
< user_len
; i
++)
4832 fprintf (out_fp
, "%c", username
[i
]);
4835 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4837 fputc (separator
, out_fp
);
4842 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4844 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4846 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4848 fputc (separator
, out_fp
);
4852 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4854 for (uint i
= 0; i
< plain_len
; i
++)
4856 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4859 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4861 fputc (separator
, out_fp
);
4865 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4868 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4873 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4875 fprintf (out_fp
, "%llu", crackpos
);
4880 fputc ('\n', out_fp
);
4883 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
)
4887 pot_key
.hash
.salt
= hashes_buf
->salt
;
4888 pot_key
.hash
.digest
= hashes_buf
->digest
;
4890 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4896 input_buf
[input_len
] = 0;
4899 unsigned char *username
= NULL
;
4904 user_t
*user
= hashes_buf
->hash_info
->user
;
4908 username
= (unsigned char *) (user
->user_name
);
4910 user_len
= user
->user_len
;
4914 // do output the line
4915 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4919 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4920 #define LM_MASKED_PLAIN "[notfound]"
4922 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
)
4928 pot_left_key
.hash
.salt
= hash_left
->salt
;
4929 pot_left_key
.hash
.digest
= hash_left
->digest
;
4931 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4935 uint weak_hash_found
= 0;
4937 pot_t pot_right_key
;
4939 pot_right_key
.hash
.salt
= hash_right
->salt
;
4940 pot_right_key
.hash
.digest
= hash_right
->digest
;
4942 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4944 if (pot_right_ptr
== NULL
)
4946 // special case, if "weak hash"
4948 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4950 weak_hash_found
= 1;
4952 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4954 // in theory this is not needed, but we are paranoia:
4956 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4957 pot_right_ptr
->plain_len
= 0;
4961 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4963 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
4968 // at least one half was found:
4972 input_buf
[input_len
] = 0;
4976 unsigned char *username
= NULL
;
4981 user_t
*user
= hash_left
->hash_info
->user
;
4985 username
= (unsigned char *) (user
->user_name
);
4987 user_len
= user
->user_len
;
4991 // mask the part which was not found
4993 uint left_part_masked
= 0;
4994 uint right_part_masked
= 0;
4996 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
4998 if (pot_left_ptr
== NULL
)
5000 left_part_masked
= 1;
5002 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5004 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5006 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5007 pot_left_ptr
->plain_len
= mask_plain_len
;
5010 if (pot_right_ptr
== NULL
)
5012 right_part_masked
= 1;
5014 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5016 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5018 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5019 pot_right_ptr
->plain_len
= mask_plain_len
;
5022 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5026 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5028 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5030 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5032 // do output the line
5034 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5036 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5038 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5039 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5042 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
)
5046 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5048 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5050 if (pot_ptr
== NULL
)
5054 input_buf
[input_len
] = 0;
5056 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5060 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
)
5066 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5068 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5072 pot_t pot_right_key
;
5074 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5076 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5078 uint weak_hash_found
= 0;
5080 if (pot_right_ptr
== NULL
)
5082 // special case, if "weak hash"
5084 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5086 weak_hash_found
= 1;
5088 // we just need that pot_right_ptr is not a NULL pointer
5090 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5094 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5096 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5101 // ... at least one part was not cracked
5105 input_buf
[input_len
] = 0;
5107 // only show the hash part which is still not cracked
5109 uint user_len
= input_len
- 32;
5111 char *hash_output
= (char *) mymalloc (33);
5113 memcpy (hash_output
, input_buf
, input_len
);
5115 if (pot_left_ptr
!= NULL
)
5117 // only show right part (because left part was already found)
5119 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5121 hash_output
[user_len
+ 16] = 0;
5124 if (pot_right_ptr
!= NULL
)
5126 // only show left part (because right part was already found)
5128 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5130 hash_output
[user_len
+ 16] = 0;
5133 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5135 myfree (hash_output
);
5137 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5140 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5142 uint opencl_platforms_filter
= 0;
5144 if (opencl_platforms
)
5146 char *platforms
= strdup (opencl_platforms
);
5148 char *next
= strtok (platforms
, ",");
5152 int platform
= atoi (next
);
5154 if (platform
< 1 || platform
> 32)
5156 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5161 opencl_platforms_filter
|= 1 << (platform
- 1);
5163 } while ((next
= strtok (NULL
, ",")) != NULL
);
5169 opencl_platforms_filter
= -1;
5172 return opencl_platforms_filter
;
5175 u32
setup_devices_filter (char *opencl_devices
)
5177 u32 devices_filter
= 0;
5181 char *devices
= strdup (opencl_devices
);
5183 char *next
= strtok (devices
, ",");
5187 int device_id
= atoi (next
);
5189 if (device_id
< 1 || device_id
> 32)
5191 log_error ("ERROR: invalid device_id %u specified", device_id
);
5196 devices_filter
|= 1 << (device_id
- 1);
5198 } while ((next
= strtok (NULL
, ",")) != NULL
);
5204 devices_filter
= -1;
5207 return devices_filter
;
5210 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5212 cl_device_type device_types_filter
= 0;
5214 if (opencl_device_types
)
5216 char *device_types
= strdup (opencl_device_types
);
5218 char *next
= strtok (device_types
, ",");
5222 int device_type
= atoi (next
);
5224 if (device_type
< 1 || device_type
> 3)
5226 log_error ("ERROR: invalid device_type %u specified", device_type
);
5231 device_types_filter
|= 1 << device_type
;
5233 } while ((next
= strtok (NULL
, ",")) != NULL
);
5235 free (device_types
);
5239 // Do not use CPU by default, this often reduces GPU performance because
5240 // the CPU is too busy to handle GPU synchronization
5242 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5245 return device_types_filter
;
5248 u32
get_random_num (const u32 min
, const u32 max
)
5250 if (min
== max
) return (min
);
5252 return ((rand () % (max
- min
)) + min
);
5255 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5257 u32 quotient
= dividend
/ divisor
;
5259 if (dividend
% divisor
) quotient
++;
5264 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5266 u64 quotient
= dividend
/ divisor
;
5268 if (dividend
% divisor
) quotient
++;
5273 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5275 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5276 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5278 if (tm
->tm_year
- 70)
5280 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5281 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5283 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5285 else if (tm
->tm_yday
)
5287 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5288 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5290 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5292 else if (tm
->tm_hour
)
5294 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5295 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5297 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5299 else if (tm
->tm_min
)
5301 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5302 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5304 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5308 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5310 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5314 void format_speed_display (float val
, char *buf
, size_t len
)
5325 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5336 /* generate output */
5340 snprintf (buf
, len
- 1, "%.0f ", val
);
5344 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5348 void lowercase (u8
*buf
, int len
)
5350 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5353 void uppercase (u8
*buf
, int len
)
5355 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5358 int fgetl (FILE *fp
, char *line_buf
)
5364 const int c
= fgetc (fp
);
5366 if (c
== EOF
) break;
5368 line_buf
[line_len
] = (char) c
;
5372 if (line_len
== BUFSIZ
) line_len
--;
5374 if (c
== '\n') break;
5377 if (line_len
== 0) return 0;
5379 if (line_buf
[line_len
- 1] == '\n')
5383 line_buf
[line_len
] = 0;
5386 if (line_len
== 0) return 0;
5388 if (line_buf
[line_len
- 1] == '\r')
5392 line_buf
[line_len
] = 0;
5398 int in_superchop (char *buf
)
5400 int len
= strlen (buf
);
5404 if (buf
[len
- 1] == '\n')
5411 if (buf
[len
- 1] == '\r')
5426 char **scan_directory (const char *path
)
5428 char *tmp_path
= mystrdup (path
);
5430 size_t tmp_path_len
= strlen (tmp_path
);
5432 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5434 tmp_path
[tmp_path_len
- 1] = 0;
5436 tmp_path_len
= strlen (tmp_path
);
5439 char **files
= NULL
;
5445 if ((d
= opendir (tmp_path
)) != NULL
)
5451 memset (&e
, 0, sizeof (e
));
5452 struct dirent
*de
= NULL
;
5454 if (readdir_r (d
, &e
, &de
) != 0)
5456 log_error ("ERROR: readdir_r() failed");
5461 if (de
== NULL
) break;
5465 while ((de
= readdir (d
)) != NULL
)
5468 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5470 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5472 char *path_file
= (char *) mymalloc (path_size
+ 1);
5474 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5476 path_file
[path_size
] = 0;
5480 if ((d_test
= opendir (path_file
)) != NULL
)
5488 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5492 files
[num_files
- 1] = path_file
;
5498 else if (errno
== ENOTDIR
)
5500 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5504 files
[num_files
- 1] = mystrdup (path
);
5507 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5511 files
[num_files
- 1] = NULL
;
5518 int count_dictionaries (char **dictionary_files
)
5520 if (dictionary_files
== NULL
) return 0;
5524 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5532 char *stroptitype (const uint opti_type
)
5536 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5537 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5538 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5539 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5540 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5541 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5542 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5543 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5544 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5545 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5546 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5547 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5548 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5549 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5555 char *strparser (const uint parser_status
)
5557 switch (parser_status
)
5559 case PARSER_OK
: return ((char *) PA_000
); break;
5560 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5561 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5562 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5563 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5564 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5565 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5566 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5567 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5568 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5569 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5570 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5571 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5572 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5573 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5574 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5575 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5578 return ((char *) PA_255
);
5581 char *strhashtype (const uint hash_mode
)
5585 case 0: return ((char *) HT_00000
); break;
5586 case 10: return ((char *) HT_00010
); break;
5587 case 11: return ((char *) HT_00011
); break;
5588 case 12: return ((char *) HT_00012
); break;
5589 case 20: return ((char *) HT_00020
); break;
5590 case 21: return ((char *) HT_00021
); break;
5591 case 22: return ((char *) HT_00022
); break;
5592 case 23: return ((char *) HT_00023
); break;
5593 case 30: return ((char *) HT_00030
); break;
5594 case 40: return ((char *) HT_00040
); break;
5595 case 50: return ((char *) HT_00050
); break;
5596 case 60: return ((char *) HT_00060
); break;
5597 case 100: return ((char *) HT_00100
); break;
5598 case 101: return ((char *) HT_00101
); break;
5599 case 110: return ((char *) HT_00110
); break;
5600 case 111: return ((char *) HT_00111
); break;
5601 case 112: return ((char *) HT_00112
); break;
5602 case 120: return ((char *) HT_00120
); break;
5603 case 121: return ((char *) HT_00121
); break;
5604 case 122: return ((char *) HT_00122
); break;
5605 case 124: return ((char *) HT_00124
); break;
5606 case 130: return ((char *) HT_00130
); break;
5607 case 131: return ((char *) HT_00131
); break;
5608 case 132: return ((char *) HT_00132
); break;
5609 case 133: return ((char *) HT_00133
); break;
5610 case 140: return ((char *) HT_00140
); break;
5611 case 141: return ((char *) HT_00141
); break;
5612 case 150: return ((char *) HT_00150
); break;
5613 case 160: return ((char *) HT_00160
); break;
5614 case 190: return ((char *) HT_00190
); break;
5615 case 200: return ((char *) HT_00200
); break;
5616 case 300: return ((char *) HT_00300
); break;
5617 case 400: return ((char *) HT_00400
); break;
5618 case 500: return ((char *) HT_00500
); break;
5619 case 501: return ((char *) HT_00501
); break;
5620 case 900: return ((char *) HT_00900
); break;
5621 case 910: return ((char *) HT_00910
); break;
5622 case 1000: return ((char *) HT_01000
); break;
5623 case 1100: return ((char *) HT_01100
); break;
5624 case 1400: return ((char *) HT_01400
); break;
5625 case 1410: return ((char *) HT_01410
); break;
5626 case 1420: return ((char *) HT_01420
); break;
5627 case 1421: return ((char *) HT_01421
); break;
5628 case 1430: return ((char *) HT_01430
); break;
5629 case 1440: return ((char *) HT_01440
); break;
5630 case 1441: return ((char *) HT_01441
); break;
5631 case 1450: return ((char *) HT_01450
); break;
5632 case 1460: return ((char *) HT_01460
); break;
5633 case 1500: return ((char *) HT_01500
); break;
5634 case 1600: return ((char *) HT_01600
); break;
5635 case 1700: return ((char *) HT_01700
); break;
5636 case 1710: return ((char *) HT_01710
); break;
5637 case 1711: return ((char *) HT_01711
); break;
5638 case 1720: return ((char *) HT_01720
); break;
5639 case 1722: return ((char *) HT_01722
); break;
5640 case 1730: return ((char *) HT_01730
); break;
5641 case 1731: return ((char *) HT_01731
); break;
5642 case 1740: return ((char *) HT_01740
); break;
5643 case 1750: return ((char *) HT_01750
); break;
5644 case 1760: return ((char *) HT_01760
); break;
5645 case 1800: return ((char *) HT_01800
); break;
5646 case 2100: return ((char *) HT_02100
); break;
5647 case 2400: return ((char *) HT_02400
); break;
5648 case 2410: return ((char *) HT_02410
); break;
5649 case 2500: return ((char *) HT_02500
); break;
5650 case 2600: return ((char *) HT_02600
); break;
5651 case 2611: return ((char *) HT_02611
); break;
5652 case 2612: return ((char *) HT_02612
); break;
5653 case 2711: return ((char *) HT_02711
); break;
5654 case 2811: return ((char *) HT_02811
); break;
5655 case 3000: return ((char *) HT_03000
); break;
5656 case 3100: return ((char *) HT_03100
); break;
5657 case 3200: return ((char *) HT_03200
); break;
5658 case 3710: return ((char *) HT_03710
); break;
5659 case 3711: return ((char *) HT_03711
); break;
5660 case 3800: return ((char *) HT_03800
); break;
5661 case 4300: return ((char *) HT_04300
); break;
5662 case 4400: return ((char *) HT_04400
); break;
5663 case 4500: return ((char *) HT_04500
); break;
5664 case 4700: return ((char *) HT_04700
); break;
5665 case 4800: return ((char *) HT_04800
); break;
5666 case 4900: return ((char *) HT_04900
); break;
5667 case 5000: return ((char *) HT_05000
); break;
5668 case 5100: return ((char *) HT_05100
); break;
5669 case 5200: return ((char *) HT_05200
); break;
5670 case 5300: return ((char *) HT_05300
); break;
5671 case 5400: return ((char *) HT_05400
); break;
5672 case 5500: return ((char *) HT_05500
); break;
5673 case 5600: return ((char *) HT_05600
); break;
5674 case 5700: return ((char *) HT_05700
); break;
5675 case 5800: return ((char *) HT_05800
); break;
5676 case 6000: return ((char *) HT_06000
); break;
5677 case 6100: return ((char *) HT_06100
); break;
5678 case 6211: return ((char *) HT_06211
); break;
5679 case 6212: return ((char *) HT_06212
); break;
5680 case 6213: return ((char *) HT_06213
); break;
5681 case 6221: return ((char *) HT_06221
); break;
5682 case 6222: return ((char *) HT_06222
); break;
5683 case 6223: return ((char *) HT_06223
); break;
5684 case 6231: return ((char *) HT_06231
); break;
5685 case 6232: return ((char *) HT_06232
); break;
5686 case 6233: return ((char *) HT_06233
); break;
5687 case 6241: return ((char *) HT_06241
); break;
5688 case 6242: return ((char *) HT_06242
); break;
5689 case 6243: return ((char *) HT_06243
); break;
5690 case 6300: return ((char *) HT_06300
); break;
5691 case 6400: return ((char *) HT_06400
); break;
5692 case 6500: return ((char *) HT_06500
); break;
5693 case 6600: return ((char *) HT_06600
); break;
5694 case 6700: return ((char *) HT_06700
); break;
5695 case 6800: return ((char *) HT_06800
); break;
5696 case 6900: return ((char *) HT_06900
); break;
5697 case 7100: return ((char *) HT_07100
); break;
5698 case 7200: return ((char *) HT_07200
); break;
5699 case 7300: return ((char *) HT_07300
); break;
5700 case 7400: return ((char *) HT_07400
); break;
5701 case 7500: return ((char *) HT_07500
); break;
5702 case 7600: return ((char *) HT_07600
); break;
5703 case 7700: return ((char *) HT_07700
); break;
5704 case 7800: return ((char *) HT_07800
); break;
5705 case 7900: return ((char *) HT_07900
); break;
5706 case 8000: return ((char *) HT_08000
); break;
5707 case 8100: return ((char *) HT_08100
); break;
5708 case 8200: return ((char *) HT_08200
); break;
5709 case 8300: return ((char *) HT_08300
); break;
5710 case 8400: return ((char *) HT_08400
); break;
5711 case 8500: return ((char *) HT_08500
); break;
5712 case 8600: return ((char *) HT_08600
); break;
5713 case 8700: return ((char *) HT_08700
); break;
5714 case 8800: return ((char *) HT_08800
); break;
5715 case 8900: return ((char *) HT_08900
); break;
5716 case 9000: return ((char *) HT_09000
); break;
5717 case 9100: return ((char *) HT_09100
); break;
5718 case 9200: return ((char *) HT_09200
); break;
5719 case 9300: return ((char *) HT_09300
); break;
5720 case 9400: return ((char *) HT_09400
); break;
5721 case 9500: return ((char *) HT_09500
); break;
5722 case 9600: return ((char *) HT_09600
); break;
5723 case 9700: return ((char *) HT_09700
); break;
5724 case 9710: return ((char *) HT_09710
); break;
5725 case 9720: return ((char *) HT_09720
); break;
5726 case 9800: return ((char *) HT_09800
); break;
5727 case 9810: return ((char *) HT_09810
); break;
5728 case 9820: return ((char *) HT_09820
); break;
5729 case 9900: return ((char *) HT_09900
); break;
5730 case 10000: return ((char *) HT_10000
); break;
5731 case 10100: return ((char *) HT_10100
); break;
5732 case 10200: return ((char *) HT_10200
); break;
5733 case 10300: return ((char *) HT_10300
); break;
5734 case 10400: return ((char *) HT_10400
); break;
5735 case 10410: return ((char *) HT_10410
); break;
5736 case 10420: return ((char *) HT_10420
); break;
5737 case 10500: return ((char *) HT_10500
); break;
5738 case 10600: return ((char *) HT_10600
); break;
5739 case 10700: return ((char *) HT_10700
); break;
5740 case 10800: return ((char *) HT_10800
); break;
5741 case 10900: return ((char *) HT_10900
); break;
5742 case 11000: return ((char *) HT_11000
); break;
5743 case 11100: return ((char *) HT_11100
); break;
5744 case 11200: return ((char *) HT_11200
); break;
5745 case 11300: return ((char *) HT_11300
); break;
5746 case 11400: return ((char *) HT_11400
); break;
5747 case 11500: return ((char *) HT_11500
); break;
5748 case 11600: return ((char *) HT_11600
); break;
5749 case 11700: return ((char *) HT_11700
); break;
5750 case 11800: return ((char *) HT_11800
); break;
5751 case 11900: return ((char *) HT_11900
); break;
5752 case 12000: return ((char *) HT_12000
); break;
5753 case 12100: return ((char *) HT_12100
); break;
5754 case 12200: return ((char *) HT_12200
); break;
5755 case 12300: return ((char *) HT_12300
); break;
5756 case 12400: return ((char *) HT_12400
); break;
5757 case 12500: return ((char *) HT_12500
); break;
5758 case 12600: return ((char *) HT_12600
); break;
5759 case 12700: return ((char *) HT_12700
); break;
5760 case 12800: return ((char *) HT_12800
); break;
5761 case 12900: return ((char *) HT_12900
); break;
5762 case 13000: return ((char *) HT_13000
); break;
5765 return ((char *) "Unknown");
5768 char *strstatus (const uint devices_status
)
5770 switch (devices_status
)
5772 case STATUS_INIT
: return ((char *) ST_0000
); break;
5773 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5774 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5775 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5776 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5777 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5778 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5779 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5780 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5781 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5784 return ((char *) "Unknown");
5787 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5789 uint hash_type
= data
.hash_type
;
5790 uint hash_mode
= data
.hash_mode
;
5791 uint salt_type
= data
.salt_type
;
5792 uint opts_type
= data
.opts_type
;
5793 uint opti_type
= data
.opti_type
;
5794 uint dgst_size
= data
.dgst_size
;
5796 char *hashfile
= data
.hashfile
;
5800 uint digest_buf
[64];
5802 u64
*digest_buf64
= (u64
*) digest_buf
;
5804 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5806 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5808 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5814 case HASH_TYPE_DESCRYPT
:
5815 FP (digest_buf
[1], digest_buf
[0], tt
);
5818 case HASH_TYPE_DESRACF
:
5819 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5820 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5822 FP (digest_buf
[1], digest_buf
[0], tt
);
5826 FP (digest_buf
[1], digest_buf
[0], tt
);
5829 case HASH_TYPE_NETNTLM
:
5830 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5831 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5832 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5833 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5835 FP (digest_buf
[1], digest_buf
[0], tt
);
5836 FP (digest_buf
[3], digest_buf
[2], tt
);
5839 case HASH_TYPE_BSDICRYPT
:
5840 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5841 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5843 FP (digest_buf
[1], digest_buf
[0], tt
);
5848 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5853 digest_buf
[0] += MD4M_A
;
5854 digest_buf
[1] += MD4M_B
;
5855 digest_buf
[2] += MD4M_C
;
5856 digest_buf
[3] += MD4M_D
;
5860 digest_buf
[0] += MD5M_A
;
5861 digest_buf
[1] += MD5M_B
;
5862 digest_buf
[2] += MD5M_C
;
5863 digest_buf
[3] += MD5M_D
;
5866 case HASH_TYPE_SHA1
:
5867 digest_buf
[0] += SHA1M_A
;
5868 digest_buf
[1] += SHA1M_B
;
5869 digest_buf
[2] += SHA1M_C
;
5870 digest_buf
[3] += SHA1M_D
;
5871 digest_buf
[4] += SHA1M_E
;
5874 case HASH_TYPE_SHA256
:
5875 digest_buf
[0] += SHA256M_A
;
5876 digest_buf
[1] += SHA256M_B
;
5877 digest_buf
[2] += SHA256M_C
;
5878 digest_buf
[3] += SHA256M_D
;
5879 digest_buf
[4] += SHA256M_E
;
5880 digest_buf
[5] += SHA256M_F
;
5881 digest_buf
[6] += SHA256M_G
;
5882 digest_buf
[7] += SHA256M_H
;
5885 case HASH_TYPE_SHA384
:
5886 digest_buf64
[0] += SHA384M_A
;
5887 digest_buf64
[1] += SHA384M_B
;
5888 digest_buf64
[2] += SHA384M_C
;
5889 digest_buf64
[3] += SHA384M_D
;
5890 digest_buf64
[4] += SHA384M_E
;
5891 digest_buf64
[5] += SHA384M_F
;
5892 digest_buf64
[6] += 0;
5893 digest_buf64
[7] += 0;
5896 case HASH_TYPE_SHA512
:
5897 digest_buf64
[0] += SHA512M_A
;
5898 digest_buf64
[1] += SHA512M_B
;
5899 digest_buf64
[2] += SHA512M_C
;
5900 digest_buf64
[3] += SHA512M_D
;
5901 digest_buf64
[4] += SHA512M_E
;
5902 digest_buf64
[5] += SHA512M_F
;
5903 digest_buf64
[6] += SHA512M_G
;
5904 digest_buf64
[7] += SHA512M_H
;
5909 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5911 if (dgst_size
== DGST_SIZE_4_2
)
5913 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5915 else if (dgst_size
== DGST_SIZE_4_4
)
5917 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5919 else if (dgst_size
== DGST_SIZE_4_5
)
5921 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5923 else if (dgst_size
== DGST_SIZE_4_6
)
5925 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5927 else if (dgst_size
== DGST_SIZE_4_8
)
5929 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5931 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5933 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5935 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5937 else if (hash_type
== HASH_TYPE_SHA384
)
5939 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5941 else if (hash_type
== HASH_TYPE_SHA512
)
5943 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5945 else if (hash_type
== HASH_TYPE_GOST
)
5947 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5950 else if (dgst_size
== DGST_SIZE_4_64
)
5952 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5954 else if (dgst_size
== DGST_SIZE_8_25
)
5956 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5960 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5961 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5962 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5968 memset (&salt
, 0, sizeof (salt_t
));
5970 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5972 char *ptr
= (char *) salt
.salt_buf
;
5974 uint len
= salt
.salt_len
;
5976 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5982 case HASH_TYPE_NETNTLM
:
5984 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
5985 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
5987 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5993 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5995 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6003 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6005 uint max
= salt
.salt_len
/ 4;
6009 for (uint i
= 0; i
< max
; i
++)
6011 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6015 if (opts_type
& OPTS_TYPE_ST_HEX
)
6019 memset (tmp
, 0, sizeof (tmp
));
6021 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6023 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6028 memcpy (ptr
, tmp
, len
);
6031 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6033 memset (ptr
+ len
, 0, memset_size
);
6035 salt
.salt_len
= len
;
6039 // some modes require special encoding
6042 uint out_buf_plain
[256];
6043 uint out_buf_salt
[256];
6047 memset (out_buf_plain
, 0, sizeof (out_buf_plain
));
6048 memset (out_buf_salt
, 0, sizeof (out_buf_salt
));
6050 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6052 char *ptr_plain
= (char *) out_buf_plain
;
6053 char *ptr_salt
= (char *) out_buf_salt
;
6055 if (hash_mode
== 22)
6059 memset (username
, 0, sizeof (username
));
6061 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6063 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6065 u16
*ptr
= (u16
*) digest_buf
;
6067 tmp_buf
[ 0] = sig
[0];
6068 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6069 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6070 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6071 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6072 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6073 tmp_buf
[ 6] = sig
[1];
6074 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6075 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6076 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6077 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6078 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6079 tmp_buf
[12] = sig
[2];
6080 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6081 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6082 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6083 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6084 tmp_buf
[17] = sig
[3];
6085 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6086 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6087 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6088 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6089 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6090 tmp_buf
[23] = sig
[4];
6091 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6092 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6093 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6094 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6095 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6096 tmp_buf
[29] = sig
[5];
6098 snprintf (out_buf
, len
-1, "%s:%s",
6102 else if (hash_mode
== 23)
6104 // do not show the \nskyper\n part in output
6106 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6108 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6110 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6117 else if (hash_mode
== 101)
6119 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6121 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6122 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6123 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6124 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6125 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6127 memcpy (tmp_buf
, digest_buf
, 20);
6129 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6131 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6133 else if (hash_mode
== 111)
6135 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6137 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6138 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6139 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6140 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6141 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6143 memcpy (tmp_buf
, digest_buf
, 20);
6144 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6146 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6148 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6150 else if (hash_mode
== 122)
6152 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6153 (char *) salt
.salt_buf
,
6160 else if (hash_mode
== 124)
6162 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6163 (char *) salt
.salt_buf
,
6170 else if (hash_mode
== 131)
6172 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6173 (char *) salt
.salt_buf
,
6181 else if (hash_mode
== 132)
6183 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6184 (char *) salt
.salt_buf
,
6191 else if (hash_mode
== 133)
6193 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6195 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6196 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6197 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6198 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6199 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6201 memcpy (tmp_buf
, digest_buf
, 20);
6203 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6205 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6207 else if (hash_mode
== 141)
6209 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6211 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6213 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6215 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6217 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6218 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6219 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6220 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6221 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6223 memcpy (tmp_buf
, digest_buf
, 20);
6225 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6229 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6231 else if (hash_mode
== 400)
6233 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6235 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6236 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6237 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6238 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6240 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6242 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6244 else if (hash_mode
== 500)
6246 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6248 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6249 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6250 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6251 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6253 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6255 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6257 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6261 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6264 else if (hash_mode
== 501)
6266 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6268 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6269 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6271 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6273 else if (hash_mode
== 1421)
6275 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6277 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6293 else if (hash_mode
== 1441)
6295 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6297 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6299 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6301 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6303 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6304 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6305 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6306 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6307 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6308 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6309 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6310 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6312 memcpy (tmp_buf
, digest_buf
, 32);
6314 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6318 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6320 else if (hash_mode
== 1500)
6322 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6323 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6324 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6325 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6326 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6328 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6330 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6332 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6333 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6335 memcpy (tmp_buf
, digest_buf
, 8);
6337 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6339 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6343 else if (hash_mode
== 1600)
6345 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6347 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6348 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6349 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6350 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6352 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6354 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6356 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6360 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6363 else if (hash_mode
== 1711)
6365 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6367 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6368 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6369 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6370 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6371 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6372 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6373 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6374 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6376 memcpy (tmp_buf
, digest_buf
, 64);
6377 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6379 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6381 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6383 else if (hash_mode
== 1722)
6385 uint
*ptr
= digest_buf
;
6387 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6388 (unsigned char *) salt
.salt_buf
,
6398 else if (hash_mode
== 1731)
6400 uint
*ptr
= digest_buf
;
6402 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6403 (unsigned char *) salt
.salt_buf
,
6413 else if (hash_mode
== 1800)
6417 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6418 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6419 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6420 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6421 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6422 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6423 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6424 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6426 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6428 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6430 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6434 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6437 else if (hash_mode
== 2100)
6441 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6443 salt
.salt_iter
+ 1);
6445 uint signature_len
= strlen (out_buf
);
6447 pos
+= signature_len
;
6448 len
-= signature_len
;
6450 char *salt_ptr
= (char *) salt
.salt_buf
;
6452 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6454 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6455 byte_swap_32 (digest_buf
[0]),
6456 byte_swap_32 (digest_buf
[1]),
6457 byte_swap_32 (digest_buf
[2]),
6458 byte_swap_32 (digest_buf
[3]));
6460 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6462 memcpy (tmp_buf
, digest_buf
, 16);
6464 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6466 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6467 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6468 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6469 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6471 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6472 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6473 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6474 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6476 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6477 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6478 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6479 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6481 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6482 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6483 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6484 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6486 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6487 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6488 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6489 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6493 else if (hash_mode
== 2500)
6495 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6497 wpa_t
*wpa
= &wpas
[salt_pos
];
6501 char *pke_ptr
= (char *) pke
;
6503 for (uint i
= 0; i
< 25; i
++)
6505 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6508 unsigned char mac1
[6];
6509 unsigned char mac2
[6];
6511 memcpy (mac1
, pke_ptr
+ 23, 6);
6512 memcpy (mac2
, pke_ptr
+ 29, 6);
6514 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6515 (char *) salt
.salt_buf
,
6529 else if (hash_mode
== 4400)
6531 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6532 byte_swap_32 (digest_buf
[0]),
6533 byte_swap_32 (digest_buf
[1]),
6534 byte_swap_32 (digest_buf
[2]),
6535 byte_swap_32 (digest_buf
[3]));
6537 else if (hash_mode
== 4700)
6539 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6540 byte_swap_32 (digest_buf
[0]),
6541 byte_swap_32 (digest_buf
[1]),
6542 byte_swap_32 (digest_buf
[2]),
6543 byte_swap_32 (digest_buf
[3]),
6544 byte_swap_32 (digest_buf
[4]));
6546 else if (hash_mode
== 4800)
6548 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6550 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6555 byte_swap_32 (salt
.salt_buf
[0]),
6556 byte_swap_32 (salt
.salt_buf
[1]),
6557 byte_swap_32 (salt
.salt_buf
[2]),
6558 byte_swap_32 (salt
.salt_buf
[3]),
6561 else if (hash_mode
== 4900)
6563 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6564 byte_swap_32 (digest_buf
[0]),
6565 byte_swap_32 (digest_buf
[1]),
6566 byte_swap_32 (digest_buf
[2]),
6567 byte_swap_32 (digest_buf
[3]),
6568 byte_swap_32 (digest_buf
[4]));
6570 else if (hash_mode
== 5100)
6572 snprintf (out_buf
, len
-1, "%08x%08x",
6576 else if (hash_mode
== 5200)
6578 snprintf (out_buf
, len
-1, "%s", hashfile
);
6580 else if (hash_mode
== 5300)
6582 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6584 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6586 int buf_len
= len
-1;
6590 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6592 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6594 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6596 snprintf (out_buf
, buf_len
, ":");
6602 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6610 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6612 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6614 if ((i
== 0) || (i
== 5))
6616 snprintf (out_buf
, buf_len
, ":");
6622 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6630 for (uint i
= 0; i
< 4; i
++)
6634 snprintf (out_buf
, buf_len
, ":");
6640 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6646 else if (hash_mode
== 5400)
6648 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6650 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6652 int buf_len
= len
-1;
6656 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6658 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6660 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6662 snprintf (out_buf
, buf_len
, ":");
6668 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6676 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6678 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6680 if ((i
== 0) || (i
== 5))
6682 snprintf (out_buf
, buf_len
, ":");
6688 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6696 for (uint i
= 0; i
< 5; i
++)
6700 snprintf (out_buf
, buf_len
, ":");
6706 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6712 else if (hash_mode
== 5500)
6714 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6716 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6719 char domain_buf
[64];
6720 char srvchall_buf
[1024];
6721 char clichall_buf
[1024];
6723 memset (user_buf
, 0, sizeof (user_buf
));
6724 memset (domain_buf
, 0, sizeof (domain_buf
));
6725 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6726 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6728 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6730 char *ptr
= (char *) netntlm
->userdomain_buf
;
6732 user_buf
[i
] = ptr
[j
];
6735 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6737 char *ptr
= (char *) netntlm
->userdomain_buf
;
6739 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6742 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6744 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6746 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6749 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6751 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6753 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6756 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6764 byte_swap_32 (salt
.salt_buf_pc
[0]),
6765 byte_swap_32 (salt
.salt_buf_pc
[1]),
6768 else if (hash_mode
== 5600)
6770 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6772 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6775 char domain_buf
[64];
6776 char srvchall_buf
[1024];
6777 char clichall_buf
[1024];
6779 memset (user_buf
, 0, sizeof (user_buf
));
6780 memset (domain_buf
, 0, sizeof (domain_buf
));
6781 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6782 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6784 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6786 char *ptr
= (char *) netntlm
->userdomain_buf
;
6788 user_buf
[i
] = ptr
[j
];
6791 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6793 char *ptr
= (char *) netntlm
->userdomain_buf
;
6795 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6798 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6800 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6802 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6805 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6807 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6809 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6812 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6822 else if (hash_mode
== 5700)
6824 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6826 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6827 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6828 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6829 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6830 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6831 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6832 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6833 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6835 memcpy (tmp_buf
, digest_buf
, 32);
6837 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6841 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6843 else if (hash_mode
== 5800)
6845 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6846 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6847 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6848 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6849 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6851 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6858 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6860 snprintf (out_buf
, len
-1, "%s", hashfile
);
6862 else if (hash_mode
== 6300)
6864 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6866 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6867 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6868 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6869 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6871 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6873 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6875 else if (hash_mode
== 6400)
6877 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6879 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6881 else if (hash_mode
== 6500)
6883 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6885 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6887 else if (hash_mode
== 6600)
6889 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6891 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6893 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6894 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6896 uint buf_len
= len
- 1;
6898 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6901 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6903 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6908 else if (hash_mode
== 6700)
6910 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6912 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6914 else if (hash_mode
== 6800)
6916 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6918 else if (hash_mode
== 7100)
6920 uint
*ptr
= digest_buf
;
6922 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6924 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6928 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6929 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6930 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6931 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6932 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6933 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6934 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6935 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6937 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",
6938 SIGNATURE_SHA512OSX
,
6940 esalt
[ 0], esalt
[ 1],
6941 esalt
[ 2], esalt
[ 3],
6942 esalt
[ 4], esalt
[ 5],
6943 esalt
[ 6], esalt
[ 7],
6951 ptr
[15], ptr
[14]);
6953 else if (hash_mode
== 7200)
6955 uint
*ptr
= digest_buf
;
6957 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6959 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6963 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6965 len_used
= strlen (out_buf
);
6967 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6969 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6971 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6974 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",
6982 ptr
[15], ptr
[14]);
6984 else if (hash_mode
== 7300)
6986 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6988 rakp_t
*rakp
= &rakps
[salt_pos
];
6990 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6992 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6995 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7002 else if (hash_mode
== 7400)
7004 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7006 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7007 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7008 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7009 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7010 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7011 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7012 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7013 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7015 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7017 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7019 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7023 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7026 else if (hash_mode
== 7500)
7028 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7030 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7032 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7033 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7037 char *ptr_data
= data
;
7039 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7041 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7044 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7046 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7051 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7053 (char *) krb5pa
->user
,
7054 (char *) krb5pa
->realm
,
7055 (char *) krb5pa
->salt
,
7058 else if (hash_mode
== 7700)
7060 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7061 (char *) salt
.salt_buf
,
7065 else if (hash_mode
== 7800)
7067 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7068 (char *) salt
.salt_buf
,
7075 else if (hash_mode
== 7900)
7077 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7081 char *tmp
= (char *) salt
.salt_buf_pc
;
7083 ptr_plain
[42] = tmp
[0];
7089 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7091 else if (hash_mode
== 8000)
7093 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7094 (unsigned char *) salt
.salt_buf
,
7104 else if (hash_mode
== 8100)
7106 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7107 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7109 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7110 (unsigned char *) salt
.salt_buf
,
7117 else if (hash_mode
== 8200)
7119 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7121 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7123 char data_buf
[4096];
7125 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7127 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7130 data_buf
[cloudkey
->data_len
* 2] = 0;
7132 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7133 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7134 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7135 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7136 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7137 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7138 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7139 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7141 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7142 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7143 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7144 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7146 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7162 else if (hash_mode
== 8300)
7164 char digest_buf_c
[34] = { 0 };
7166 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7168 digest_buf_c
[32] = 0;
7172 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7174 char domain_buf_c
[33] = { 0 };
7176 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7178 for (uint i
= 0; i
< salt_pc_len
; i
++)
7180 const char next
= domain_buf_c
[i
];
7182 domain_buf_c
[i
] = '.';
7187 domain_buf_c
[salt_pc_len
] = 0;
7191 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7193 else if (hash_mode
== 8500)
7195 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7197 else if (hash_mode
== 2612)
7199 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7201 (char *) salt
.salt_buf
,
7207 else if (hash_mode
== 3711)
7209 char *salt_ptr
= (char *) salt
.salt_buf
;
7211 salt_ptr
[salt
.salt_len
- 1] = 0;
7213 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7214 SIGNATURE_MEDIAWIKI_B
,
7221 else if (hash_mode
== 8800)
7223 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7225 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7229 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7231 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7236 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7237 SIGNATURE_ANDROIDFDE
,
7238 byte_swap_32 (salt
.salt_buf
[0]),
7239 byte_swap_32 (salt
.salt_buf
[1]),
7240 byte_swap_32 (salt
.salt_buf
[2]),
7241 byte_swap_32 (salt
.salt_buf
[3]),
7242 byte_swap_32 (digest_buf
[0]),
7243 byte_swap_32 (digest_buf
[1]),
7244 byte_swap_32 (digest_buf
[2]),
7245 byte_swap_32 (digest_buf
[3]),
7248 else if (hash_mode
== 8900)
7250 uint N
= salt
.scrypt_N
;
7251 uint r
= salt
.scrypt_r
;
7252 uint p
= salt
.scrypt_p
;
7254 char base64_salt
[32];
7256 memset (base64_salt
, 0, 32);
7258 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7260 memset (tmp_buf
, 0, 46);
7262 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7263 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7264 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7265 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7266 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7267 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7268 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7269 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7270 digest_buf
[8] = 0; // needed for base64_encode ()
7272 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7274 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7282 else if (hash_mode
== 9000)
7284 snprintf (out_buf
, len
-1, "%s", hashfile
);
7286 else if (hash_mode
== 9200)
7290 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7292 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7294 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7298 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7299 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7300 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7301 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7302 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7303 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7304 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7305 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7306 digest_buf
[8] = 0; // needed for base64_encode ()
7309 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7311 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7312 tmp_buf
[43] = 0; // cut it here
7316 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7318 else if (hash_mode
== 9300)
7320 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7321 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7322 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7323 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7324 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7325 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7326 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7327 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7328 digest_buf
[8] = 0; // needed for base64_encode ()
7331 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7333 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7334 tmp_buf
[43] = 0; // cut it here
7336 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7338 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7340 else if (hash_mode
== 9400)
7342 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7344 office2007_t
*office2007
= &office2007s
[salt_pos
];
7346 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7347 SIGNATURE_OFFICE2007
,
7350 office2007
->keySize
,
7356 office2007
->encryptedVerifier
[0],
7357 office2007
->encryptedVerifier
[1],
7358 office2007
->encryptedVerifier
[2],
7359 office2007
->encryptedVerifier
[3],
7360 office2007
->encryptedVerifierHash
[0],
7361 office2007
->encryptedVerifierHash
[1],
7362 office2007
->encryptedVerifierHash
[2],
7363 office2007
->encryptedVerifierHash
[3],
7364 office2007
->encryptedVerifierHash
[4]);
7366 else if (hash_mode
== 9500)
7368 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7370 office2010_t
*office2010
= &office2010s
[salt_pos
];
7372 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,
7378 office2010
->encryptedVerifier
[0],
7379 office2010
->encryptedVerifier
[1],
7380 office2010
->encryptedVerifier
[2],
7381 office2010
->encryptedVerifier
[3],
7382 office2010
->encryptedVerifierHash
[0],
7383 office2010
->encryptedVerifierHash
[1],
7384 office2010
->encryptedVerifierHash
[2],
7385 office2010
->encryptedVerifierHash
[3],
7386 office2010
->encryptedVerifierHash
[4],
7387 office2010
->encryptedVerifierHash
[5],
7388 office2010
->encryptedVerifierHash
[6],
7389 office2010
->encryptedVerifierHash
[7]);
7391 else if (hash_mode
== 9600)
7393 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7395 office2013_t
*office2013
= &office2013s
[salt_pos
];
7397 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,
7403 office2013
->encryptedVerifier
[0],
7404 office2013
->encryptedVerifier
[1],
7405 office2013
->encryptedVerifier
[2],
7406 office2013
->encryptedVerifier
[3],
7407 office2013
->encryptedVerifierHash
[0],
7408 office2013
->encryptedVerifierHash
[1],
7409 office2013
->encryptedVerifierHash
[2],
7410 office2013
->encryptedVerifierHash
[3],
7411 office2013
->encryptedVerifierHash
[4],
7412 office2013
->encryptedVerifierHash
[5],
7413 office2013
->encryptedVerifierHash
[6],
7414 office2013
->encryptedVerifierHash
[7]);
7416 else if (hash_mode
== 9700)
7418 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7420 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7422 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7423 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7424 byte_swap_32 (salt
.salt_buf
[0]),
7425 byte_swap_32 (salt
.salt_buf
[1]),
7426 byte_swap_32 (salt
.salt_buf
[2]),
7427 byte_swap_32 (salt
.salt_buf
[3]),
7428 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7429 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7430 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7431 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7432 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7433 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7434 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7435 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7437 else if (hash_mode
== 9710)
7439 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7441 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7443 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7444 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7445 byte_swap_32 (salt
.salt_buf
[0]),
7446 byte_swap_32 (salt
.salt_buf
[1]),
7447 byte_swap_32 (salt
.salt_buf
[2]),
7448 byte_swap_32 (salt
.salt_buf
[3]),
7449 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7450 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7451 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7452 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7453 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7454 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7455 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7456 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7458 else if (hash_mode
== 9720)
7460 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7462 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7464 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7466 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7467 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7468 byte_swap_32 (salt
.salt_buf
[0]),
7469 byte_swap_32 (salt
.salt_buf
[1]),
7470 byte_swap_32 (salt
.salt_buf
[2]),
7471 byte_swap_32 (salt
.salt_buf
[3]),
7472 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7473 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7474 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7475 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7476 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7477 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7478 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7479 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7486 else if (hash_mode
== 9800)
7488 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7490 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7492 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7493 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7498 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7499 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7500 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7501 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7502 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7503 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7504 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7505 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7506 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7508 else if (hash_mode
== 9810)
7510 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7512 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7514 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7515 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7520 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7521 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7522 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7523 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7524 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7525 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7526 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7527 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7528 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7530 else if (hash_mode
== 9820)
7532 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7534 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7536 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7538 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7539 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7544 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7545 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7546 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7547 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7548 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7549 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7550 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7551 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7552 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7559 else if (hash_mode
== 10000)
7563 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7565 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7567 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7571 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7572 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7573 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7574 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7575 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7576 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7577 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7578 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7579 digest_buf
[8] = 0; // needed for base64_encode ()
7582 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7584 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7588 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7590 else if (hash_mode
== 10100)
7592 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7597 byte_swap_32 (salt
.salt_buf
[0]),
7598 byte_swap_32 (salt
.salt_buf
[1]),
7599 byte_swap_32 (salt
.salt_buf
[2]),
7600 byte_swap_32 (salt
.salt_buf
[3]));
7602 else if (hash_mode
== 10200)
7604 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7606 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7610 char challenge
[100];
7612 memset (challenge
, 0, sizeof (challenge
));
7614 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7620 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7621 (char *) cram_md5
->user
,
7629 memset (response
, 0, sizeof (response
));
7631 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7633 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7635 else if (hash_mode
== 10300)
7639 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7641 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7642 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7644 uint tmp_len
= 20 + salt
.salt_len
;
7648 char base64_encoded
[100];
7650 memset (base64_encoded
, 0, sizeof (base64_encoded
));
7652 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7654 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7656 else if (hash_mode
== 10400)
7658 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7660 pdf_t
*pdf
= &pdfs
[salt_pos
];
7662 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",
7670 byte_swap_32 (pdf
->id_buf
[0]),
7671 byte_swap_32 (pdf
->id_buf
[1]),
7672 byte_swap_32 (pdf
->id_buf
[2]),
7673 byte_swap_32 (pdf
->id_buf
[3]),
7675 byte_swap_32 (pdf
->u_buf
[0]),
7676 byte_swap_32 (pdf
->u_buf
[1]),
7677 byte_swap_32 (pdf
->u_buf
[2]),
7678 byte_swap_32 (pdf
->u_buf
[3]),
7679 byte_swap_32 (pdf
->u_buf
[4]),
7680 byte_swap_32 (pdf
->u_buf
[5]),
7681 byte_swap_32 (pdf
->u_buf
[6]),
7682 byte_swap_32 (pdf
->u_buf
[7]),
7684 byte_swap_32 (pdf
->o_buf
[0]),
7685 byte_swap_32 (pdf
->o_buf
[1]),
7686 byte_swap_32 (pdf
->o_buf
[2]),
7687 byte_swap_32 (pdf
->o_buf
[3]),
7688 byte_swap_32 (pdf
->o_buf
[4]),
7689 byte_swap_32 (pdf
->o_buf
[5]),
7690 byte_swap_32 (pdf
->o_buf
[6]),
7691 byte_swap_32 (pdf
->o_buf
[7])
7694 else if (hash_mode
== 10410)
7696 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7698 pdf_t
*pdf
= &pdfs
[salt_pos
];
7700 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",
7708 byte_swap_32 (pdf
->id_buf
[0]),
7709 byte_swap_32 (pdf
->id_buf
[1]),
7710 byte_swap_32 (pdf
->id_buf
[2]),
7711 byte_swap_32 (pdf
->id_buf
[3]),
7713 byte_swap_32 (pdf
->u_buf
[0]),
7714 byte_swap_32 (pdf
->u_buf
[1]),
7715 byte_swap_32 (pdf
->u_buf
[2]),
7716 byte_swap_32 (pdf
->u_buf
[3]),
7717 byte_swap_32 (pdf
->u_buf
[4]),
7718 byte_swap_32 (pdf
->u_buf
[5]),
7719 byte_swap_32 (pdf
->u_buf
[6]),
7720 byte_swap_32 (pdf
->u_buf
[7]),
7722 byte_swap_32 (pdf
->o_buf
[0]),
7723 byte_swap_32 (pdf
->o_buf
[1]),
7724 byte_swap_32 (pdf
->o_buf
[2]),
7725 byte_swap_32 (pdf
->o_buf
[3]),
7726 byte_swap_32 (pdf
->o_buf
[4]),
7727 byte_swap_32 (pdf
->o_buf
[5]),
7728 byte_swap_32 (pdf
->o_buf
[6]),
7729 byte_swap_32 (pdf
->o_buf
[7])
7732 else if (hash_mode
== 10420)
7734 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7736 pdf_t
*pdf
= &pdfs
[salt_pos
];
7738 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7740 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",
7748 byte_swap_32 (pdf
->id_buf
[0]),
7749 byte_swap_32 (pdf
->id_buf
[1]),
7750 byte_swap_32 (pdf
->id_buf
[2]),
7751 byte_swap_32 (pdf
->id_buf
[3]),
7753 byte_swap_32 (pdf
->u_buf
[0]),
7754 byte_swap_32 (pdf
->u_buf
[1]),
7755 byte_swap_32 (pdf
->u_buf
[2]),
7756 byte_swap_32 (pdf
->u_buf
[3]),
7757 byte_swap_32 (pdf
->u_buf
[4]),
7758 byte_swap_32 (pdf
->u_buf
[5]),
7759 byte_swap_32 (pdf
->u_buf
[6]),
7760 byte_swap_32 (pdf
->u_buf
[7]),
7762 byte_swap_32 (pdf
->o_buf
[0]),
7763 byte_swap_32 (pdf
->o_buf
[1]),
7764 byte_swap_32 (pdf
->o_buf
[2]),
7765 byte_swap_32 (pdf
->o_buf
[3]),
7766 byte_swap_32 (pdf
->o_buf
[4]),
7767 byte_swap_32 (pdf
->o_buf
[5]),
7768 byte_swap_32 (pdf
->o_buf
[6]),
7769 byte_swap_32 (pdf
->o_buf
[7]),
7777 else if (hash_mode
== 10500)
7779 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7781 pdf_t
*pdf
= &pdfs
[salt_pos
];
7783 if (pdf
->id_len
== 32)
7785 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",
7793 byte_swap_32 (pdf
->id_buf
[0]),
7794 byte_swap_32 (pdf
->id_buf
[1]),
7795 byte_swap_32 (pdf
->id_buf
[2]),
7796 byte_swap_32 (pdf
->id_buf
[3]),
7797 byte_swap_32 (pdf
->id_buf
[4]),
7798 byte_swap_32 (pdf
->id_buf
[5]),
7799 byte_swap_32 (pdf
->id_buf
[6]),
7800 byte_swap_32 (pdf
->id_buf
[7]),
7802 byte_swap_32 (pdf
->u_buf
[0]),
7803 byte_swap_32 (pdf
->u_buf
[1]),
7804 byte_swap_32 (pdf
->u_buf
[2]),
7805 byte_swap_32 (pdf
->u_buf
[3]),
7806 byte_swap_32 (pdf
->u_buf
[4]),
7807 byte_swap_32 (pdf
->u_buf
[5]),
7808 byte_swap_32 (pdf
->u_buf
[6]),
7809 byte_swap_32 (pdf
->u_buf
[7]),
7811 byte_swap_32 (pdf
->o_buf
[0]),
7812 byte_swap_32 (pdf
->o_buf
[1]),
7813 byte_swap_32 (pdf
->o_buf
[2]),
7814 byte_swap_32 (pdf
->o_buf
[3]),
7815 byte_swap_32 (pdf
->o_buf
[4]),
7816 byte_swap_32 (pdf
->o_buf
[5]),
7817 byte_swap_32 (pdf
->o_buf
[6]),
7818 byte_swap_32 (pdf
->o_buf
[7])
7823 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",
7831 byte_swap_32 (pdf
->id_buf
[0]),
7832 byte_swap_32 (pdf
->id_buf
[1]),
7833 byte_swap_32 (pdf
->id_buf
[2]),
7834 byte_swap_32 (pdf
->id_buf
[3]),
7836 byte_swap_32 (pdf
->u_buf
[0]),
7837 byte_swap_32 (pdf
->u_buf
[1]),
7838 byte_swap_32 (pdf
->u_buf
[2]),
7839 byte_swap_32 (pdf
->u_buf
[3]),
7840 byte_swap_32 (pdf
->u_buf
[4]),
7841 byte_swap_32 (pdf
->u_buf
[5]),
7842 byte_swap_32 (pdf
->u_buf
[6]),
7843 byte_swap_32 (pdf
->u_buf
[7]),
7845 byte_swap_32 (pdf
->o_buf
[0]),
7846 byte_swap_32 (pdf
->o_buf
[1]),
7847 byte_swap_32 (pdf
->o_buf
[2]),
7848 byte_swap_32 (pdf
->o_buf
[3]),
7849 byte_swap_32 (pdf
->o_buf
[4]),
7850 byte_swap_32 (pdf
->o_buf
[5]),
7851 byte_swap_32 (pdf
->o_buf
[6]),
7852 byte_swap_32 (pdf
->o_buf
[7])
7856 else if (hash_mode
== 10600)
7858 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7860 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7861 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7863 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7865 else if (hash_mode
== 10700)
7867 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7869 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7870 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7872 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7874 else if (hash_mode
== 10900)
7876 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7878 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7879 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7881 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7883 else if (hash_mode
== 11100)
7885 u32 salt_challenge
= salt
.salt_buf
[0];
7887 salt_challenge
= byte_swap_32 (salt_challenge
);
7889 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7891 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7892 SIGNATURE_POSTGRESQL_AUTH
,
7900 else if (hash_mode
== 11200)
7902 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7903 SIGNATURE_MYSQL_AUTH
,
7904 (unsigned char *) salt
.salt_buf
,
7911 else if (hash_mode
== 11300)
7913 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7915 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7917 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7918 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7919 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7921 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7922 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7923 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7925 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7927 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7929 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7932 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7934 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7936 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7939 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7941 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7943 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7946 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7947 SIGNATURE_BITCOIN_WALLET
,
7951 (unsigned char *) salt
.salt_buf
,
7959 free (cry_master_buf
);
7961 free (public_key_buf
);
7963 else if (hash_mode
== 11400)
7965 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7967 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7968 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7970 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7972 else if (hash_mode
== 11600)
7974 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7976 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7978 const uint data_len
= seven_zip
->data_len
;
7980 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7982 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7984 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
7986 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7989 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7990 SIGNATURE_SEVEN_ZIP
,
7994 (char *) seven_zip
->salt_buf
,
7996 seven_zip
->iv_buf
[0],
7997 seven_zip
->iv_buf
[1],
7998 seven_zip
->iv_buf
[2],
7999 seven_zip
->iv_buf
[3],
8001 seven_zip
->data_len
,
8002 seven_zip
->unpack_size
,
8007 else if (hash_mode
== 11700)
8009 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8019 else if (hash_mode
== 11800)
8021 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8039 else if (hash_mode
== 11900)
8041 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8043 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8044 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8046 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8048 else if (hash_mode
== 12000)
8050 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8052 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8053 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8055 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8057 else if (hash_mode
== 12100)
8059 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8061 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8062 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8064 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8066 else if (hash_mode
== 12200)
8068 uint
*ptr_digest
= digest_buf
;
8069 uint
*ptr_salt
= salt
.salt_buf
;
8071 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8078 else if (hash_mode
== 12300)
8080 uint
*ptr_digest
= digest_buf
;
8081 uint
*ptr_salt
= salt
.salt_buf
;
8083 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",
8084 ptr_digest
[ 0], ptr_digest
[ 1],
8085 ptr_digest
[ 2], ptr_digest
[ 3],
8086 ptr_digest
[ 4], ptr_digest
[ 5],
8087 ptr_digest
[ 6], ptr_digest
[ 7],
8088 ptr_digest
[ 8], ptr_digest
[ 9],
8089 ptr_digest
[10], ptr_digest
[11],
8090 ptr_digest
[12], ptr_digest
[13],
8091 ptr_digest
[14], ptr_digest
[15],
8097 else if (hash_mode
== 12400)
8099 // encode iteration count
8103 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8104 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8105 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8106 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8111 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8112 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8113 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8114 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8119 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8121 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8122 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8124 memcpy (tmp_buf
, digest_buf
, 8);
8126 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8130 // fill the resulting buffer
8132 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8134 else if (hash_mode
== 12500)
8136 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8138 byte_swap_32 (salt
.salt_buf
[0]),
8139 byte_swap_32 (salt
.salt_buf
[1]),
8145 else if (hash_mode
== 12600)
8147 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8148 digest_buf
[0] + salt
.salt_buf_pc
[0],
8149 digest_buf
[1] + salt
.salt_buf_pc
[1],
8150 digest_buf
[2] + salt
.salt_buf_pc
[2],
8151 digest_buf
[3] + salt
.salt_buf_pc
[3],
8152 digest_buf
[4] + salt
.salt_buf_pc
[4],
8153 digest_buf
[5] + salt
.salt_buf_pc
[5],
8154 digest_buf
[6] + salt
.salt_buf_pc
[6],
8155 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8157 else if (hash_mode
== 12700)
8159 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8161 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8162 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8164 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8166 else if (hash_mode
== 12800)
8168 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8170 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",
8183 byte_swap_32 (digest_buf
[0]),
8184 byte_swap_32 (digest_buf
[1]),
8185 byte_swap_32 (digest_buf
[2]),
8186 byte_swap_32 (digest_buf
[3]),
8187 byte_swap_32 (digest_buf
[4]),
8188 byte_swap_32 (digest_buf
[5]),
8189 byte_swap_32 (digest_buf
[6]),
8190 byte_swap_32 (digest_buf
[7])
8193 else if (hash_mode
== 12900)
8195 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",
8204 byte_swap_32 (digest_buf
[0]),
8205 byte_swap_32 (digest_buf
[1]),
8206 byte_swap_32 (digest_buf
[2]),
8207 byte_swap_32 (digest_buf
[3]),
8208 byte_swap_32 (digest_buf
[4]),
8209 byte_swap_32 (digest_buf
[5]),
8210 byte_swap_32 (digest_buf
[6]),
8211 byte_swap_32 (digest_buf
[7]),
8218 else if (hash_mode
== 13000)
8220 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8222 rar5_t
*rar5
= &rar5s
[salt_pos
];
8224 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8234 byte_swap_32 (digest_buf
[0]),
8235 byte_swap_32 (digest_buf
[1])
8240 if (hash_type
== HASH_TYPE_MD4
)
8242 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8248 else if (hash_type
== HASH_TYPE_MD5
)
8250 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8256 else if (hash_type
== HASH_TYPE_SHA1
)
8258 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8265 else if (hash_type
== HASH_TYPE_SHA256
)
8267 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8277 else if (hash_type
== HASH_TYPE_SHA384
)
8279 uint
*ptr
= digest_buf
;
8281 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8289 else if (hash_type
== HASH_TYPE_SHA512
)
8291 uint
*ptr
= digest_buf
;
8293 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8303 else if (hash_type
== HASH_TYPE_LM
)
8305 snprintf (out_buf
, len
-1, "%08x%08x",
8309 else if (hash_type
== HASH_TYPE_ORACLEH
)
8311 snprintf (out_buf
, len
-1, "%08X%08X",
8315 else if (hash_type
== HASH_TYPE_BCRYPT
)
8317 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8318 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8320 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8322 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8324 else if (hash_type
== HASH_TYPE_KECCAK
)
8326 uint
*ptr
= digest_buf
;
8328 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",
8356 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8358 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8360 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8367 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8369 digest_buf
[ 0] = digest_buf
[ 0];
8370 digest_buf
[ 1] = digest_buf
[ 1];
8371 digest_buf
[ 2] = digest_buf
[ 2];
8372 digest_buf
[ 3] = digest_buf
[ 3];
8373 digest_buf
[ 4] = digest_buf
[ 4];
8374 digest_buf
[ 5] = digest_buf
[ 5];
8375 digest_buf
[ 6] = digest_buf
[ 6];
8376 digest_buf
[ 7] = digest_buf
[ 7];
8377 digest_buf
[ 8] = digest_buf
[ 8];
8378 digest_buf
[ 9] = digest_buf
[ 9];
8379 digest_buf
[10] = digest_buf
[10];
8380 digest_buf
[11] = digest_buf
[11];
8381 digest_buf
[12] = digest_buf
[12];
8382 digest_buf
[13] = digest_buf
[13];
8383 digest_buf
[14] = digest_buf
[14];
8384 digest_buf
[15] = digest_buf
[15];
8386 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8404 else if (hash_type
== HASH_TYPE_GOST
)
8406 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8416 else if (hash_type
== HASH_TYPE_MYSQL
)
8418 snprintf (out_buf
, len
-1, "%08x%08x",
8422 else if (hash_type
== HASH_TYPE_LOTUS5
)
8424 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8430 else if (hash_type
== HASH_TYPE_LOTUS6
)
8432 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8433 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8434 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8435 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8439 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8440 memcpy (buf
+ 5, digest_buf
, 9);
8444 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8446 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8449 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8451 else if (hash_type
== HASH_TYPE_LOTUS8
)
8455 memset (buf
, 0, sizeof (buf
));
8459 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8465 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8469 buf
[26] = salt
.salt_buf_pc
[0];
8470 buf
[27] = salt
.salt_buf_pc
[1];
8474 memcpy (buf
+ 28, digest_buf
, 8);
8476 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8480 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8482 else if (hash_type
== HASH_TYPE_CRC32
)
8484 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8488 if (salt_type
== SALT_TYPE_INTERN
)
8490 size_t pos
= strlen (out_buf
);
8492 out_buf
[pos
] = data
.separator
;
8494 char *ptr
= (char *) salt
.salt_buf
;
8496 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8498 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8502 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8504 memset (hccap
, 0, sizeof (hccap_t
));
8506 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8508 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8510 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8511 wpa_t
*wpa
= &wpas
[salt_pos
];
8513 hccap
->keyver
= wpa
->keyver
;
8515 hccap
->eapol_size
= wpa
->eapol_size
;
8517 if (wpa
->keyver
!= 1)
8521 for (uint i
= 0; i
< 64; i
++)
8523 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8526 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8530 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8535 for (int i
= 5; i
< 25; i
++)
8537 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8540 char *pke_ptr
= (char *) pke_tmp
;
8542 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8543 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8544 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8545 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8547 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8549 uint dgst_size
= data
.dgst_size
;
8551 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8553 if (wpa
->keyver
!= 1)
8557 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8558 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8559 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8560 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8562 memcpy (hccap
->keymic
, digest_tmp
, 16);
8566 memcpy (hccap
->keymic
, digest_ptr
, 16);
8570 void SuspendThreads ()
8572 if (data
.devices_status
== STATUS_RUNNING
)
8574 hc_timer_set (&data
.timer_paused
);
8576 data
.devices_status
= STATUS_PAUSED
;
8578 log_info ("Paused");
8582 void ResumeThreads ()
8584 if (data
.devices_status
== STATUS_PAUSED
)
8588 hc_timer_get (data
.timer_paused
, ms_paused
);
8590 data
.ms_paused
+= ms_paused
;
8592 data
.devices_status
= STATUS_RUNNING
;
8594 log_info ("Resumed");
8600 if (data
.devices_status
!= STATUS_RUNNING
) return;
8602 data
.devices_status
= STATUS_BYPASS
;
8604 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8607 void stop_at_checkpoint ()
8609 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8611 if (data
.devices_status
!= STATUS_RUNNING
) return;
8614 // this feature only makes sense if --restore-disable was not specified
8616 if (data
.restore_disable
== 1)
8618 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8623 // check if monitoring of Restore Point updates should be enabled or disabled
8625 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8627 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8629 // save the current restore point value
8631 data
.checkpoint_cur_words
= get_lowest_words_done ();
8633 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8637 data
.devices_status
= STATUS_RUNNING
;
8639 // reset the global value for checkpoint checks
8641 data
.checkpoint_cur_words
= 0;
8643 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8649 if (data
.devices_status
== STATUS_INIT
) return;
8650 if (data
.devices_status
== STATUS_STARTING
) return;
8652 data
.devices_status
= STATUS_ABORTED
;
8657 if (data
.devices_status
== STATUS_INIT
) return;
8658 if (data
.devices_status
== STATUS_STARTING
) return;
8660 data
.devices_status
= STATUS_QUIT
;
8663 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8667 if ((fp
= fopen (kernel_file
, "rb")) != NULL
)
8671 memset (&st
, 0, sizeof (st
));
8673 stat (kernel_file
, &st
);
8675 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8677 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8679 if (num_read
!= (size_t) st
.st_size
)
8681 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8688 buf
[st
.st_size
] = 0;
8690 for (int i
= 0; i
< num_devices
; i
++)
8692 kernel_lengths
[i
] = (size_t) st
.st_size
;
8694 kernel_sources
[i
] = buf
;
8699 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8707 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8709 FILE *fp
= fopen (dst
, "wb");
8711 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8721 restore_data_t
*init_restore (int argc
, char **argv
)
8723 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8725 if (data
.restore_disable
== 0)
8727 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8731 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8735 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8744 char pidbin
[BUFSIZ
];
8749 memset (pidbin
, 0, sizeof (pidbin
));
8751 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8753 FILE *fd
= fopen (pidbin
, "rb");
8757 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8759 pidbin
[pidbin_len
] = 0;
8763 char *argv0_r
= strrchr (argv
[0], '/');
8765 char *pidbin_r
= strrchr (pidbin
, '/');
8767 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8769 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8771 if (strcmp (argv0_r
, pidbin_r
) == 0)
8773 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8780 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8782 char pidbin2
[BUFSIZ
];
8786 memset (pidbin2
, 0, sizeof (pidbin2
));
8788 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8789 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8791 pidbin
[pidbin_len
] = 0;
8792 pidbin2
[pidbin2_len
] = 0;
8796 if (strcmp (pidbin
, pidbin2
) == 0)
8798 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8806 if (rd
->version_bin
< RESTORE_MIN
)
8808 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8815 memset (rd
, 0, sizeof (restore_data_t
));
8817 rd
->version_bin
= VERSION_BIN
;
8820 rd
->pid
= getpid ();
8822 rd
->pid
= GetCurrentProcessId ();
8825 if (getcwd (rd
->cwd
, 255) == NULL
)
8838 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8840 FILE *fp
= fopen (eff_restore_file
, "rb");
8844 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8849 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8851 log_error ("ERROR: cannot read %s", eff_restore_file
);
8856 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8858 for (uint i
= 0; i
< rd
->argc
; i
++)
8862 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8864 log_error ("ERROR: cannot read %s", eff_restore_file
);
8869 size_t len
= strlen (buf
);
8871 if (len
) buf
[len
- 1] = 0;
8873 rd
->argv
[i
] = mystrdup (buf
);
8880 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8884 log_error ("Restore file is corrupted");
8887 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8889 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8891 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8896 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8900 if (chdir (rd
->cwd
))
8902 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8908 u64
get_lowest_words_done ()
8912 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8914 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8916 if (device_param
->skipped
) continue;
8918 const u64 words_done
= device_param
->words_done
;
8920 if (words_done
< words_cur
) words_cur
= words_done
;
8923 // It's possible that a device's workload isn't finished right after a restore-case.
8924 // In that case, this function would return 0 and overwrite the real restore point
8925 // There's also data.words_cur which is set to rd->words_cur but it changes while
8926 // the attack is running therefore we should stick to rd->words_cur.
8927 // Note that -s influences rd->words_cur we should keep a close look on that.
8929 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8934 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8936 u64 words_cur
= get_lowest_words_done ();
8938 rd
->words_cur
= words_cur
;
8940 FILE *fp
= fopen (new_restore_file
, "wb");
8944 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8949 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8951 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8956 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8958 for (uint i
= 0; i
< rd
->argc
; i
++)
8960 fprintf (fp
, "%s", rd
->argv
[i
]);
8966 fsync (fileno (fp
));
8971 void cycle_restore ()
8973 const char *eff_restore_file
= data
.eff_restore_file
;
8974 const char *new_restore_file
= data
.new_restore_file
;
8976 restore_data_t
*rd
= data
.rd
;
8978 write_restore (new_restore_file
, rd
);
8982 memset (&st
, 0, sizeof(st
));
8984 if (stat (eff_restore_file
, &st
) == 0)
8986 if (unlink (eff_restore_file
))
8988 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8992 if (rename (new_restore_file
, eff_restore_file
))
8994 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8998 void check_checkpoint ()
9000 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9002 u64 words_cur
= get_lowest_words_done ();
9004 if (words_cur
!= data
.checkpoint_cur_words
)
9014 uint
set_kernel_accel (uint hash_mode
)
9018 case 0: return GET_ACCEL (0);
9019 case 10: return GET_ACCEL (10);
9020 case 11: return GET_ACCEL (11);
9021 case 12: return GET_ACCEL (12);
9022 case 20: return GET_ACCEL (20);
9023 case 21: return GET_ACCEL (21);
9024 case 22: return GET_ACCEL (22);
9025 case 23: return GET_ACCEL (23);
9026 case 30: return GET_ACCEL (30);
9027 case 40: return GET_ACCEL (40);
9028 case 50: return GET_ACCEL (50);
9029 case 60: return GET_ACCEL (60);
9030 case 100: return GET_ACCEL (100);
9031 case 101: return GET_ACCEL (101);
9032 case 110: return GET_ACCEL (110);
9033 case 111: return GET_ACCEL (111);
9034 case 112: return GET_ACCEL (112);
9035 case 120: return GET_ACCEL (120);
9036 case 121: return GET_ACCEL (121);
9037 case 122: return GET_ACCEL (122);
9038 case 124: return GET_ACCEL (124);
9039 case 130: return GET_ACCEL (130);
9040 case 131: return GET_ACCEL (131);
9041 case 132: return GET_ACCEL (132);
9042 case 133: return GET_ACCEL (133);
9043 case 140: return GET_ACCEL (140);
9044 case 141: return GET_ACCEL (141);
9045 case 150: return GET_ACCEL (150);
9046 case 160: return GET_ACCEL (160);
9047 case 190: return GET_ACCEL (190);
9048 case 200: return GET_ACCEL (200);
9049 case 300: return GET_ACCEL (300);
9050 case 400: return GET_ACCEL (400);
9051 case 500: return GET_ACCEL (500);
9052 case 501: return GET_ACCEL (501);
9053 case 900: return GET_ACCEL (900);
9054 case 910: return GET_ACCEL (910);
9055 case 1000: return GET_ACCEL (1000);
9056 case 1100: return GET_ACCEL (1100);
9057 case 1400: return GET_ACCEL (1400);
9058 case 1410: return GET_ACCEL (1410);
9059 case 1420: return GET_ACCEL (1420);
9060 case 1421: return GET_ACCEL (1421);
9061 case 1430: return GET_ACCEL (1430);
9062 case 1440: return GET_ACCEL (1440);
9063 case 1441: return GET_ACCEL (1441);
9064 case 1450: return GET_ACCEL (1450);
9065 case 1460: return GET_ACCEL (1460);
9066 case 1500: return GET_ACCEL (1500);
9067 case 1600: return GET_ACCEL (1600);
9068 case 1700: return GET_ACCEL (1700);
9069 case 1710: return GET_ACCEL (1710);
9070 case 1711: return GET_ACCEL (1711);
9071 case 1720: return GET_ACCEL (1720);
9072 case 1722: return GET_ACCEL (1722);
9073 case 1730: return GET_ACCEL (1730);
9074 case 1731: return GET_ACCEL (1731);
9075 case 1740: return GET_ACCEL (1740);
9076 case 1750: return GET_ACCEL (1750);
9077 case 1760: return GET_ACCEL (1760);
9078 case 1800: return GET_ACCEL (1800);
9079 case 2100: return GET_ACCEL (2100);
9080 case 2400: return GET_ACCEL (2400);
9081 case 2410: return GET_ACCEL (2410);
9082 case 2500: return GET_ACCEL (2500);
9083 case 2600: return GET_ACCEL (2600);
9084 case 2611: return GET_ACCEL (2611);
9085 case 2612: return GET_ACCEL (2612);
9086 case 2711: return GET_ACCEL (2711);
9087 case 2811: return GET_ACCEL (2811);
9088 case 3000: return GET_ACCEL (3000);
9089 case 3100: return GET_ACCEL (3100);
9090 case 3200: return GET_ACCEL (3200);
9091 case 3710: return GET_ACCEL (3710);
9092 case 3711: return GET_ACCEL (3711);
9093 case 3800: return GET_ACCEL (3800);
9094 case 4300: return GET_ACCEL (4300);
9095 case 4400: return GET_ACCEL (4400);
9096 case 4500: return GET_ACCEL (4500);
9097 case 4700: return GET_ACCEL (4700);
9098 case 4800: return GET_ACCEL (4800);
9099 case 4900: return GET_ACCEL (4900);
9100 case 5000: return GET_ACCEL (5000);
9101 case 5100: return GET_ACCEL (5100);
9102 case 5200: return GET_ACCEL (5200);
9103 case 5300: return GET_ACCEL (5300);
9104 case 5400: return GET_ACCEL (5400);
9105 case 5500: return GET_ACCEL (5500);
9106 case 5600: return GET_ACCEL (5600);
9107 case 5700: return GET_ACCEL (5700);
9108 case 5800: return GET_ACCEL (5800);
9109 case 6000: return GET_ACCEL (6000);
9110 case 6100: return GET_ACCEL (6100);
9111 case 6211: return GET_ACCEL (6211);
9112 case 6212: return GET_ACCEL (6212);
9113 case 6213: return GET_ACCEL (6213);
9114 case 6221: return GET_ACCEL (6221);
9115 case 6222: return GET_ACCEL (6222);
9116 case 6223: return GET_ACCEL (6223);
9117 case 6231: return GET_ACCEL (6231);
9118 case 6232: return GET_ACCEL (6232);
9119 case 6233: return GET_ACCEL (6233);
9120 case 6241: return GET_ACCEL (6241);
9121 case 6242: return GET_ACCEL (6242);
9122 case 6243: return GET_ACCEL (6243);
9123 case 6300: return GET_ACCEL (6300);
9124 case 6400: return GET_ACCEL (6400);
9125 case 6500: return GET_ACCEL (6500);
9126 case 6600: return GET_ACCEL (6600);
9127 case 6700: return GET_ACCEL (6700);
9128 case 6800: return GET_ACCEL (6800);
9129 case 6900: return GET_ACCEL (6900);
9130 case 7100: return GET_ACCEL (7100);
9131 case 7200: return GET_ACCEL (7200);
9132 case 7300: return GET_ACCEL (7300);
9133 case 7400: return GET_ACCEL (7400);
9134 case 7500: return GET_ACCEL (7500);
9135 case 7600: return GET_ACCEL (7600);
9136 case 7700: return GET_ACCEL (7700);
9137 case 7800: return GET_ACCEL (7800);
9138 case 7900: return GET_ACCEL (7900);
9139 case 8000: return GET_ACCEL (8000);
9140 case 8100: return GET_ACCEL (8100);
9141 case 8200: return GET_ACCEL (8200);
9142 case 8300: return GET_ACCEL (8300);
9143 case 8400: return GET_ACCEL (8400);
9144 case 8500: return GET_ACCEL (8500);
9145 case 8600: return GET_ACCEL (8600);
9146 case 8700: return GET_ACCEL (8700);
9147 case 8800: return GET_ACCEL (8800);
9148 case 8900: return GET_ACCEL (8900);
9149 case 9000: return GET_ACCEL (9000);
9150 case 9100: return GET_ACCEL (9100);
9151 case 9200: return GET_ACCEL (9200);
9152 case 9300: return GET_ACCEL (9300);
9153 case 9400: return GET_ACCEL (9400);
9154 case 9500: return GET_ACCEL (9500);
9155 case 9600: return GET_ACCEL (9600);
9156 case 9700: return GET_ACCEL (9700);
9157 case 9710: return GET_ACCEL (9710);
9158 case 9720: return GET_ACCEL (9720);
9159 case 9800: return GET_ACCEL (9800);
9160 case 9810: return GET_ACCEL (9810);
9161 case 9820: return GET_ACCEL (9820);
9162 case 9900: return GET_ACCEL (9900);
9163 case 10000: return GET_ACCEL (10000);
9164 case 10100: return GET_ACCEL (10100);
9165 case 10200: return GET_ACCEL (10200);
9166 case 10300: return GET_ACCEL (10300);
9167 case 10400: return GET_ACCEL (10400);
9168 case 10410: return GET_ACCEL (10410);
9169 case 10420: return GET_ACCEL (10420);
9170 case 10500: return GET_ACCEL (10500);
9171 case 10600: return GET_ACCEL (10600);
9172 case 10700: return GET_ACCEL (10700);
9173 case 10800: return GET_ACCEL (10800);
9174 case 10900: return GET_ACCEL (10900);
9175 case 11000: return GET_ACCEL (11000);
9176 case 11100: return GET_ACCEL (11100);
9177 case 11200: return GET_ACCEL (11200);
9178 case 11300: return GET_ACCEL (11300);
9179 case 11400: return GET_ACCEL (11400);
9180 case 11500: return GET_ACCEL (11500);
9181 case 11600: return GET_ACCEL (11600);
9182 case 11700: return GET_ACCEL (11700);
9183 case 11800: return GET_ACCEL (11800);
9184 case 11900: return GET_ACCEL (11900);
9185 case 12000: return GET_ACCEL (12000);
9186 case 12100: return GET_ACCEL (12100);
9187 case 12200: return GET_ACCEL (12200);
9188 case 12300: return GET_ACCEL (12300);
9189 case 12400: return GET_ACCEL (12400);
9190 case 12500: return GET_ACCEL (12500);
9191 case 12600: return GET_ACCEL (12600);
9192 case 12700: return GET_ACCEL (12700);
9193 case 12800: return GET_ACCEL (12800);
9194 case 12900: return GET_ACCEL (12900);
9195 case 13000: return GET_ACCEL (13000);
9201 uint
set_kernel_loops (uint hash_mode
)
9205 case 0: return GET_LOOPS (0);
9206 case 10: return GET_LOOPS (10);
9207 case 11: return GET_LOOPS (11);
9208 case 12: return GET_LOOPS (12);
9209 case 20: return GET_LOOPS (20);
9210 case 21: return GET_LOOPS (21);
9211 case 22: return GET_LOOPS (22);
9212 case 23: return GET_LOOPS (23);
9213 case 30: return GET_LOOPS (30);
9214 case 40: return GET_LOOPS (40);
9215 case 50: return GET_LOOPS (50);
9216 case 60: return GET_LOOPS (60);
9217 case 100: return GET_LOOPS (100);
9218 case 101: return GET_LOOPS (101);
9219 case 110: return GET_LOOPS (110);
9220 case 111: return GET_LOOPS (111);
9221 case 112: return GET_LOOPS (112);
9222 case 120: return GET_LOOPS (120);
9223 case 121: return GET_LOOPS (121);
9224 case 122: return GET_LOOPS (122);
9225 case 124: return GET_LOOPS (124);
9226 case 130: return GET_LOOPS (130);
9227 case 131: return GET_LOOPS (131);
9228 case 132: return GET_LOOPS (132);
9229 case 133: return GET_LOOPS (133);
9230 case 140: return GET_LOOPS (140);
9231 case 141: return GET_LOOPS (141);
9232 case 150: return GET_LOOPS (150);
9233 case 160: return GET_LOOPS (160);
9234 case 190: return GET_LOOPS (190);
9235 case 200: return GET_LOOPS (200);
9236 case 300: return GET_LOOPS (300);
9237 case 400: return GET_LOOPS (400);
9238 case 500: return GET_LOOPS (500);
9239 case 501: return GET_LOOPS (501);
9240 case 900: return GET_LOOPS (900);
9241 case 910: return GET_LOOPS (910);
9242 case 1000: return GET_LOOPS (1000);
9243 case 1100: return GET_LOOPS (1100);
9244 case 1400: return GET_LOOPS (1400);
9245 case 1410: return GET_LOOPS (1410);
9246 case 1420: return GET_LOOPS (1420);
9247 case 1421: return GET_LOOPS (1421);
9248 case 1430: return GET_LOOPS (1430);
9249 case 1440: return GET_LOOPS (1440);
9250 case 1441: return GET_LOOPS (1441);
9251 case 1450: return GET_LOOPS (1450);
9252 case 1460: return GET_LOOPS (1460);
9253 case 1500: return GET_LOOPS (1500);
9254 case 1600: return GET_LOOPS (1600);
9255 case 1700: return GET_LOOPS (1700);
9256 case 1710: return GET_LOOPS (1710);
9257 case 1711: return GET_LOOPS (1711);
9258 case 1720: return GET_LOOPS (1720);
9259 case 1722: return GET_LOOPS (1722);
9260 case 1730: return GET_LOOPS (1730);
9261 case 1731: return GET_LOOPS (1731);
9262 case 1740: return GET_LOOPS (1740);
9263 case 1750: return GET_LOOPS (1750);
9264 case 1760: return GET_LOOPS (1760);
9265 case 1800: return GET_LOOPS (1800);
9266 case 2100: return GET_LOOPS (2100);
9267 case 2400: return GET_LOOPS (2400);
9268 case 2410: return GET_LOOPS (2410);
9269 case 2500: return GET_LOOPS (2500);
9270 case 2600: return GET_LOOPS (2600);
9271 case 2611: return GET_LOOPS (2611);
9272 case 2612: return GET_LOOPS (2612);
9273 case 2711: return GET_LOOPS (2711);
9274 case 2811: return GET_LOOPS (2811);
9275 case 3000: return GET_LOOPS (3000);
9276 case 3100: return GET_LOOPS (3100);
9277 case 3200: return GET_LOOPS (3200);
9278 case 3710: return GET_LOOPS (3710);
9279 case 3711: return GET_LOOPS (3711);
9280 case 3800: return GET_LOOPS (3800);
9281 case 4300: return GET_LOOPS (4300);
9282 case 4400: return GET_LOOPS (4400);
9283 case 4500: return GET_LOOPS (4500);
9284 case 4700: return GET_LOOPS (4700);
9285 case 4800: return GET_LOOPS (4800);
9286 case 4900: return GET_LOOPS (4900);
9287 case 5000: return GET_LOOPS (5000);
9288 case 5100: return GET_LOOPS (5100);
9289 case 5200: return GET_LOOPS (5200);
9290 case 5300: return GET_LOOPS (5300);
9291 case 5400: return GET_LOOPS (5400);
9292 case 5500: return GET_LOOPS (5500);
9293 case 5600: return GET_LOOPS (5600);
9294 case 5700: return GET_LOOPS (5700);
9295 case 5800: return GET_LOOPS (5800);
9296 case 6000: return GET_LOOPS (6000);
9297 case 6100: return GET_LOOPS (6100);
9298 case 6211: return GET_LOOPS (6211);
9299 case 6212: return GET_LOOPS (6212);
9300 case 6213: return GET_LOOPS (6213);
9301 case 6221: return GET_LOOPS (6221);
9302 case 6222: return GET_LOOPS (6222);
9303 case 6223: return GET_LOOPS (6223);
9304 case 6231: return GET_LOOPS (6231);
9305 case 6232: return GET_LOOPS (6232);
9306 case 6233: return GET_LOOPS (6233);
9307 case 6241: return GET_LOOPS (6241);
9308 case 6242: return GET_LOOPS (6242);
9309 case 6243: return GET_LOOPS (6243);
9310 case 6300: return GET_LOOPS (6300);
9311 case 6400: return GET_LOOPS (6400);
9312 case 6500: return GET_LOOPS (6500);
9313 case 6600: return GET_LOOPS (6600);
9314 case 6700: return GET_LOOPS (6700);
9315 case 6800: return GET_LOOPS (6800);
9316 case 6900: return GET_LOOPS (6900);
9317 case 7100: return GET_LOOPS (7100);
9318 case 7200: return GET_LOOPS (7200);
9319 case 7300: return GET_LOOPS (7300);
9320 case 7400: return GET_LOOPS (7400);
9321 case 7500: return GET_LOOPS (7500);
9322 case 7600: return GET_LOOPS (7600);
9323 case 7700: return GET_LOOPS (7700);
9324 case 7800: return GET_LOOPS (7800);
9325 case 7900: return GET_LOOPS (7900);
9326 case 8000: return GET_LOOPS (8000);
9327 case 8100: return GET_LOOPS (8100);
9328 case 8200: return GET_LOOPS (8200);
9329 case 8300: return GET_LOOPS (8300);
9330 case 8400: return GET_LOOPS (8400);
9331 case 8500: return GET_LOOPS (8500);
9332 case 8600: return GET_LOOPS (8600);
9333 case 8700: return GET_LOOPS (8700);
9334 case 8800: return GET_LOOPS (8800);
9335 case 8900: return GET_LOOPS (8900);
9336 case 9000: return GET_LOOPS (9000);
9337 case 9100: return GET_LOOPS (9100);
9338 case 9200: return GET_LOOPS (9200);
9339 case 9300: return GET_LOOPS (9300);
9340 case 9400: return GET_LOOPS (9400);
9341 case 9500: return GET_LOOPS (9500);
9342 case 9600: return GET_LOOPS (9600);
9343 case 9700: return GET_LOOPS (9700);
9344 case 9710: return GET_LOOPS (9710);
9345 case 9720: return GET_LOOPS (9720);
9346 case 9800: return GET_LOOPS (9800);
9347 case 9810: return GET_LOOPS (9810);
9348 case 9820: return GET_LOOPS (9820);
9349 case 9900: return GET_LOOPS (9900);
9350 case 10000: return GET_LOOPS (10000);
9351 case 10100: return GET_LOOPS (10100);
9352 case 10200: return GET_LOOPS (10200);
9353 case 10300: return GET_LOOPS (10300);
9354 case 10400: return GET_LOOPS (10400);
9355 case 10410: return GET_LOOPS (10410);
9356 case 10420: return GET_LOOPS (10420);
9357 case 10500: return GET_LOOPS (10500);
9358 case 10600: return GET_LOOPS (10600);
9359 case 10700: return GET_LOOPS (10700);
9360 case 10800: return GET_LOOPS (10800);
9361 case 10900: return GET_LOOPS (10900);
9362 case 11000: return GET_LOOPS (11000);
9363 case 11100: return GET_LOOPS (11100);
9364 case 11200: return GET_LOOPS (11200);
9365 case 11300: return GET_LOOPS (11300);
9366 case 11400: return GET_LOOPS (11400);
9367 case 11500: return GET_LOOPS (11500);
9368 case 11600: return GET_LOOPS (11600);
9369 case 11700: return GET_LOOPS (11700);
9370 case 11800: return GET_LOOPS (11800);
9371 case 11900: return GET_LOOPS (11900);
9372 case 12000: return GET_LOOPS (12000);
9373 case 12100: return GET_LOOPS (12100);
9374 case 12200: return GET_LOOPS (12200);
9375 case 12300: return GET_LOOPS (12300);
9376 case 12400: return GET_LOOPS (12400);
9377 case 12500: return GET_LOOPS (12500);
9378 case 12600: return GET_LOOPS (12600);
9379 case 12700: return GET_LOOPS (12700);
9380 case 12800: return GET_LOOPS (12800);
9381 case 12900: return GET_LOOPS (12900);
9382 case 13000: return GET_LOOPS (13000);
9392 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9396 if (salt_len
> sizeof (tmp
))
9401 memset (tmp
, 0, sizeof (tmp
));
9402 memcpy (tmp
, in
, salt_len
);
9404 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9406 if ((salt_len
% 2) == 0)
9408 u32 new_salt_len
= salt_len
/ 2;
9410 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9415 tmp
[i
] = hex_convert (p1
) << 0;
9416 tmp
[i
] |= hex_convert (p0
) << 4;
9419 salt_len
= new_salt_len
;
9426 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9428 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9431 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9433 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9437 u32
*tmp_uint
= (u32
*) tmp
;
9439 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9440 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9441 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9442 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9443 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9444 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9445 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9446 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9447 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9448 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9450 salt_len
= salt_len
* 2;
9458 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9460 lowercase (tmp
, salt_len
);
9463 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9465 uppercase (tmp
, salt_len
);
9470 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9475 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9480 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9482 u32
*tmp_uint
= (uint
*) tmp
;
9488 for (u32 i
= 0; i
< max
; i
++)
9490 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9493 // Important: we may need to increase the length of memcpy since
9494 // we don't want to "loose" some swapped bytes (could happen if
9495 // they do not perfectly fit in the 4-byte blocks)
9496 // Memcpy does always copy the bytes in the BE order, but since
9497 // we swapped them, some important bytes could be in positions
9498 // we normally skip with the original len
9500 if (len
% 4) len
+= 4 - (len
% 4);
9503 memcpy (out
, tmp
, len
);
9508 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9510 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9512 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9514 u32
*digest
= (u32
*) hash_buf
->digest
;
9516 salt_t
*salt
= hash_buf
->salt
;
9518 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9520 char *iter_pos
= input_buf
+ 4;
9522 salt
->salt_iter
= 1 << atoi (iter_pos
);
9524 char *salt_pos
= strchr (iter_pos
, '$');
9526 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9532 salt
->salt_len
= salt_len
;
9536 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9538 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9540 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9542 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9544 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9545 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9546 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9547 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9549 char *hash_pos
= salt_pos
+ 22;
9551 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9553 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9555 memcpy (digest
, tmp_buf
, 24);
9557 digest
[0] = byte_swap_32 (digest
[0]);
9558 digest
[1] = byte_swap_32 (digest
[1]);
9559 digest
[2] = byte_swap_32 (digest
[2]);
9560 digest
[3] = byte_swap_32 (digest
[3]);
9561 digest
[4] = byte_swap_32 (digest
[4]);
9562 digest
[5] = byte_swap_32 (digest
[5]);
9564 digest
[5] &= ~0xff; // its just 23 not 24 !
9569 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9571 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9573 u32
*digest
= (u32
*) hash_buf
->digest
;
9577 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9579 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9581 memcpy (digest
, tmp_buf
, 32);
9583 digest
[0] = byte_swap_32 (digest
[0]);
9584 digest
[1] = byte_swap_32 (digest
[1]);
9585 digest
[2] = byte_swap_32 (digest
[2]);
9586 digest
[3] = byte_swap_32 (digest
[3]);
9587 digest
[4] = byte_swap_32 (digest
[4]);
9588 digest
[5] = byte_swap_32 (digest
[5]);
9589 digest
[6] = byte_swap_32 (digest
[6]);
9590 digest
[7] = byte_swap_32 (digest
[7]);
9592 digest
[0] -= SHA256M_A
;
9593 digest
[1] -= SHA256M_B
;
9594 digest
[2] -= SHA256M_C
;
9595 digest
[3] -= SHA256M_D
;
9596 digest
[4] -= SHA256M_E
;
9597 digest
[5] -= SHA256M_F
;
9598 digest
[6] -= SHA256M_G
;
9599 digest
[7] -= SHA256M_H
;
9604 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9606 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9608 u32
*digest
= (u32
*) hash_buf
->digest
;
9610 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9611 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9613 digest
[0] = byte_swap_32 (digest
[0]);
9614 digest
[1] = byte_swap_32 (digest
[1]);
9618 IP (digest
[0], digest
[1], tt
);
9620 digest
[0] = digest
[0];
9621 digest
[1] = digest
[1];
9628 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9630 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9632 u32
*digest
= (u32
*) hash_buf
->digest
;
9634 salt_t
*salt
= hash_buf
->salt
;
9636 char *hash_pos
= input_buf
+ 8;
9638 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9639 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9640 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9641 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9642 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9644 digest
[0] -= SHA1M_A
;
9645 digest
[1] -= SHA1M_B
;
9646 digest
[2] -= SHA1M_C
;
9647 digest
[3] -= SHA1M_D
;
9648 digest
[4] -= SHA1M_E
;
9652 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9654 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9656 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9658 salt
->salt_len
= salt_len
;
9663 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9665 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9667 u64
*digest
= (u64
*) hash_buf
->digest
;
9669 salt_t
*salt
= hash_buf
->salt
;
9671 char *hash_pos
= input_buf
+ 8;
9673 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9674 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9675 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9676 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9677 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9678 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9679 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9680 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9682 digest
[0] -= SHA512M_A
;
9683 digest
[1] -= SHA512M_B
;
9684 digest
[2] -= SHA512M_C
;
9685 digest
[3] -= SHA512M_D
;
9686 digest
[4] -= SHA512M_E
;
9687 digest
[5] -= SHA512M_F
;
9688 digest
[6] -= SHA512M_G
;
9689 digest
[7] -= SHA512M_H
;
9693 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9695 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9697 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9699 salt
->salt_len
= salt_len
;
9704 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9706 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9708 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9712 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9715 u32
*digest
= (u32
*) hash_buf
->digest
;
9717 salt_t
*salt
= hash_buf
->salt
;
9719 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9720 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9721 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9722 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9724 digest
[0] = byte_swap_32 (digest
[0]);
9725 digest
[1] = byte_swap_32 (digest
[1]);
9726 digest
[2] = byte_swap_32 (digest
[2]);
9727 digest
[3] = byte_swap_32 (digest
[3]);
9729 digest
[0] -= MD5M_A
;
9730 digest
[1] -= MD5M_B
;
9731 digest
[2] -= MD5M_C
;
9732 digest
[3] -= MD5M_D
;
9734 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9736 uint salt_len
= input_len
- 32 - 1;
9738 char *salt_buf
= input_buf
+ 32 + 1;
9740 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9742 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9744 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9746 salt
->salt_len
= salt_len
;
9751 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9753 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9755 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9759 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9764 char clean_input_buf
[32];
9766 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9767 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9769 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9773 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9779 clean_input_buf
[k
] = input_buf
[i
];
9787 u32
*digest
= (u32
*) hash_buf
->digest
;
9789 salt_t
*salt
= hash_buf
->salt
;
9791 u32 a
, b
, c
, d
, e
, f
;
9793 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9794 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9795 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9796 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9797 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9798 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9800 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9801 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9803 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9804 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9805 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9806 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9807 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9808 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9810 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9811 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9813 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9814 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9815 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9816 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9817 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9818 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9820 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9821 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9823 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9824 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9825 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9826 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9827 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9828 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9830 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9831 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9833 digest
[0] = byte_swap_32 (digest
[0]);
9834 digest
[1] = byte_swap_32 (digest
[1]);
9835 digest
[2] = byte_swap_32 (digest
[2]);
9836 digest
[3] = byte_swap_32 (digest
[3]);
9838 digest
[0] -= MD5M_A
;
9839 digest
[1] -= MD5M_B
;
9840 digest
[2] -= MD5M_C
;
9841 digest
[3] -= MD5M_D
;
9843 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9845 uint salt_len
= input_len
- 30 - 1;
9847 char *salt_buf
= input_buf
+ 30 + 1;
9849 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9851 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9853 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9854 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9856 salt
->salt_len
= salt_len
;
9858 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9860 salt
->salt_len
+= 22;
9865 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9867 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9869 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9873 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9876 u32
*digest
= (u32
*) hash_buf
->digest
;
9878 salt_t
*salt
= hash_buf
->salt
;
9880 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9881 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9882 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9883 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9884 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9886 digest
[0] -= SHA1M_A
;
9887 digest
[1] -= SHA1M_B
;
9888 digest
[2] -= SHA1M_C
;
9889 digest
[3] -= SHA1M_D
;
9890 digest
[4] -= SHA1M_E
;
9892 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9894 uint salt_len
= input_len
- 40 - 1;
9896 char *salt_buf
= input_buf
+ 40 + 1;
9898 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9900 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9902 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9904 salt
->salt_len
= salt_len
;
9909 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9911 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9913 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9917 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9920 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9922 char *iter_pos
= input_buf
+ 6;
9924 salt_t
*salt
= hash_buf
->salt
;
9926 uint iter
= atoi (iter_pos
);
9933 salt
->salt_iter
= iter
- 1;
9935 char *salt_pos
= strchr (iter_pos
, '#');
9937 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9941 char *digest_pos
= strchr (salt_pos
, '#');
9943 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9947 uint salt_len
= digest_pos
- salt_pos
- 1;
9949 u32
*digest
= (u32
*) hash_buf
->digest
;
9951 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9952 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9953 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9954 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9956 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9958 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9960 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9962 salt
->salt_len
= salt_len
;
9967 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9969 u32
*digest
= (u32
*) hash_buf
->digest
;
9971 salt_t
*salt
= hash_buf
->salt
;
9973 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9977 memcpy (&in
, input_buf
, input_len
);
9979 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9981 memcpy (digest
, in
.keymic
, 16);
9984 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9985 The phrase "Pairwise key expansion"
9986 Access Point Address (referred to as Authenticator Address AA)
9987 Supplicant Address (referred to as Supplicant Address SA)
9988 Access Point Nonce (referred to as Authenticator Anonce)
9989 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9992 uint salt_len
= strlen (in
.essid
);
9994 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9996 salt
->salt_len
= salt_len
;
9998 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10000 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10002 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10004 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10006 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10007 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10011 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10012 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10015 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10017 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10018 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10022 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10023 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10026 for (int i
= 0; i
< 25; i
++)
10028 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10031 wpa
->keyver
= in
.keyver
;
10033 if (wpa
->keyver
> 255)
10035 log_info ("ATTENTION!");
10036 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10037 log_info (" This could be due to a recent aircrack-ng bug.");
10038 log_info (" The key version was automatically reset to a reasonable value.");
10041 wpa
->keyver
&= 0xff;
10044 wpa
->eapol_size
= in
.eapol_size
;
10046 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10048 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10050 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10052 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10054 if (wpa
->keyver
== 1)
10060 digest
[0] = byte_swap_32 (digest
[0]);
10061 digest
[1] = byte_swap_32 (digest
[1]);
10062 digest
[2] = byte_swap_32 (digest
[2]);
10063 digest
[3] = byte_swap_32 (digest
[3]);
10065 for (int i
= 0; i
< 64; i
++)
10067 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10071 salt
->salt_buf
[10] = digest
[1];
10072 salt
->salt_buf
[11] = digest
[2];
10074 return (PARSER_OK
);
10077 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10079 u32
*digest
= (u32
*) hash_buf
->digest
;
10081 salt_t
*salt
= hash_buf
->salt
;
10083 if (input_len
== 0)
10085 log_error ("Password Safe v2 container not specified");
10090 FILE *fp
= fopen (input_buf
, "rb");
10094 log_error ("%s: %s", input_buf
, strerror (errno
));
10101 memset (&buf
, 0, sizeof (psafe2_hdr
));
10103 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10107 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10109 salt
->salt_buf
[0] = buf
.random
[0];
10110 salt
->salt_buf
[1] = buf
.random
[1];
10112 salt
->salt_len
= 8;
10113 salt
->salt_iter
= 1000;
10115 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10116 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10117 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10118 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10119 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10121 return (PARSER_OK
);
10124 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10126 u32
*digest
= (u32
*) hash_buf
->digest
;
10128 salt_t
*salt
= hash_buf
->salt
;
10130 if (input_len
== 0)
10132 log_error (".psafe3 not specified");
10137 FILE *fp
= fopen (input_buf
, "rb");
10141 log_error ("%s: %s", input_buf
, strerror (errno
));
10148 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10152 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10154 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10156 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10158 salt
->salt_iter
= in
.iterations
+ 1;
10160 salt
->salt_buf
[0] = in
.salt_buf
[0];
10161 salt
->salt_buf
[1] = in
.salt_buf
[1];
10162 salt
->salt_buf
[2] = in
.salt_buf
[2];
10163 salt
->salt_buf
[3] = in
.salt_buf
[3];
10164 salt
->salt_buf
[4] = in
.salt_buf
[4];
10165 salt
->salt_buf
[5] = in
.salt_buf
[5];
10166 salt
->salt_buf
[6] = in
.salt_buf
[6];
10167 salt
->salt_buf
[7] = in
.salt_buf
[7];
10169 salt
->salt_len
= 32;
10171 digest
[0] = in
.hash_buf
[0];
10172 digest
[1] = in
.hash_buf
[1];
10173 digest
[2] = in
.hash_buf
[2];
10174 digest
[3] = in
.hash_buf
[3];
10175 digest
[4] = in
.hash_buf
[4];
10176 digest
[5] = in
.hash_buf
[5];
10177 digest
[6] = in
.hash_buf
[6];
10178 digest
[7] = in
.hash_buf
[7];
10180 digest
[0] = byte_swap_32 (digest
[0]);
10181 digest
[1] = byte_swap_32 (digest
[1]);
10182 digest
[2] = byte_swap_32 (digest
[2]);
10183 digest
[3] = byte_swap_32 (digest
[3]);
10184 digest
[4] = byte_swap_32 (digest
[4]);
10185 digest
[5] = byte_swap_32 (digest
[5]);
10186 digest
[6] = byte_swap_32 (digest
[6]);
10187 digest
[7] = byte_swap_32 (digest
[7]);
10189 return (PARSER_OK
);
10192 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10194 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10196 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10198 u32
*digest
= (u32
*) hash_buf
->digest
;
10200 salt_t
*salt
= hash_buf
->salt
;
10202 char *iter_pos
= input_buf
+ 3;
10204 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10206 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10208 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10210 salt
->salt_iter
= salt_iter
;
10212 char *salt_pos
= iter_pos
+ 1;
10216 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10218 salt
->salt_len
= salt_len
;
10220 char *hash_pos
= salt_pos
+ salt_len
;
10222 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10224 return (PARSER_OK
);
10227 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10229 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10231 u32
*digest
= (u32
*) hash_buf
->digest
;
10233 salt_t
*salt
= hash_buf
->salt
;
10235 char *salt_pos
= input_buf
+ 3;
10237 uint iterations_len
= 0;
10239 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10243 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10245 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10246 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10250 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10254 iterations_len
+= 8;
10258 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10261 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10263 char *hash_pos
= strchr (salt_pos
, '$');
10265 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10267 uint salt_len
= hash_pos
- salt_pos
;
10269 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10271 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10273 salt
->salt_len
= salt_len
;
10277 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10279 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10281 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10283 return (PARSER_OK
);
10286 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10288 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10290 u32
*digest
= (u32
*) hash_buf
->digest
;
10292 salt_t
*salt
= hash_buf
->salt
;
10294 char *salt_pos
= input_buf
+ 6;
10296 uint iterations_len
= 0;
10298 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10302 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10304 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10305 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10309 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10313 iterations_len
+= 8;
10317 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10320 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10322 char *hash_pos
= strchr (salt_pos
, '$');
10324 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10326 uint salt_len
= hash_pos
- salt_pos
;
10328 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10330 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10332 salt
->salt_len
= salt_len
;
10336 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10338 return (PARSER_OK
);
10341 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10343 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10345 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10347 u32
*digest
= (u32
*) hash_buf
->digest
;
10349 salt_t
*salt
= hash_buf
->salt
;
10351 char *salt_pos
= input_buf
+ 14;
10353 char *hash_pos
= strchr (salt_pos
, '*');
10355 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10359 uint salt_len
= hash_pos
- salt_pos
- 1;
10361 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10363 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10365 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10367 salt
->salt_len
= salt_len
;
10371 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10373 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10375 memcpy (digest
, tmp_buf
, 20);
10377 digest
[0] = byte_swap_32 (digest
[0]);
10378 digest
[1] = byte_swap_32 (digest
[1]);
10379 digest
[2] = byte_swap_32 (digest
[2]);
10380 digest
[3] = byte_swap_32 (digest
[3]);
10381 digest
[4] = byte_swap_32 (digest
[4]);
10383 digest
[0] -= SHA1M_A
;
10384 digest
[1] -= SHA1M_B
;
10385 digest
[2] -= SHA1M_C
;
10386 digest
[3] -= SHA1M_D
;
10387 digest
[4] -= SHA1M_E
;
10389 return (PARSER_OK
);
10392 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10394 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10396 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10398 if (c12
& 3) return (PARSER_HASH_VALUE
);
10400 u32
*digest
= (u32
*) hash_buf
->digest
;
10402 salt_t
*salt
= hash_buf
->salt
;
10404 // for ascii_digest
10405 salt
->salt_sign
[0] = input_buf
[0];
10406 salt
->salt_sign
[1] = input_buf
[1];
10408 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10409 | itoa64_to_int (input_buf
[1]) << 6;
10411 salt
->salt_len
= 2;
10415 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10417 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10419 memcpy (digest
, tmp_buf
, 8);
10423 IP (digest
[0], digest
[1], tt
);
10428 return (PARSER_OK
);
10431 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10433 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10435 u32
*digest
= (u32
*) hash_buf
->digest
;
10437 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10438 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10439 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10440 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10442 digest
[0] = byte_swap_32 (digest
[0]);
10443 digest
[1] = byte_swap_32 (digest
[1]);
10444 digest
[2] = byte_swap_32 (digest
[2]);
10445 digest
[3] = byte_swap_32 (digest
[3]);
10447 digest
[0] -= MD4M_A
;
10448 digest
[1] -= MD4M_B
;
10449 digest
[2] -= MD4M_C
;
10450 digest
[3] -= MD4M_D
;
10452 return (PARSER_OK
);
10455 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10457 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10459 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10463 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10466 u32
*digest
= (u32
*) hash_buf
->digest
;
10468 salt_t
*salt
= hash_buf
->salt
;
10470 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10471 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10472 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10473 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10475 digest
[0] = byte_swap_32 (digest
[0]);
10476 digest
[1] = byte_swap_32 (digest
[1]);
10477 digest
[2] = byte_swap_32 (digest
[2]);
10478 digest
[3] = byte_swap_32 (digest
[3]);
10480 digest
[0] -= MD4M_A
;
10481 digest
[1] -= MD4M_B
;
10482 digest
[2] -= MD4M_C
;
10483 digest
[3] -= MD4M_D
;
10485 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10487 uint salt_len
= input_len
- 32 - 1;
10489 char *salt_buf
= input_buf
+ 32 + 1;
10491 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10493 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10495 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10497 salt
->salt_len
= salt_len
;
10499 return (PARSER_OK
);
10502 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10504 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10506 u32
*digest
= (u32
*) hash_buf
->digest
;
10508 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10509 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10510 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10511 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10513 digest
[0] = byte_swap_32 (digest
[0]);
10514 digest
[1] = byte_swap_32 (digest
[1]);
10515 digest
[2] = byte_swap_32 (digest
[2]);
10516 digest
[3] = byte_swap_32 (digest
[3]);
10518 digest
[0] -= MD5M_A
;
10519 digest
[1] -= MD5M_B
;
10520 digest
[2] -= MD5M_C
;
10521 digest
[3] -= MD5M_D
;
10523 return (PARSER_OK
);
10526 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10528 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10530 u32
*digest
= (u32
*) hash_buf
->digest
;
10532 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10533 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10537 digest
[0] = byte_swap_32 (digest
[0]);
10538 digest
[1] = byte_swap_32 (digest
[1]);
10540 return (PARSER_OK
);
10543 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10545 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10547 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10551 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10554 u32
*digest
= (u32
*) hash_buf
->digest
;
10556 salt_t
*salt
= hash_buf
->salt
;
10558 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10559 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10560 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10561 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10563 digest
[0] = byte_swap_32 (digest
[0]);
10564 digest
[1] = byte_swap_32 (digest
[1]);
10565 digest
[2] = byte_swap_32 (digest
[2]);
10566 digest
[3] = byte_swap_32 (digest
[3]);
10568 digest
[0] -= MD5M_A
;
10569 digest
[1] -= MD5M_B
;
10570 digest
[2] -= MD5M_C
;
10571 digest
[3] -= MD5M_D
;
10573 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10575 uint salt_len
= input_len
- 32 - 1;
10577 char *salt_buf
= input_buf
+ 32 + 1;
10579 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10581 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10583 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10585 salt
->salt_len
= salt_len
;
10587 return (PARSER_OK
);
10590 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10592 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10594 u32
*digest
= (u32
*) hash_buf
->digest
;
10596 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10597 | itoa64_to_int (input_buf
[ 1]) << 6
10598 | itoa64_to_int (input_buf
[ 2]) << 12
10599 | itoa64_to_int (input_buf
[ 3]) << 18;
10600 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10601 | itoa64_to_int (input_buf
[ 5]) << 6
10602 | itoa64_to_int (input_buf
[ 6]) << 12
10603 | itoa64_to_int (input_buf
[ 7]) << 18;
10604 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10605 | itoa64_to_int (input_buf
[ 9]) << 6
10606 | itoa64_to_int (input_buf
[10]) << 12
10607 | itoa64_to_int (input_buf
[11]) << 18;
10608 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10609 | itoa64_to_int (input_buf
[13]) << 6
10610 | itoa64_to_int (input_buf
[14]) << 12
10611 | itoa64_to_int (input_buf
[15]) << 18;
10613 digest
[0] -= MD5M_A
;
10614 digest
[1] -= MD5M_B
;
10615 digest
[2] -= MD5M_C
;
10616 digest
[3] -= MD5M_D
;
10618 digest
[0] &= 0x00ffffff;
10619 digest
[1] &= 0x00ffffff;
10620 digest
[2] &= 0x00ffffff;
10621 digest
[3] &= 0x00ffffff;
10623 return (PARSER_OK
);
10626 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10628 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10630 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10634 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10637 u32
*digest
= (u32
*) hash_buf
->digest
;
10639 salt_t
*salt
= hash_buf
->salt
;
10641 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10642 | itoa64_to_int (input_buf
[ 1]) << 6
10643 | itoa64_to_int (input_buf
[ 2]) << 12
10644 | itoa64_to_int (input_buf
[ 3]) << 18;
10645 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10646 | itoa64_to_int (input_buf
[ 5]) << 6
10647 | itoa64_to_int (input_buf
[ 6]) << 12
10648 | itoa64_to_int (input_buf
[ 7]) << 18;
10649 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10650 | itoa64_to_int (input_buf
[ 9]) << 6
10651 | itoa64_to_int (input_buf
[10]) << 12
10652 | itoa64_to_int (input_buf
[11]) << 18;
10653 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10654 | itoa64_to_int (input_buf
[13]) << 6
10655 | itoa64_to_int (input_buf
[14]) << 12
10656 | itoa64_to_int (input_buf
[15]) << 18;
10658 digest
[0] -= MD5M_A
;
10659 digest
[1] -= MD5M_B
;
10660 digest
[2] -= MD5M_C
;
10661 digest
[3] -= MD5M_D
;
10663 digest
[0] &= 0x00ffffff;
10664 digest
[1] &= 0x00ffffff;
10665 digest
[2] &= 0x00ffffff;
10666 digest
[3] &= 0x00ffffff;
10668 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10670 uint salt_len
= input_len
- 16 - 1;
10672 char *salt_buf
= input_buf
+ 16 + 1;
10674 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10676 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10678 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10680 salt
->salt_len
= salt_len
;
10682 return (PARSER_OK
);
10685 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10687 key
[0] = (nthash
[0] >> 0);
10688 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10689 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10690 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10691 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10692 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10693 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10694 key
[7] = (nthash
[6] << 1);
10706 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10708 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10710 u32
*digest
= (u32
*) hash_buf
->digest
;
10712 salt_t
*salt
= hash_buf
->salt
;
10714 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10720 char *user_pos
= input_buf
;
10722 char *unused_pos
= strchr (user_pos
, ':');
10724 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10726 uint user_len
= unused_pos
- user_pos
;
10728 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10732 char *domain_pos
= strchr (unused_pos
, ':');
10734 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10736 uint unused_len
= domain_pos
- unused_pos
;
10738 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10742 char *srvchall_pos
= strchr (domain_pos
, ':');
10744 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10746 uint domain_len
= srvchall_pos
- domain_pos
;
10748 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10752 char *hash_pos
= strchr (srvchall_pos
, ':');
10754 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10756 uint srvchall_len
= hash_pos
- srvchall_pos
;
10758 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10762 char *clichall_pos
= strchr (hash_pos
, ':');
10764 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10766 uint hash_len
= clichall_pos
- hash_pos
;
10768 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10772 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10774 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10777 * store some data for later use
10780 netntlm
->user_len
= user_len
* 2;
10781 netntlm
->domain_len
= domain_len
* 2;
10782 netntlm
->srvchall_len
= srvchall_len
/ 2;
10783 netntlm
->clichall_len
= clichall_len
/ 2;
10785 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10786 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10789 * handle username and domainname
10792 for (uint i
= 0; i
< user_len
; i
++)
10794 *userdomain_ptr
++ = user_pos
[i
];
10795 *userdomain_ptr
++ = 0;
10798 for (uint i
= 0; i
< domain_len
; i
++)
10800 *userdomain_ptr
++ = domain_pos
[i
];
10801 *userdomain_ptr
++ = 0;
10805 * handle server challenge encoding
10808 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10810 const char p0
= srvchall_pos
[i
+ 0];
10811 const char p1
= srvchall_pos
[i
+ 1];
10813 *chall_ptr
++ = hex_convert (p1
) << 0
10814 | hex_convert (p0
) << 4;
10818 * handle client challenge encoding
10821 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10823 const char p0
= clichall_pos
[i
+ 0];
10824 const char p1
= clichall_pos
[i
+ 1];
10826 *chall_ptr
++ = hex_convert (p1
) << 0
10827 | hex_convert (p0
) << 4;
10834 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10836 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10838 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10840 salt
->salt_len
= salt_len
;
10842 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10843 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10844 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10845 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10847 digest
[0] = byte_swap_32 (digest
[0]);
10848 digest
[1] = byte_swap_32 (digest
[1]);
10849 digest
[2] = byte_swap_32 (digest
[2]);
10850 digest
[3] = byte_swap_32 (digest
[3]);
10852 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10854 uint digest_tmp
[2];
10856 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10857 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10859 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10860 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10862 /* special case 2: ESS */
10864 if (srvchall_len
== 48)
10866 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10870 w
[ 0] = netntlm
->chall_buf
[6];
10871 w
[ 1] = netntlm
->chall_buf
[7];
10872 w
[ 2] = netntlm
->chall_buf
[0];
10873 w
[ 3] = netntlm
->chall_buf
[1];
10896 salt
->salt_buf
[0] = dgst
[0];
10897 salt
->salt_buf
[1] = dgst
[1];
10901 /* precompute netntlmv1 exploit start */
10903 for (uint i
= 0; i
< 0x10000; i
++)
10905 uint key_md4
[2] = { i
, 0 };
10906 uint key_des
[2] = { 0, 0 };
10908 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10913 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10915 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10917 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10919 if (data3
[0] != digest_tmp
[0]) continue;
10920 if (data3
[1] != digest_tmp
[1]) continue;
10922 salt
->salt_buf
[2] = i
;
10924 salt
->salt_len
= 24;
10929 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10930 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10932 /* precompute netntlmv1 exploit stop */
10936 IP (digest
[0], digest
[1], tt
);
10937 IP (digest
[2], digest
[3], tt
);
10939 digest
[0] = rotr32 (digest
[0], 29);
10940 digest
[1] = rotr32 (digest
[1], 29);
10941 digest
[2] = rotr32 (digest
[2], 29);
10942 digest
[3] = rotr32 (digest
[3], 29);
10944 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10946 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10947 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10949 return (PARSER_OK
);
10952 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10954 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10956 u32
*digest
= (u32
*) hash_buf
->digest
;
10958 salt_t
*salt
= hash_buf
->salt
;
10960 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10966 char *user_pos
= input_buf
;
10968 char *unused_pos
= strchr (user_pos
, ':');
10970 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10972 uint user_len
= unused_pos
- user_pos
;
10974 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10978 char *domain_pos
= strchr (unused_pos
, ':');
10980 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10982 uint unused_len
= domain_pos
- unused_pos
;
10984 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10988 char *srvchall_pos
= strchr (domain_pos
, ':');
10990 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10992 uint domain_len
= srvchall_pos
- domain_pos
;
10994 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10998 char *hash_pos
= strchr (srvchall_pos
, ':');
11000 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11002 uint srvchall_len
= hash_pos
- srvchall_pos
;
11004 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11008 char *clichall_pos
= strchr (hash_pos
, ':');
11010 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11012 uint hash_len
= clichall_pos
- hash_pos
;
11014 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11018 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11020 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11022 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11025 * store some data for later use
11028 netntlm
->user_len
= user_len
* 2;
11029 netntlm
->domain_len
= domain_len
* 2;
11030 netntlm
->srvchall_len
= srvchall_len
/ 2;
11031 netntlm
->clichall_len
= clichall_len
/ 2;
11033 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11034 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11037 * handle username and domainname
11040 for (uint i
= 0; i
< user_len
; i
++)
11042 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11043 *userdomain_ptr
++ = 0;
11046 for (uint i
= 0; i
< domain_len
; i
++)
11048 *userdomain_ptr
++ = domain_pos
[i
];
11049 *userdomain_ptr
++ = 0;
11052 *userdomain_ptr
++ = 0x80;
11055 * handle server challenge encoding
11058 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11060 const char p0
= srvchall_pos
[i
+ 0];
11061 const char p1
= srvchall_pos
[i
+ 1];
11063 *chall_ptr
++ = hex_convert (p1
) << 0
11064 | hex_convert (p0
) << 4;
11068 * handle client challenge encoding
11071 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11073 const char p0
= clichall_pos
[i
+ 0];
11074 const char p1
= clichall_pos
[i
+ 1];
11076 *chall_ptr
++ = hex_convert (p1
) << 0
11077 | hex_convert (p0
) << 4;
11080 *chall_ptr
++ = 0x80;
11083 * handle hash itself
11086 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11087 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11088 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11089 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11091 digest
[0] = byte_swap_32 (digest
[0]);
11092 digest
[1] = byte_swap_32 (digest
[1]);
11093 digest
[2] = byte_swap_32 (digest
[2]);
11094 digest
[3] = byte_swap_32 (digest
[3]);
11097 * reuse challange data as salt_buf, its the buffer that is most likely unique
11100 salt
->salt_buf
[0] = 0;
11101 salt
->salt_buf
[1] = 0;
11102 salt
->salt_buf
[2] = 0;
11103 salt
->salt_buf
[3] = 0;
11104 salt
->salt_buf
[4] = 0;
11105 salt
->salt_buf
[5] = 0;
11106 salt
->salt_buf
[6] = 0;
11107 salt
->salt_buf
[7] = 0;
11111 uptr
= (uint
*) netntlm
->userdomain_buf
;
11113 for (uint i
= 0; i
< 16; i
+= 16)
11115 md5_64 (uptr
, salt
->salt_buf
);
11118 uptr
= (uint
*) netntlm
->chall_buf
;
11120 for (uint i
= 0; i
< 256; i
+= 16)
11122 md5_64 (uptr
, salt
->salt_buf
);
11125 salt
->salt_len
= 16;
11127 return (PARSER_OK
);
11130 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11132 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11134 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11138 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11141 u32
*digest
= (u32
*) hash_buf
->digest
;
11143 salt_t
*salt
= hash_buf
->salt
;
11145 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11146 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11147 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11148 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11150 digest
[0] = byte_swap_32 (digest
[0]);
11151 digest
[1] = byte_swap_32 (digest
[1]);
11152 digest
[2] = byte_swap_32 (digest
[2]);
11153 digest
[3] = byte_swap_32 (digest
[3]);
11155 digest
[0] -= MD5M_A
;
11156 digest
[1] -= MD5M_B
;
11157 digest
[2] -= MD5M_C
;
11158 digest
[3] -= MD5M_D
;
11160 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11162 uint salt_len
= input_len
- 32 - 1;
11164 char *salt_buf
= input_buf
+ 32 + 1;
11166 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11168 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11170 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11172 salt
->salt_len
= salt_len
;
11174 return (PARSER_OK
);
11177 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11179 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11181 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11185 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11188 u32
*digest
= (u32
*) hash_buf
->digest
;
11190 salt_t
*salt
= hash_buf
->salt
;
11192 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11193 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11194 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11195 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11197 digest
[0] = byte_swap_32 (digest
[0]);
11198 digest
[1] = byte_swap_32 (digest
[1]);
11199 digest
[2] = byte_swap_32 (digest
[2]);
11200 digest
[3] = byte_swap_32 (digest
[3]);
11202 digest
[0] -= MD5M_A
;
11203 digest
[1] -= MD5M_B
;
11204 digest
[2] -= MD5M_C
;
11205 digest
[3] -= MD5M_D
;
11207 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11209 uint salt_len
= input_len
- 32 - 1;
11211 char *salt_buf
= input_buf
+ 32 + 1;
11213 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11215 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11217 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11219 salt
->salt_len
= salt_len
;
11221 return (PARSER_OK
);
11224 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11226 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11228 u32
*digest
= (u32
*) hash_buf
->digest
;
11230 salt_t
*salt
= hash_buf
->salt
;
11232 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11233 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11234 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11235 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11237 digest
[0] = byte_swap_32 (digest
[0]);
11238 digest
[1] = byte_swap_32 (digest
[1]);
11239 digest
[2] = byte_swap_32 (digest
[2]);
11240 digest
[3] = byte_swap_32 (digest
[3]);
11242 digest
[0] -= MD5M_A
;
11243 digest
[1] -= MD5M_B
;
11244 digest
[2] -= MD5M_C
;
11245 digest
[3] -= MD5M_D
;
11248 * This is a virtual salt. While the algorithm is basically not salted
11249 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11250 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11253 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11255 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11257 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11259 salt
->salt_len
= salt_len
;
11261 return (PARSER_OK
);
11264 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11266 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11268 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11272 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11275 u32
*digest
= (u32
*) hash_buf
->digest
;
11277 salt_t
*salt
= hash_buf
->salt
;
11279 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11280 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11281 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11282 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11284 digest
[0] = byte_swap_32 (digest
[0]);
11285 digest
[1] = byte_swap_32 (digest
[1]);
11286 digest
[2] = byte_swap_32 (digest
[2]);
11287 digest
[3] = byte_swap_32 (digest
[3]);
11289 digest
[0] -= MD5M_A
;
11290 digest
[1] -= MD5M_B
;
11291 digest
[2] -= MD5M_C
;
11292 digest
[3] -= MD5M_D
;
11294 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11296 uint salt_len
= input_len
- 32 - 1;
11298 char *salt_buf
= input_buf
+ 32 + 1;
11300 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11302 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11304 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11306 salt
->salt_len
= salt_len
;
11308 return (PARSER_OK
);
11311 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11313 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11315 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11319 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11322 u32
*digest
= (u32
*) hash_buf
->digest
;
11324 salt_t
*salt
= hash_buf
->salt
;
11326 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11327 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11328 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11329 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11331 digest
[0] = byte_swap_32 (digest
[0]);
11332 digest
[1] = byte_swap_32 (digest
[1]);
11333 digest
[2] = byte_swap_32 (digest
[2]);
11334 digest
[3] = byte_swap_32 (digest
[3]);
11336 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11338 uint salt_len
= input_len
- 32 - 1;
11340 char *salt_buf
= input_buf
+ 32 + 1;
11342 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11344 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11346 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11348 salt
->salt_len
= salt_len
;
11350 return (PARSER_OK
);
11353 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11355 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11357 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11361 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11364 u32
*digest
= (u32
*) hash_buf
->digest
;
11366 salt_t
*salt
= hash_buf
->salt
;
11368 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11369 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11370 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11371 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11373 digest
[0] = byte_swap_32 (digest
[0]);
11374 digest
[1] = byte_swap_32 (digest
[1]);
11375 digest
[2] = byte_swap_32 (digest
[2]);
11376 digest
[3] = byte_swap_32 (digest
[3]);
11378 digest
[0] -= MD4M_A
;
11379 digest
[1] -= MD4M_B
;
11380 digest
[2] -= MD4M_C
;
11381 digest
[3] -= MD4M_D
;
11383 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11385 uint salt_len
= input_len
- 32 - 1;
11387 char *salt_buf
= input_buf
+ 32 + 1;
11389 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11391 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11393 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11395 salt
->salt_len
= salt_len
;
11397 return (PARSER_OK
);
11400 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11402 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11404 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11408 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11411 u32
*digest
= (u32
*) hash_buf
->digest
;
11413 salt_t
*salt
= hash_buf
->salt
;
11415 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11416 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11417 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11418 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11420 digest
[0] = byte_swap_32 (digest
[0]);
11421 digest
[1] = byte_swap_32 (digest
[1]);
11422 digest
[2] = byte_swap_32 (digest
[2]);
11423 digest
[3] = byte_swap_32 (digest
[3]);
11425 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11427 uint salt_len
= input_len
- 32 - 1;
11429 char *salt_buf
= input_buf
+ 32 + 1;
11431 uint salt_pc_block
[16];
11433 memset (salt_pc_block
, 0, sizeof (salt_pc_block
));
11435 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11437 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11439 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11441 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11443 salt_pc_block
[14] = salt_len
* 8;
11445 uint salt_pc_digest
[4];
11447 salt_pc_digest
[0] = MAGIC_A
;
11448 salt_pc_digest
[1] = MAGIC_B
;
11449 salt_pc_digest
[2] = MAGIC_C
;
11450 salt_pc_digest
[3] = MAGIC_D
;
11452 md5_64 (salt_pc_block
, salt_pc_digest
);
11454 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11455 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11456 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11457 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11459 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11461 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11463 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11465 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11466 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11467 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11468 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11470 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11472 return (PARSER_OK
);
11475 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11477 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11479 u32
*digest
= (u32
*) hash_buf
->digest
;
11481 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11482 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11483 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11484 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11485 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11487 digest
[0] -= SHA1M_A
;
11488 digest
[1] -= SHA1M_B
;
11489 digest
[2] -= SHA1M_C
;
11490 digest
[3] -= SHA1M_D
;
11491 digest
[4] -= SHA1M_E
;
11493 return (PARSER_OK
);
11496 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11498 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11500 u32
*digest
= (u32
*) hash_buf
->digest
;
11502 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11503 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11504 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11505 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11506 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11508 return (PARSER_OK
);
11511 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11513 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11515 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11519 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11522 u32
*digest
= (u32
*) hash_buf
->digest
;
11524 salt_t
*salt
= hash_buf
->salt
;
11526 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11527 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11528 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11529 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11530 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11532 digest
[0] -= SHA1M_A
;
11533 digest
[1] -= SHA1M_B
;
11534 digest
[2] -= SHA1M_C
;
11535 digest
[3] -= SHA1M_D
;
11536 digest
[4] -= SHA1M_E
;
11538 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11540 uint salt_len
= input_len
- 40 - 1;
11542 char *salt_buf
= input_buf
+ 40 + 1;
11544 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11546 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11548 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11550 salt
->salt_len
= salt_len
;
11552 return (PARSER_OK
);
11555 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11557 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11559 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11561 u32
*digest
= (u32
*) hash_buf
->digest
;
11565 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11567 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11569 memcpy (digest
, tmp_buf
, 20);
11571 digest
[0] = byte_swap_32 (digest
[0]);
11572 digest
[1] = byte_swap_32 (digest
[1]);
11573 digest
[2] = byte_swap_32 (digest
[2]);
11574 digest
[3] = byte_swap_32 (digest
[3]);
11575 digest
[4] = byte_swap_32 (digest
[4]);
11577 digest
[0] -= SHA1M_A
;
11578 digest
[1] -= SHA1M_B
;
11579 digest
[2] -= SHA1M_C
;
11580 digest
[3] -= SHA1M_D
;
11581 digest
[4] -= SHA1M_E
;
11583 return (PARSER_OK
);
11586 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11588 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11590 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11592 u32
*digest
= (u32
*) hash_buf
->digest
;
11594 salt_t
*salt
= hash_buf
->salt
;
11598 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11600 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11602 memcpy (digest
, tmp_buf
, 20);
11604 salt
->salt_len
= tmp_len
- 20;
11606 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11608 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11610 char *ptr
= (char *) salt
->salt_buf
;
11612 ptr
[salt
->salt_len
] = 0x80;
11615 digest
[0] = byte_swap_32 (digest
[0]);
11616 digest
[1] = byte_swap_32 (digest
[1]);
11617 digest
[2] = byte_swap_32 (digest
[2]);
11618 digest
[3] = byte_swap_32 (digest
[3]);
11619 digest
[4] = byte_swap_32 (digest
[4]);
11621 digest
[0] -= SHA1M_A
;
11622 digest
[1] -= SHA1M_B
;
11623 digest
[2] -= SHA1M_C
;
11624 digest
[3] -= SHA1M_D
;
11625 digest
[4] -= SHA1M_E
;
11627 return (PARSER_OK
);
11630 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11632 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11634 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11636 u32
*digest
= (u32
*) hash_buf
->digest
;
11638 salt_t
*salt
= hash_buf
->salt
;
11640 char *salt_buf
= input_buf
+ 6;
11644 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11646 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11648 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11650 salt
->salt_len
= salt_len
;
11652 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11654 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11655 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11656 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11657 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11658 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11660 digest
[0] -= SHA1M_A
;
11661 digest
[1] -= SHA1M_B
;
11662 digest
[2] -= SHA1M_C
;
11663 digest
[3] -= SHA1M_D
;
11664 digest
[4] -= SHA1M_E
;
11666 return (PARSER_OK
);
11669 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11671 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11673 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11675 u32
*digest
= (u32
*) hash_buf
->digest
;
11677 salt_t
*salt
= hash_buf
->salt
;
11679 char *salt_buf
= input_buf
+ 6;
11683 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11685 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11687 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11689 salt
->salt_len
= salt_len
;
11691 char *hash_pos
= input_buf
+ 6 + 8;
11693 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11694 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11695 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11696 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11697 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11699 digest
[0] -= SHA1M_A
;
11700 digest
[1] -= SHA1M_B
;
11701 digest
[2] -= SHA1M_C
;
11702 digest
[3] -= SHA1M_D
;
11703 digest
[4] -= SHA1M_E
;
11705 return (PARSER_OK
);
11708 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11710 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11712 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11714 u64
*digest
= (u64
*) hash_buf
->digest
;
11716 salt_t
*salt
= hash_buf
->salt
;
11718 char *salt_buf
= input_buf
+ 6;
11722 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11724 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11726 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11728 salt
->salt_len
= salt_len
;
11730 char *hash_pos
= input_buf
+ 6 + 8;
11732 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11733 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11734 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11735 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11736 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11737 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11738 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11739 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11741 digest
[0] -= SHA512M_A
;
11742 digest
[1] -= SHA512M_B
;
11743 digest
[2] -= SHA512M_C
;
11744 digest
[3] -= SHA512M_D
;
11745 digest
[4] -= SHA512M_E
;
11746 digest
[5] -= SHA512M_F
;
11747 digest
[6] -= SHA512M_G
;
11748 digest
[7] -= SHA512M_H
;
11750 return (PARSER_OK
);
11753 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11755 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11757 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11761 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11764 u32
*digest
= (u32
*) hash_buf
->digest
;
11766 salt_t
*salt
= hash_buf
->salt
;
11768 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11769 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11773 digest
[0] = byte_swap_32 (digest
[0]);
11774 digest
[1] = byte_swap_32 (digest
[1]);
11776 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11778 uint salt_len
= input_len
- 16 - 1;
11780 char *salt_buf
= input_buf
+ 16 + 1;
11782 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11784 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11786 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11788 salt
->salt_len
= salt_len
;
11790 return (PARSER_OK
);
11793 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11795 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11797 u32
*digest
= (u32
*) hash_buf
->digest
;
11799 salt_t
*salt
= hash_buf
->salt
;
11801 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11802 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11803 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11804 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11805 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11807 digest
[0] -= SHA1M_A
;
11808 digest
[1] -= SHA1M_B
;
11809 digest
[2] -= SHA1M_C
;
11810 digest
[3] -= SHA1M_D
;
11811 digest
[4] -= SHA1M_E
;
11813 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11815 uint salt_len
= input_len
- 40 - 1;
11817 char *salt_buf
= input_buf
+ 40 + 1;
11819 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11821 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11823 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11825 salt
->salt_len
= salt_len
;
11827 return (PARSER_OK
);
11830 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11832 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11834 u32
*digest
= (u32
*) hash_buf
->digest
;
11836 salt_t
*salt
= hash_buf
->salt
;
11838 char *hash_pos
= input_buf
;
11840 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11841 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11842 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11843 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11844 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11845 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11846 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11847 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11848 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11849 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11850 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11851 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11852 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11853 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11854 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11855 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11857 char *salt_pos
= input_buf
+ 128;
11859 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11860 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11861 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11862 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11864 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11865 salt
->salt_len
= 16;
11867 return (PARSER_OK
);
11870 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11872 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11874 u32
*digest
= (u32
*) hash_buf
->digest
;
11876 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11877 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11878 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11879 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11880 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11881 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11882 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11883 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11885 digest
[0] -= SHA256M_A
;
11886 digest
[1] -= SHA256M_B
;
11887 digest
[2] -= SHA256M_C
;
11888 digest
[3] -= SHA256M_D
;
11889 digest
[4] -= SHA256M_E
;
11890 digest
[5] -= SHA256M_F
;
11891 digest
[6] -= SHA256M_G
;
11892 digest
[7] -= SHA256M_H
;
11894 return (PARSER_OK
);
11897 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11899 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11901 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11905 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11908 u32
*digest
= (u32
*) hash_buf
->digest
;
11910 salt_t
*salt
= hash_buf
->salt
;
11912 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11913 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11914 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11915 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11916 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11917 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11918 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11919 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11921 digest
[0] -= SHA256M_A
;
11922 digest
[1] -= SHA256M_B
;
11923 digest
[2] -= SHA256M_C
;
11924 digest
[3] -= SHA256M_D
;
11925 digest
[4] -= SHA256M_E
;
11926 digest
[5] -= SHA256M_F
;
11927 digest
[6] -= SHA256M_G
;
11928 digest
[7] -= SHA256M_H
;
11930 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11932 uint salt_len
= input_len
- 64 - 1;
11934 char *salt_buf
= input_buf
+ 64 + 1;
11936 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11938 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11940 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11942 salt
->salt_len
= salt_len
;
11944 return (PARSER_OK
);
11947 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11949 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11951 u64
*digest
= (u64
*) hash_buf
->digest
;
11953 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11954 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11955 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11956 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11957 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11958 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11962 digest
[0] -= SHA384M_A
;
11963 digest
[1] -= SHA384M_B
;
11964 digest
[2] -= SHA384M_C
;
11965 digest
[3] -= SHA384M_D
;
11966 digest
[4] -= SHA384M_E
;
11967 digest
[5] -= SHA384M_F
;
11971 return (PARSER_OK
);
11974 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11976 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11978 u64
*digest
= (u64
*) hash_buf
->digest
;
11980 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11981 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11982 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11983 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11984 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11985 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11986 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11987 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11989 digest
[0] -= SHA512M_A
;
11990 digest
[1] -= SHA512M_B
;
11991 digest
[2] -= SHA512M_C
;
11992 digest
[3] -= SHA512M_D
;
11993 digest
[4] -= SHA512M_E
;
11994 digest
[5] -= SHA512M_F
;
11995 digest
[6] -= SHA512M_G
;
11996 digest
[7] -= SHA512M_H
;
11998 return (PARSER_OK
);
12001 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12003 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12005 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12009 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12012 u64
*digest
= (u64
*) hash_buf
->digest
;
12014 salt_t
*salt
= hash_buf
->salt
;
12016 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12017 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12018 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12019 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12020 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12021 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12022 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12023 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12025 digest
[0] -= SHA512M_A
;
12026 digest
[1] -= SHA512M_B
;
12027 digest
[2] -= SHA512M_C
;
12028 digest
[3] -= SHA512M_D
;
12029 digest
[4] -= SHA512M_E
;
12030 digest
[5] -= SHA512M_F
;
12031 digest
[6] -= SHA512M_G
;
12032 digest
[7] -= SHA512M_H
;
12034 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12036 uint salt_len
= input_len
- 128 - 1;
12038 char *salt_buf
= input_buf
+ 128 + 1;
12040 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12042 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12044 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12046 salt
->salt_len
= salt_len
;
12048 return (PARSER_OK
);
12051 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12053 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12055 u64
*digest
= (u64
*) hash_buf
->digest
;
12057 salt_t
*salt
= hash_buf
->salt
;
12059 char *salt_pos
= input_buf
+ 3;
12061 uint iterations_len
= 0;
12063 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12067 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12069 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12070 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12074 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12078 iterations_len
+= 8;
12082 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12085 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12087 char *hash_pos
= strchr (salt_pos
, '$');
12089 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12091 uint salt_len
= hash_pos
- salt_pos
;
12093 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12095 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12097 salt
->salt_len
= salt_len
;
12101 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12103 return (PARSER_OK
);
12106 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12108 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12110 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12112 u64
*digest
= (u64
*) hash_buf
->digest
;
12114 salt_t
*salt
= hash_buf
->salt
;
12116 uint keccak_mdlen
= input_len
/ 2;
12118 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12120 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12122 digest
[i
] = byte_swap_64 (digest
[i
]);
12125 salt
->keccak_mdlen
= keccak_mdlen
;
12127 return (PARSER_OK
);
12130 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12132 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12134 u32
*digest
= (u32
*) hash_buf
->digest
;
12136 salt_t
*salt
= hash_buf
->salt
;
12138 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12141 * Parse that strange long line
12148 in_off
[0] = strtok (input_buf
, ":");
12150 in_len
[0] = strlen (in_off
[0]);
12154 for (i
= 1; i
< 9; i
++)
12156 in_off
[i
] = strtok (NULL
, ":");
12158 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12160 in_len
[i
] = strlen (in_off
[i
]);
12165 ptr
= (char *) ikepsk
->msg_buf
;
12167 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12168 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12169 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12170 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12171 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12172 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12176 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12178 ptr
= (char *) ikepsk
->nr_buf
;
12180 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12181 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12185 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12188 * Store to database
12193 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12194 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12195 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12196 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12198 digest
[0] = byte_swap_32 (digest
[0]);
12199 digest
[1] = byte_swap_32 (digest
[1]);
12200 digest
[2] = byte_swap_32 (digest
[2]);
12201 digest
[3] = byte_swap_32 (digest
[3]);
12203 salt
->salt_len
= 32;
12205 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12206 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12207 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12208 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12209 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12210 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12211 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12212 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12214 return (PARSER_OK
);
12217 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12219 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12221 u32
*digest
= (u32
*) hash_buf
->digest
;
12223 salt_t
*salt
= hash_buf
->salt
;
12225 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12228 * Parse that strange long line
12235 in_off
[0] = strtok (input_buf
, ":");
12237 in_len
[0] = strlen (in_off
[0]);
12241 for (i
= 1; i
< 9; i
++)
12243 in_off
[i
] = strtok (NULL
, ":");
12245 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12247 in_len
[i
] = strlen (in_off
[i
]);
12252 ptr
= (char *) ikepsk
->msg_buf
;
12254 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12255 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12256 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12257 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12258 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12259 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12263 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12265 ptr
= (char *) ikepsk
->nr_buf
;
12267 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12268 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12272 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12275 * Store to database
12280 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12281 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12282 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12283 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12284 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12286 salt
->salt_len
= 32;
12288 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12289 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12290 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12291 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12292 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12293 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12294 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12295 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12297 return (PARSER_OK
);
12300 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12302 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12304 u32
*digest
= (u32
*) hash_buf
->digest
;
12306 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12307 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12308 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12309 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12310 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12312 digest
[0] = byte_swap_32 (digest
[0]);
12313 digest
[1] = byte_swap_32 (digest
[1]);
12314 digest
[2] = byte_swap_32 (digest
[2]);
12315 digest
[3] = byte_swap_32 (digest
[3]);
12316 digest
[4] = byte_swap_32 (digest
[4]);
12318 return (PARSER_OK
);
12321 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12323 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12325 u32
*digest
= (u32
*) hash_buf
->digest
;
12327 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12328 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12329 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12330 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12331 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12332 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12333 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12334 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12335 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12336 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12337 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12338 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12339 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12340 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12341 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12342 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12344 return (PARSER_OK
);
12347 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12349 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12351 u32
*digest
= (u32
*) hash_buf
->digest
;
12353 salt_t
*salt
= hash_buf
->salt
;
12355 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12356 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12357 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12358 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12359 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12361 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12363 uint salt_len
= input_len
- 40 - 1;
12365 char *salt_buf
= input_buf
+ 40 + 1;
12367 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12369 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12371 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12373 salt
->salt_len
= salt_len
;
12375 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12377 return (PARSER_OK
);
12380 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12382 u32
*digest
= (u32
*) hash_buf
->digest
;
12384 salt_t
*salt
= hash_buf
->salt
;
12386 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12388 if (input_len
== 0)
12390 log_error ("TrueCrypt container not specified");
12395 FILE *fp
= fopen (input_buf
, "rb");
12399 log_error ("%s: %s", input_buf
, strerror (errno
));
12406 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12410 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12412 memcpy (tc
->salt_buf
, buf
, 64);
12414 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12416 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12418 salt
->salt_len
= 4;
12420 salt
->salt_iter
= 1000 - 1;
12422 digest
[0] = tc
->data_buf
[0];
12424 return (PARSER_OK
);
12427 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12429 u32
*digest
= (u32
*) hash_buf
->digest
;
12431 salt_t
*salt
= hash_buf
->salt
;
12433 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12435 if (input_len
== 0)
12437 log_error ("TrueCrypt container not specified");
12442 FILE *fp
= fopen (input_buf
, "rb");
12446 log_error ("%s: %s", input_buf
, strerror (errno
));
12453 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12457 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12459 memcpy (tc
->salt_buf
, buf
, 64);
12461 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12463 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12465 salt
->salt_len
= 4;
12467 salt
->salt_iter
= 2000 - 1;
12469 digest
[0] = tc
->data_buf
[0];
12471 return (PARSER_OK
);
12474 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12476 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12478 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12480 u32
*digest
= (u32
*) hash_buf
->digest
;
12482 salt_t
*salt
= hash_buf
->salt
;
12484 char *salt_pos
= input_buf
+ 6;
12486 char *hash_pos
= strchr (salt_pos
, '$');
12488 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12490 uint salt_len
= hash_pos
- salt_pos
;
12492 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12494 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12496 salt
->salt_len
= salt_len
;
12498 salt
->salt_iter
= 1000;
12502 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12504 return (PARSER_OK
);
12507 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12509 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12511 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12513 u32
*digest
= (u32
*) hash_buf
->digest
;
12515 salt_t
*salt
= hash_buf
->salt
;
12517 char *iter_pos
= input_buf
+ 7;
12519 char *salt_pos
= strchr (iter_pos
, '$');
12521 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12525 char *hash_pos
= strchr (salt_pos
, '$');
12527 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12529 uint salt_len
= hash_pos
- salt_pos
;
12531 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12533 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12535 salt
->salt_len
= salt_len
;
12537 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12539 salt
->salt_sign
[0] = atoi (salt_iter
);
12541 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12545 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12547 digest
[0] = byte_swap_32 (digest
[0]);
12548 digest
[1] = byte_swap_32 (digest
[1]);
12549 digest
[2] = byte_swap_32 (digest
[2]);
12550 digest
[3] = byte_swap_32 (digest
[3]);
12551 digest
[4] = byte_swap_32 (digest
[4]);
12553 return (PARSER_OK
);
12556 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12558 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12560 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12562 u32
*digest
= (u32
*) hash_buf
->digest
;
12564 salt_t
*salt
= hash_buf
->salt
;
12566 char *iter_pos
= input_buf
+ 9;
12568 char *salt_pos
= strchr (iter_pos
, '$');
12570 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12574 char *hash_pos
= strchr (salt_pos
, '$');
12576 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12578 uint salt_len
= hash_pos
- salt_pos
;
12580 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12582 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12584 salt
->salt_len
= salt_len
;
12586 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12588 salt
->salt_sign
[0] = atoi (salt_iter
);
12590 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12594 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12596 digest
[0] = byte_swap_32 (digest
[0]);
12597 digest
[1] = byte_swap_32 (digest
[1]);
12598 digest
[2] = byte_swap_32 (digest
[2]);
12599 digest
[3] = byte_swap_32 (digest
[3]);
12600 digest
[4] = byte_swap_32 (digest
[4]);
12601 digest
[5] = byte_swap_32 (digest
[5]);
12602 digest
[6] = byte_swap_32 (digest
[6]);
12603 digest
[7] = byte_swap_32 (digest
[7]);
12605 return (PARSER_OK
);
12608 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12610 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12612 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12614 u64
*digest
= (u64
*) hash_buf
->digest
;
12616 salt_t
*salt
= hash_buf
->salt
;
12618 char *iter_pos
= input_buf
+ 9;
12620 char *salt_pos
= strchr (iter_pos
, '$');
12622 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12626 char *hash_pos
= strchr (salt_pos
, '$');
12628 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12630 uint salt_len
= hash_pos
- salt_pos
;
12632 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12634 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12636 salt
->salt_len
= salt_len
;
12638 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12640 salt
->salt_sign
[0] = atoi (salt_iter
);
12642 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12646 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12648 digest
[0] = byte_swap_64 (digest
[0]);
12649 digest
[1] = byte_swap_64 (digest
[1]);
12650 digest
[2] = byte_swap_64 (digest
[2]);
12651 digest
[3] = byte_swap_64 (digest
[3]);
12652 digest
[4] = byte_swap_64 (digest
[4]);
12653 digest
[5] = byte_swap_64 (digest
[5]);
12654 digest
[6] = byte_swap_64 (digest
[6]);
12655 digest
[7] = byte_swap_64 (digest
[7]);
12657 return (PARSER_OK
);
12660 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12662 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12664 u32
*digest
= (u32
*) hash_buf
->digest
;
12666 salt_t
*salt
= hash_buf
->salt
;
12668 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12674 char *iterations_pos
= input_buf
;
12676 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12678 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12680 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12682 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12686 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12688 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12690 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12692 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12694 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12696 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12701 * pbkdf2 iterations
12704 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12707 * handle salt encoding
12710 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12712 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12714 const char p0
= saltbuf_pos
[i
+ 0];
12715 const char p1
= saltbuf_pos
[i
+ 1];
12717 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12718 | hex_convert (p0
) << 4;
12721 salt
->salt_len
= saltbuf_len
/ 2;
12724 * handle cipher encoding
12727 uint
*tmp
= (uint
*) mymalloc (32);
12729 char *cipherbuf_ptr
= (char *) tmp
;
12731 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12733 const char p0
= cipherbuf_pos
[i
+ 0];
12734 const char p1
= cipherbuf_pos
[i
+ 1];
12736 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12737 | hex_convert (p0
) << 4;
12740 // iv is stored at salt_buf 4 (length 16)
12741 // data is stored at salt_buf 8 (length 16)
12743 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12744 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12745 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12746 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12748 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12749 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12750 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12751 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12755 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12757 const char p0
= cipherbuf_pos
[j
+ 0];
12758 const char p1
= cipherbuf_pos
[j
+ 1];
12760 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12761 | hex_convert (p0
) << 4;
12768 digest
[0] = 0x10101010;
12769 digest
[1] = 0x10101010;
12770 digest
[2] = 0x10101010;
12771 digest
[3] = 0x10101010;
12773 return (PARSER_OK
);
12776 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12778 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12780 u32
*digest
= (u32
*) hash_buf
->digest
;
12782 salt_t
*salt
= hash_buf
->salt
;
12784 char *hashbuf_pos
= input_buf
;
12786 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12788 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12790 uint hash_len
= iterations_pos
- hashbuf_pos
;
12792 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12796 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12798 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12800 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12804 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12806 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12808 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12810 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12812 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12814 salt
->salt_len
= salt_len
;
12816 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12818 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12819 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12820 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12821 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12823 return (PARSER_OK
);
12826 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12828 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12830 u32
*digest
= (u32
*) hash_buf
->digest
;
12832 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12833 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12834 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12835 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12836 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12837 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12838 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12839 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12841 digest
[0] = byte_swap_32 (digest
[0]);
12842 digest
[1] = byte_swap_32 (digest
[1]);
12843 digest
[2] = byte_swap_32 (digest
[2]);
12844 digest
[3] = byte_swap_32 (digest
[3]);
12845 digest
[4] = byte_swap_32 (digest
[4]);
12846 digest
[5] = byte_swap_32 (digest
[5]);
12847 digest
[6] = byte_swap_32 (digest
[6]);
12848 digest
[7] = byte_swap_32 (digest
[7]);
12850 return (PARSER_OK
);
12853 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12855 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12857 u32
*digest
= (u32
*) hash_buf
->digest
;
12859 salt_t
*salt
= hash_buf
->salt
;
12861 char *salt_pos
= input_buf
+ 3;
12863 uint iterations_len
= 0;
12865 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12869 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12871 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12872 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12876 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12880 iterations_len
+= 8;
12884 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12887 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12889 char *hash_pos
= strchr (salt_pos
, '$');
12891 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12893 uint salt_len
= hash_pos
- salt_pos
;
12895 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12897 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12899 salt
->salt_len
= salt_len
;
12903 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12905 return (PARSER_OK
);
12908 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12910 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12912 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12914 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12916 u64
*digest
= (u64
*) hash_buf
->digest
;
12918 salt_t
*salt
= hash_buf
->salt
;
12920 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12922 char *iter_pos
= input_buf
+ 4;
12924 char *salt_pos
= strchr (iter_pos
, '$');
12926 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12930 char *hash_pos
= strchr (salt_pos
, '$');
12932 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12934 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12938 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12939 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12940 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12941 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12942 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12943 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12944 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12945 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12947 uint salt_len
= hash_pos
- salt_pos
- 1;
12949 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12951 salt
->salt_len
= salt_len
/ 2;
12953 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12954 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12955 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12956 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12957 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12958 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12959 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12960 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12962 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12963 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12964 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12965 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12966 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12967 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12968 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12969 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12970 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12971 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12973 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12975 salt
->salt_iter
= atoi (iter_pos
) - 1;
12977 return (PARSER_OK
);
12980 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12982 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12984 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12986 u32
*digest
= (u32
*) hash_buf
->digest
;
12988 salt_t
*salt
= hash_buf
->salt
;
12990 char *salt_pos
= input_buf
+ 14;
12992 char *hash_pos
= strchr (salt_pos
, '*');
12994 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12998 uint salt_len
= hash_pos
- salt_pos
- 1;
13000 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13002 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13004 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13006 salt
->salt_len
= salt_len
;
13010 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13012 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13014 memcpy (digest
, tmp_buf
, 32);
13016 digest
[0] = byte_swap_32 (digest
[0]);
13017 digest
[1] = byte_swap_32 (digest
[1]);
13018 digest
[2] = byte_swap_32 (digest
[2]);
13019 digest
[3] = byte_swap_32 (digest
[3]);
13020 digest
[4] = byte_swap_32 (digest
[4]);
13021 digest
[5] = byte_swap_32 (digest
[5]);
13022 digest
[6] = byte_swap_32 (digest
[6]);
13023 digest
[7] = byte_swap_32 (digest
[7]);
13025 digest
[0] -= SHA256M_A
;
13026 digest
[1] -= SHA256M_B
;
13027 digest
[2] -= SHA256M_C
;
13028 digest
[3] -= SHA256M_D
;
13029 digest
[4] -= SHA256M_E
;
13030 digest
[5] -= SHA256M_F
;
13031 digest
[6] -= SHA256M_G
;
13032 digest
[7] -= SHA256M_H
;
13034 return (PARSER_OK
);
13037 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13039 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13041 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13043 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13045 u64
*digest
= (u64
*) hash_buf
->digest
;
13047 salt_t
*salt
= hash_buf
->salt
;
13049 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13051 char *iter_pos
= input_buf
+ 19;
13053 char *salt_pos
= strchr (iter_pos
, '.');
13055 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13059 char *hash_pos
= strchr (salt_pos
, '.');
13061 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13063 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13067 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13068 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13069 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13070 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13071 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13072 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13073 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13074 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13076 uint salt_len
= hash_pos
- salt_pos
- 1;
13080 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13084 for (i
= 0; i
< salt_len
; i
++)
13086 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13089 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13090 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13092 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13094 salt
->salt_len
= salt_len
;
13096 salt
->salt_iter
= atoi (iter_pos
) - 1;
13098 return (PARSER_OK
);
13101 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13103 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13105 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13107 u64
*digest
= (u64
*) hash_buf
->digest
;
13109 salt_t
*salt
= hash_buf
->salt
;
13113 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13115 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13117 memcpy (digest
, tmp_buf
, 64);
13119 digest
[0] = byte_swap_64 (digest
[0]);
13120 digest
[1] = byte_swap_64 (digest
[1]);
13121 digest
[2] = byte_swap_64 (digest
[2]);
13122 digest
[3] = byte_swap_64 (digest
[3]);
13123 digest
[4] = byte_swap_64 (digest
[4]);
13124 digest
[5] = byte_swap_64 (digest
[5]);
13125 digest
[6] = byte_swap_64 (digest
[6]);
13126 digest
[7] = byte_swap_64 (digest
[7]);
13128 digest
[0] -= SHA512M_A
;
13129 digest
[1] -= SHA512M_B
;
13130 digest
[2] -= SHA512M_C
;
13131 digest
[3] -= SHA512M_D
;
13132 digest
[4] -= SHA512M_E
;
13133 digest
[5] -= SHA512M_F
;
13134 digest
[6] -= SHA512M_G
;
13135 digest
[7] -= SHA512M_H
;
13137 salt
->salt_len
= tmp_len
- 64;
13139 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13141 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13143 char *ptr
= (char *) salt
->salt_buf
;
13145 ptr
[salt
->salt_len
] = 0x80;
13148 return (PARSER_OK
);
13151 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13153 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13155 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13159 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13162 u32
*digest
= (u32
*) hash_buf
->digest
;
13164 salt_t
*salt
= hash_buf
->salt
;
13166 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13167 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13168 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13169 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13171 digest
[0] = byte_swap_32 (digest
[0]);
13172 digest
[1] = byte_swap_32 (digest
[1]);
13173 digest
[2] = byte_swap_32 (digest
[2]);
13174 digest
[3] = byte_swap_32 (digest
[3]);
13176 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13178 uint salt_len
= input_len
- 32 - 1;
13180 char *salt_buf
= input_buf
+ 32 + 1;
13182 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13184 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13186 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13188 salt
->salt_len
= salt_len
;
13190 return (PARSER_OK
);
13193 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13195 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13197 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13201 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13204 u32
*digest
= (u32
*) hash_buf
->digest
;
13206 salt_t
*salt
= hash_buf
->salt
;
13208 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13209 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13210 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13211 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13212 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13214 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13216 uint salt_len
= input_len
- 40 - 1;
13218 char *salt_buf
= input_buf
+ 40 + 1;
13220 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13222 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13224 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13226 salt
->salt_len
= salt_len
;
13228 return (PARSER_OK
);
13231 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13233 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13235 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13239 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13242 u32
*digest
= (u32
*) hash_buf
->digest
;
13244 salt_t
*salt
= hash_buf
->salt
;
13246 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13247 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13248 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13249 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13250 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13251 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13252 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13253 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13255 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13257 uint salt_len
= input_len
- 64 - 1;
13259 char *salt_buf
= input_buf
+ 64 + 1;
13261 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13263 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13265 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13267 salt
->salt_len
= salt_len
;
13269 return (PARSER_OK
);
13272 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13274 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13276 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13280 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13283 u64
*digest
= (u64
*) hash_buf
->digest
;
13285 salt_t
*salt
= hash_buf
->salt
;
13287 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13288 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13289 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13290 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13291 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13292 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13293 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13294 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13296 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13298 uint salt_len
= input_len
- 128 - 1;
13300 char *salt_buf
= input_buf
+ 128 + 1;
13302 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13304 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13306 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13308 salt
->salt_len
= salt_len
;
13310 return (PARSER_OK
);
13313 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13315 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13317 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13319 u32
*digest
= (u32
*) hash_buf
->digest
;
13321 salt_t
*salt
= hash_buf
->salt
;
13323 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13329 char *user_pos
= input_buf
+ 10 + 1;
13331 char *realm_pos
= strchr (user_pos
, '$');
13333 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13335 uint user_len
= realm_pos
- user_pos
;
13337 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13341 char *salt_pos
= strchr (realm_pos
, '$');
13343 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13345 uint realm_len
= salt_pos
- realm_pos
;
13347 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13351 char *data_pos
= strchr (salt_pos
, '$');
13353 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13355 uint salt_len
= data_pos
- salt_pos
;
13357 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13361 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13363 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13369 memcpy (krb5pa
->user
, user_pos
, user_len
);
13370 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13371 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13373 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13375 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13377 const char p0
= data_pos
[i
+ 0];
13378 const char p1
= data_pos
[i
+ 1];
13380 *timestamp_ptr
++ = hex_convert (p1
) << 0
13381 | hex_convert (p0
) << 4;
13384 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13386 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13388 const char p0
= data_pos
[i
+ 0];
13389 const char p1
= data_pos
[i
+ 1];
13391 *checksum_ptr
++ = hex_convert (p1
) << 0
13392 | hex_convert (p0
) << 4;
13396 * copy some data to generic buffers to make sorting happy
13399 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13400 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13401 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13402 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13403 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13404 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13405 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13406 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13407 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13409 salt
->salt_len
= 36;
13411 digest
[0] = krb5pa
->checksum
[0];
13412 digest
[1] = krb5pa
->checksum
[1];
13413 digest
[2] = krb5pa
->checksum
[2];
13414 digest
[3] = krb5pa
->checksum
[3];
13416 return (PARSER_OK
);
13419 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13421 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13423 u32
*digest
= (u32
*) hash_buf
->digest
;
13425 salt_t
*salt
= hash_buf
->salt
;
13431 char *salt_pos
= input_buf
;
13433 char *hash_pos
= strchr (salt_pos
, '$');
13435 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13437 uint salt_len
= hash_pos
- salt_pos
;
13439 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13443 uint hash_len
= input_len
- 1 - salt_len
;
13445 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13453 for (uint i
= 0; i
< salt_len
; i
++)
13455 if (salt_pos
[i
] == ' ') continue;
13460 // SAP user names cannot be longer than 12 characters
13461 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13463 // SAP user name cannot start with ! or ?
13464 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13470 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13472 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13474 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13476 salt
->salt_len
= salt_len
;
13478 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13479 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13483 digest
[0] = byte_swap_32 (digest
[0]);
13484 digest
[1] = byte_swap_32 (digest
[1]);
13486 return (PARSER_OK
);
13489 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13491 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13493 u32
*digest
= (u32
*) hash_buf
->digest
;
13495 salt_t
*salt
= hash_buf
->salt
;
13501 char *salt_pos
= input_buf
;
13503 char *hash_pos
= strchr (salt_pos
, '$');
13505 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13507 uint salt_len
= hash_pos
- salt_pos
;
13509 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13513 uint hash_len
= input_len
- 1 - salt_len
;
13515 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13523 for (uint i
= 0; i
< salt_len
; i
++)
13525 if (salt_pos
[i
] == ' ') continue;
13530 // SAP user names cannot be longer than 12 characters
13531 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13532 // so far nobody complained so we stay with this because it helps in optimization
13533 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13535 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13537 // SAP user name cannot start with ! or ?
13538 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13544 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13546 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13548 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13550 salt
->salt_len
= salt_len
;
13552 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13553 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13554 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13555 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13556 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13558 return (PARSER_OK
);
13561 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13563 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13565 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13567 u64
*digest
= (u64
*) hash_buf
->digest
;
13569 salt_t
*salt
= hash_buf
->salt
;
13571 char *iter_pos
= input_buf
+ 3;
13573 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13575 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13577 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13579 salt
->salt_iter
= salt_iter
;
13581 char *salt_pos
= iter_pos
+ 1;
13585 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13587 salt
->salt_len
= salt_len
;
13589 char *hash_pos
= salt_pos
+ salt_len
;
13591 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13595 char *tmp
= (char *) salt
->salt_buf_pc
;
13597 tmp
[0] = hash_pos
[42];
13601 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13602 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13603 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13604 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13610 return (PARSER_OK
);
13613 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13615 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13617 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13619 u32
*digest
= (u32
*) hash_buf
->digest
;
13621 salt_t
*salt
= hash_buf
->salt
;
13623 char *salt_buf
= input_buf
+ 6;
13625 uint salt_len
= 16;
13627 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13629 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13631 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13633 salt
->salt_len
= salt_len
;
13635 char *hash_pos
= input_buf
+ 6 + 16;
13637 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13638 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13639 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13640 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13641 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13642 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13643 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13644 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13646 return (PARSER_OK
);
13649 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13651 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13653 u32
*digest
= (u32
*) hash_buf
->digest
;
13655 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13656 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13660 return (PARSER_OK
);
13663 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13665 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13667 u32
*digest
= (u32
*) hash_buf
->digest
;
13669 salt_t
*salt
= hash_buf
->salt
;
13671 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13673 char *saltbuf_pos
= input_buf
;
13675 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13677 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13679 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13681 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13682 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13684 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13688 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13690 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13692 char *salt_ptr
= (char *) saltbuf_pos
;
13693 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13698 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13700 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13703 rakp_ptr
[j
] = 0x80;
13705 rakp
->salt_len
= j
;
13707 for (i
= 0; i
< 64; i
++)
13709 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13712 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13713 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13714 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13715 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13716 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13717 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13718 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13719 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13721 salt
->salt_len
= 32; // muss min. 32 haben
13723 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13724 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13725 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13726 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13727 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13729 return (PARSER_OK
);
13732 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13734 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13736 u32
*digest
= (u32
*) hash_buf
->digest
;
13738 salt_t
*salt
= hash_buf
->salt
;
13740 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13742 char *salt_pos
= input_buf
+ 1;
13744 memcpy (salt
->salt_buf
, salt_pos
, 8);
13746 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13747 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13749 salt
->salt_len
= 8;
13751 char *hash_pos
= salt_pos
+ 8;
13753 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13754 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13755 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13756 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13757 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13759 digest
[0] -= SHA1M_A
;
13760 digest
[1] -= SHA1M_B
;
13761 digest
[2] -= SHA1M_C
;
13762 digest
[3] -= SHA1M_D
;
13763 digest
[4] -= SHA1M_E
;
13765 return (PARSER_OK
);
13768 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13770 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13772 u32
*digest
= (u32
*) hash_buf
->digest
;
13774 salt_t
*salt
= hash_buf
->salt
;
13776 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13777 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13778 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13779 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13781 digest
[0] = byte_swap_32 (digest
[0]);
13782 digest
[1] = byte_swap_32 (digest
[1]);
13783 digest
[2] = byte_swap_32 (digest
[2]);
13784 digest
[3] = byte_swap_32 (digest
[3]);
13786 digest
[0] -= MD5M_A
;
13787 digest
[1] -= MD5M_B
;
13788 digest
[2] -= MD5M_C
;
13789 digest
[3] -= MD5M_D
;
13791 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13793 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13795 u32
*salt_buf
= salt
->salt_buf
;
13797 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13798 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13799 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13800 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13802 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13803 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13804 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13805 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13807 salt
->salt_len
= 16 + 1;
13809 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13811 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13813 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13815 return (PARSER_OK
);
13818 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13820 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13822 u32
*digest
= (u32
*) hash_buf
->digest
;
13824 salt_t
*salt
= hash_buf
->salt
;
13826 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13832 char *hashbuf_pos
= input_buf
;
13834 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13836 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13838 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13840 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13844 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13846 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13848 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13850 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13854 char *databuf_pos
= strchr (iteration_pos
, ':');
13856 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13858 const uint iteration_len
= databuf_pos
- iteration_pos
;
13860 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13861 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13863 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13865 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13866 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13872 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13873 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13874 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13875 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13876 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13877 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13878 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13879 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13883 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13885 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13887 const char p0
= saltbuf_pos
[i
+ 0];
13888 const char p1
= saltbuf_pos
[i
+ 1];
13890 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13891 | hex_convert (p0
) << 4;
13894 salt
->salt_buf
[4] = 0x01000000;
13895 salt
->salt_buf
[5] = 0x80;
13897 salt
->salt_len
= saltbuf_len
/ 2;
13901 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13905 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13907 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13909 const char p0
= databuf_pos
[i
+ 0];
13910 const char p1
= databuf_pos
[i
+ 1];
13912 *databuf_ptr
++ = hex_convert (p1
) << 0
13913 | hex_convert (p0
) << 4;
13916 *databuf_ptr
++ = 0x80;
13918 for (uint i
= 0; i
< 512; i
++)
13920 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13923 cloudkey
->data_len
= databuf_len
/ 2;
13925 return (PARSER_OK
);
13928 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13930 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13932 u32
*digest
= (u32
*) hash_buf
->digest
;
13934 salt_t
*salt
= hash_buf
->salt
;
13940 char *hashbuf_pos
= input_buf
;
13942 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13944 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13946 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13948 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13952 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13954 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13956 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13958 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13960 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13964 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13966 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13968 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13970 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13972 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13976 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13978 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13979 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13981 // ok, the plan for this algorithm is the following:
13982 // we have 2 salts here, the domain-name and a random salt
13983 // while both are used in the initial transformation,
13984 // only the random salt is used in the following iterations
13985 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13986 // and one that includes only the real salt (stored into salt_buf[]).
13987 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13991 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13993 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
13995 memcpy (digest
, tmp_buf
, 20);
13997 digest
[0] = byte_swap_32 (digest
[0]);
13998 digest
[1] = byte_swap_32 (digest
[1]);
13999 digest
[2] = byte_swap_32 (digest
[2]);
14000 digest
[3] = byte_swap_32 (digest
[3]);
14001 digest
[4] = byte_swap_32 (digest
[4]);
14005 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14007 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14009 char *len_ptr
= NULL
;
14011 for (uint i
= 0; i
< domainbuf_len
; i
++)
14013 if (salt_buf_pc_ptr
[i
] == '.')
14015 len_ptr
= &salt_buf_pc_ptr
[i
];
14025 salt
->salt_buf_pc
[7] = domainbuf_len
;
14029 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14031 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14033 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14035 salt
->salt_len
= salt_len
;
14039 salt
->salt_iter
= atoi (iteration_pos
);
14041 return (PARSER_OK
);
14044 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14046 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14048 u32
*digest
= (u32
*) hash_buf
->digest
;
14050 salt_t
*salt
= hash_buf
->salt
;
14052 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14053 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14054 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14055 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14056 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14058 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14060 uint salt_len
= input_len
- 40 - 1;
14062 char *salt_buf
= input_buf
+ 40 + 1;
14064 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14066 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14068 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14070 salt
->salt_len
= salt_len
;
14072 return (PARSER_OK
);
14075 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14077 const u8 ascii_to_ebcdic
[] =
14079 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14080 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14081 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14082 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14083 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14084 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14085 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14086 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14087 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14088 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14089 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14090 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14091 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14092 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14093 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14094 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14097 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14099 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14101 u32
*digest
= (u32
*) hash_buf
->digest
;
14103 salt_t
*salt
= hash_buf
->salt
;
14105 char *salt_pos
= input_buf
+ 6 + 1;
14107 char *digest_pos
= strchr (salt_pos
, '*');
14109 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14111 uint salt_len
= digest_pos
- salt_pos
;
14113 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14115 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14117 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14121 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14122 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14124 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14126 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14128 salt
->salt_len
= salt_len
;
14130 for (uint i
= 0; i
< salt_len
; i
++)
14132 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14134 for (uint i
= salt_len
; i
< 8; i
++)
14136 salt_buf_pc_ptr
[i
] = 0x40;
14141 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14143 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14144 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14146 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14147 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14149 digest
[0] = byte_swap_32 (digest
[0]);
14150 digest
[1] = byte_swap_32 (digest
[1]);
14152 IP (digest
[0], digest
[1], tt
);
14154 digest
[0] = rotr32 (digest
[0], 29);
14155 digest
[1] = rotr32 (digest
[1], 29);
14159 return (PARSER_OK
);
14162 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14164 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14166 u32
*digest
= (u32
*) hash_buf
->digest
;
14168 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14169 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14170 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14171 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14173 digest
[0] = byte_swap_32 (digest
[0]);
14174 digest
[1] = byte_swap_32 (digest
[1]);
14175 digest
[2] = byte_swap_32 (digest
[2]);
14176 digest
[3] = byte_swap_32 (digest
[3]);
14178 return (PARSER_OK
);
14181 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14183 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14185 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14187 u32
*digest
= (u32
*) hash_buf
->digest
;
14189 salt_t
*salt
= hash_buf
->salt
;
14193 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14195 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14197 tmp_buf
[3] += -4; // dont ask!
14199 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14201 salt
->salt_len
= 5;
14203 memcpy (digest
, tmp_buf
+ 5, 9);
14205 // yes, only 9 byte are needed to crack, but 10 to display
14207 salt
->salt_buf_pc
[7] = input_buf
[20];
14209 return (PARSER_OK
);
14212 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14214 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14216 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14218 u32
*digest
= (u32
*) hash_buf
->digest
;
14220 salt_t
*salt
= hash_buf
->salt
;
14224 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14226 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14228 tmp_buf
[3] += -4; // dont ask!
14232 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14234 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)
14238 char tmp_iter_buf
[11];
14240 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14242 tmp_iter_buf
[10] = 0;
14244 salt
->salt_iter
= atoi (tmp_iter_buf
);
14246 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14248 return (PARSER_SALT_ITERATION
);
14251 salt
->salt_iter
--; // first round in init
14253 // 2 additional bytes for display only
14255 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14256 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14260 memcpy (digest
, tmp_buf
+ 28, 8);
14262 digest
[0] = byte_swap_32 (digest
[0]);
14263 digest
[1] = byte_swap_32 (digest
[1]);
14267 return (PARSER_OK
);
14270 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14272 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14274 u32
*digest
= (u32
*) hash_buf
->digest
;
14276 salt_t
*salt
= hash_buf
->salt
;
14278 char *salt_buf_pos
= input_buf
;
14280 char *hash_buf_pos
= salt_buf_pos
+ 6;
14282 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14283 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14284 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14285 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14286 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14287 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14288 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14289 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14291 digest
[0] -= SHA256M_A
;
14292 digest
[1] -= SHA256M_B
;
14293 digest
[2] -= SHA256M_C
;
14294 digest
[3] -= SHA256M_D
;
14295 digest
[4] -= SHA256M_E
;
14296 digest
[5] -= SHA256M_F
;
14297 digest
[6] -= SHA256M_G
;
14298 digest
[7] -= SHA256M_H
;
14300 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14302 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14304 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14306 salt
->salt_len
= salt_len
;
14308 return (PARSER_OK
);
14311 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14313 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14315 u32
*digest
= (u32
*) hash_buf
->digest
;
14317 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14319 salt_t
*salt
= hash_buf
->salt
;
14321 char *salt_buf
= input_buf
+ 6;
14323 char *digest_buf
= strchr (salt_buf
, '$');
14325 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14327 uint salt_len
= digest_buf
- salt_buf
;
14329 digest_buf
++; // skip the '$' symbol
14331 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14333 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14335 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14337 salt
->salt_len
= salt_len
;
14339 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14340 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14341 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14342 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14344 digest
[0] = byte_swap_32 (digest
[0]);
14345 digest
[1] = byte_swap_32 (digest
[1]);
14346 digest
[2] = byte_swap_32 (digest
[2]);
14347 digest
[3] = byte_swap_32 (digest
[3]);
14349 digest
[0] -= MD5M_A
;
14350 digest
[1] -= MD5M_B
;
14351 digest
[2] -= MD5M_C
;
14352 digest
[3] -= MD5M_D
;
14354 return (PARSER_OK
);
14357 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14359 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14361 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14363 u32
*digest
= (u32
*) hash_buf
->digest
;
14365 salt_t
*salt
= hash_buf
->salt
;
14367 char *salt_buf
= input_buf
+ 3;
14369 char *digest_buf
= strchr (salt_buf
, '$');
14371 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14373 uint salt_len
= digest_buf
- salt_buf
;
14375 digest_buf
++; // skip the '$' symbol
14377 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14379 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14381 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14383 salt_buf_ptr
[salt_len
] = 0x2d;
14385 salt
->salt_len
= salt_len
+ 1;
14387 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14388 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14389 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14390 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14392 digest
[0] = byte_swap_32 (digest
[0]);
14393 digest
[1] = byte_swap_32 (digest
[1]);
14394 digest
[2] = byte_swap_32 (digest
[2]);
14395 digest
[3] = byte_swap_32 (digest
[3]);
14397 digest
[0] -= MD5M_A
;
14398 digest
[1] -= MD5M_B
;
14399 digest
[2] -= MD5M_C
;
14400 digest
[3] -= MD5M_D
;
14402 return (PARSER_OK
);
14405 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14407 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14409 u32
*digest
= (u32
*) hash_buf
->digest
;
14413 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14415 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14417 memcpy (digest
, tmp_buf
, 20);
14419 digest
[0] = byte_swap_32 (digest
[0]);
14420 digest
[1] = byte_swap_32 (digest
[1]);
14421 digest
[2] = byte_swap_32 (digest
[2]);
14422 digest
[3] = byte_swap_32 (digest
[3]);
14423 digest
[4] = byte_swap_32 (digest
[4]);
14425 digest
[0] -= SHA1M_A
;
14426 digest
[1] -= SHA1M_B
;
14427 digest
[2] -= SHA1M_C
;
14428 digest
[3] -= SHA1M_D
;
14429 digest
[4] -= SHA1M_E
;
14431 return (PARSER_OK
);
14434 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14436 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14438 u32
*digest
= (u32
*) hash_buf
->digest
;
14440 salt_t
*salt
= hash_buf
->salt
;
14442 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14443 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14444 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14445 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14447 digest
[0] = byte_swap_32 (digest
[0]);
14448 digest
[1] = byte_swap_32 (digest
[1]);
14449 digest
[2] = byte_swap_32 (digest
[2]);
14450 digest
[3] = byte_swap_32 (digest
[3]);
14452 digest
[0] -= MD5M_A
;
14453 digest
[1] -= MD5M_B
;
14454 digest
[2] -= MD5M_C
;
14455 digest
[3] -= MD5M_D
;
14457 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14459 uint salt_len
= input_len
- 32 - 1;
14461 char *salt_buf
= input_buf
+ 32 + 1;
14463 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14465 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14467 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14470 * add static "salt" part
14473 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14477 salt
->salt_len
= salt_len
;
14479 return (PARSER_OK
);
14482 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14484 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14486 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14488 u32
*digest
= (u32
*) hash_buf
->digest
;
14490 salt_t
*salt
= hash_buf
->salt
;
14492 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14498 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14500 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14502 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14504 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14506 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14510 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14512 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14514 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14516 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14520 char *keybuf_pos
= strchr (keylen_pos
, '$');
14522 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14524 uint keylen_len
= keybuf_pos
- keylen_pos
;
14526 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14530 char *databuf_pos
= strchr (keybuf_pos
, '$');
14532 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14534 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14536 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14540 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14542 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14548 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14549 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14550 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14551 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14553 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14554 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14555 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14556 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14558 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14559 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14560 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14561 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14563 salt
->salt_len
= 16;
14564 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14566 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14568 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14571 return (PARSER_OK
);
14574 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14576 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14578 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14580 u32
*digest
= (u32
*) hash_buf
->digest
;
14582 salt_t
*salt
= hash_buf
->salt
;
14588 // first is the N salt parameter
14590 char *N_pos
= input_buf
+ 6;
14592 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14596 salt
->scrypt_N
= atoi (N_pos
);
14600 char *r_pos
= strchr (N_pos
, ':');
14602 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14606 salt
->scrypt_r
= atoi (r_pos
);
14610 char *p_pos
= strchr (r_pos
, ':');
14612 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14616 salt
->scrypt_p
= atoi (p_pos
);
14620 char *saltbuf_pos
= strchr (p_pos
, ':');
14622 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14626 char *hash_pos
= strchr (saltbuf_pos
, ':');
14628 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14636 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14638 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14640 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14642 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14644 salt
->salt_len
= tmp_len
;
14645 salt
->salt_iter
= 1;
14647 // digest - base64 decode
14649 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14651 tmp_len
= input_len
- (hash_pos
- input_buf
);
14653 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14655 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14657 memcpy (digest
, tmp_buf
, 32);
14659 return (PARSER_OK
);
14662 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14664 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14666 u32
*digest
= (u32
*) hash_buf
->digest
;
14668 salt_t
*salt
= hash_buf
->salt
;
14674 char decrypted
[76]; // iv + hash
14676 juniper_decrypt_hash (input_buf
, decrypted
);
14678 char *md5crypt_hash
= decrypted
+ 12;
14680 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14682 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14684 char *salt_pos
= md5crypt_hash
+ 3;
14686 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14688 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14690 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14694 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14696 return (PARSER_OK
);
14699 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14701 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14703 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14705 u32
*digest
= (u32
*) hash_buf
->digest
;
14707 salt_t
*salt
= hash_buf
->salt
;
14709 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14715 // first is *raw* salt
14717 char *salt_pos
= input_buf
+ 3;
14719 char *hash_pos
= strchr (salt_pos
, '$');
14721 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14723 uint salt_len
= hash_pos
- salt_pos
;
14725 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14729 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14731 memcpy (salt_buf_ptr
, salt_pos
, 14);
14733 salt_buf_ptr
[17] = 0x01;
14734 salt_buf_ptr
[18] = 0x80;
14736 // add some stuff to normal salt to make sorted happy
14738 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14739 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14740 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14741 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14743 salt
->salt_len
= salt_len
;
14744 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14746 // base64 decode hash
14750 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14752 uint hash_len
= input_len
- 3 - salt_len
- 1;
14754 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14756 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14758 memcpy (digest
, tmp_buf
, 32);
14760 digest
[0] = byte_swap_32 (digest
[0]);
14761 digest
[1] = byte_swap_32 (digest
[1]);
14762 digest
[2] = byte_swap_32 (digest
[2]);
14763 digest
[3] = byte_swap_32 (digest
[3]);
14764 digest
[4] = byte_swap_32 (digest
[4]);
14765 digest
[5] = byte_swap_32 (digest
[5]);
14766 digest
[6] = byte_swap_32 (digest
[6]);
14767 digest
[7] = byte_swap_32 (digest
[7]);
14769 return (PARSER_OK
);
14772 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14774 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14776 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14778 u32
*digest
= (u32
*) hash_buf
->digest
;
14780 salt_t
*salt
= hash_buf
->salt
;
14786 // first is *raw* salt
14788 char *salt_pos
= input_buf
+ 3;
14790 char *hash_pos
= strchr (salt_pos
, '$');
14792 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14794 uint salt_len
= hash_pos
- salt_pos
;
14796 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14798 salt
->salt_len
= salt_len
;
14801 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14803 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14804 salt_buf_ptr
[salt_len
] = 0;
14806 // base64 decode hash
14810 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14812 uint hash_len
= input_len
- 3 - salt_len
- 1;
14814 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14816 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14818 memcpy (digest
, tmp_buf
, 32);
14821 salt
->scrypt_N
= 16384;
14822 salt
->scrypt_r
= 1;
14823 salt
->scrypt_p
= 1;
14824 salt
->salt_iter
= 1;
14826 return (PARSER_OK
);
14829 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14831 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14833 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14835 u32
*digest
= (u32
*) hash_buf
->digest
;
14837 salt_t
*salt
= hash_buf
->salt
;
14839 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14845 char *version_pos
= input_buf
+ 8 + 1;
14847 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14849 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14851 u32 version_len
= verifierHashSize_pos
- version_pos
;
14853 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14855 verifierHashSize_pos
++;
14857 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14859 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14861 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14863 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14867 char *saltSize_pos
= strchr (keySize_pos
, '*');
14869 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14871 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14873 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14877 char *osalt_pos
= strchr (saltSize_pos
, '*');
14879 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14881 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14883 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14887 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14889 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14891 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14893 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14895 encryptedVerifier_pos
++;
14897 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14899 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14901 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14903 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14905 encryptedVerifierHash_pos
++;
14907 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;
14909 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14911 const uint version
= atoi (version_pos
);
14913 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14915 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14917 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14919 const uint keySize
= atoi (keySize_pos
);
14921 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14923 office2007
->keySize
= keySize
;
14925 const uint saltSize
= atoi (saltSize_pos
);
14927 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14933 salt
->salt_len
= 16;
14934 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14936 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14937 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14938 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14939 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14945 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14946 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14947 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14948 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14950 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14951 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14952 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14953 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14954 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14960 digest
[0] = office2007
->encryptedVerifierHash
[0];
14961 digest
[1] = office2007
->encryptedVerifierHash
[1];
14962 digest
[2] = office2007
->encryptedVerifierHash
[2];
14963 digest
[3] = office2007
->encryptedVerifierHash
[3];
14965 return (PARSER_OK
);
14968 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14970 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14972 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14974 u32
*digest
= (u32
*) hash_buf
->digest
;
14976 salt_t
*salt
= hash_buf
->salt
;
14978 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14984 char *version_pos
= input_buf
+ 8 + 1;
14986 char *spinCount_pos
= strchr (version_pos
, '*');
14988 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14990 u32 version_len
= spinCount_pos
- version_pos
;
14992 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14996 char *keySize_pos
= strchr (spinCount_pos
, '*');
14998 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15000 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15002 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15006 char *saltSize_pos
= strchr (keySize_pos
, '*');
15008 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15010 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15012 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15016 char *osalt_pos
= strchr (saltSize_pos
, '*');
15018 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15020 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15022 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15026 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15028 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15030 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15032 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15034 encryptedVerifier_pos
++;
15036 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15038 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15040 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15042 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15044 encryptedVerifierHash_pos
++;
15046 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;
15048 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15050 const uint version
= atoi (version_pos
);
15052 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15054 const uint spinCount
= atoi (spinCount_pos
);
15056 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15058 const uint keySize
= atoi (keySize_pos
);
15060 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15062 const uint saltSize
= atoi (saltSize_pos
);
15064 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15070 salt
->salt_len
= 16;
15071 salt
->salt_iter
= spinCount
;
15073 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15074 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15075 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15076 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15082 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15083 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15084 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15085 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15087 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15088 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15089 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15090 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15091 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15092 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15093 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15094 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15100 digest
[0] = office2010
->encryptedVerifierHash
[0];
15101 digest
[1] = office2010
->encryptedVerifierHash
[1];
15102 digest
[2] = office2010
->encryptedVerifierHash
[2];
15103 digest
[3] = office2010
->encryptedVerifierHash
[3];
15105 return (PARSER_OK
);
15108 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15110 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15112 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15114 u32
*digest
= (u32
*) hash_buf
->digest
;
15116 salt_t
*salt
= hash_buf
->salt
;
15118 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15124 char *version_pos
= input_buf
+ 8 + 1;
15126 char *spinCount_pos
= strchr (version_pos
, '*');
15128 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15130 u32 version_len
= spinCount_pos
- version_pos
;
15132 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15136 char *keySize_pos
= strchr (spinCount_pos
, '*');
15138 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15140 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15142 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15146 char *saltSize_pos
= strchr (keySize_pos
, '*');
15148 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15150 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15152 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15156 char *osalt_pos
= strchr (saltSize_pos
, '*');
15158 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15160 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15162 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15166 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15168 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15170 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15172 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15174 encryptedVerifier_pos
++;
15176 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15178 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15180 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15182 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15184 encryptedVerifierHash_pos
++;
15186 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;
15188 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15190 const uint version
= atoi (version_pos
);
15192 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15194 const uint spinCount
= atoi (spinCount_pos
);
15196 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15198 const uint keySize
= atoi (keySize_pos
);
15200 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15202 const uint saltSize
= atoi (saltSize_pos
);
15204 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15210 salt
->salt_len
= 16;
15211 salt
->salt_iter
= spinCount
;
15213 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15214 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15215 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15216 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15222 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15223 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15224 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15225 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15227 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15228 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15229 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15230 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15231 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15232 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15233 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15234 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15240 digest
[0] = office2013
->encryptedVerifierHash
[0];
15241 digest
[1] = office2013
->encryptedVerifierHash
[1];
15242 digest
[2] = office2013
->encryptedVerifierHash
[2];
15243 digest
[3] = office2013
->encryptedVerifierHash
[3];
15245 return (PARSER_OK
);
15248 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15250 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15252 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15254 u32
*digest
= (u32
*) hash_buf
->digest
;
15256 salt_t
*salt
= hash_buf
->salt
;
15258 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15264 char *version_pos
= input_buf
+ 11;
15266 char *osalt_pos
= strchr (version_pos
, '*');
15268 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15270 u32 version_len
= osalt_pos
- version_pos
;
15272 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15276 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15278 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15280 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15282 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15284 encryptedVerifier_pos
++;
15286 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15288 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15290 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15292 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15294 encryptedVerifierHash_pos
++;
15296 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15298 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15300 const uint version
= *version_pos
- 0x30;
15302 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15308 oldoffice01
->version
= version
;
15310 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15311 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15312 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15313 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15315 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15316 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15317 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15318 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15320 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15321 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15322 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15323 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15325 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15326 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15327 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15328 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15334 salt
->salt_len
= 16;
15336 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15337 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15338 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15339 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15341 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15342 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15343 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15344 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15346 // this is a workaround as office produces multiple documents with the same salt
15348 salt
->salt_len
+= 32;
15350 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15351 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15352 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15353 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15354 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15355 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15356 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15357 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15363 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15364 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15365 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15366 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15368 return (PARSER_OK
);
15371 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15373 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15376 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15378 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15380 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15382 u32
*digest
= (u32
*) hash_buf
->digest
;
15384 salt_t
*salt
= hash_buf
->salt
;
15386 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15392 char *version_pos
= input_buf
+ 11;
15394 char *osalt_pos
= strchr (version_pos
, '*');
15396 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15398 u32 version_len
= osalt_pos
- version_pos
;
15400 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15404 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15406 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15408 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15410 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15412 encryptedVerifier_pos
++;
15414 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15416 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15418 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15420 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15422 encryptedVerifierHash_pos
++;
15424 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15426 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15428 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15430 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15434 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15436 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15438 const uint version
= *version_pos
- 0x30;
15440 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15446 oldoffice01
->version
= version
;
15448 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15449 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15450 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15451 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15453 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15454 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15455 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15456 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15458 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15459 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15460 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15461 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15463 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15464 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15465 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15466 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15468 oldoffice01
->rc4key
[1] = 0;
15469 oldoffice01
->rc4key
[0] = 0;
15471 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15472 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15473 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15474 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15475 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15476 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15477 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15478 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15479 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15480 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15482 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15483 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15489 salt
->salt_len
= 16;
15491 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15492 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15493 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15494 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15496 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15497 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15498 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15499 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15501 // this is a workaround as office produces multiple documents with the same salt
15503 salt
->salt_len
+= 32;
15505 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15506 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15507 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15508 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15509 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15510 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15511 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15512 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15518 digest
[0] = oldoffice01
->rc4key
[0];
15519 digest
[1] = oldoffice01
->rc4key
[1];
15523 return (PARSER_OK
);
15526 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15528 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15530 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15532 u32
*digest
= (u32
*) hash_buf
->digest
;
15534 salt_t
*salt
= hash_buf
->salt
;
15536 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15542 char *version_pos
= input_buf
+ 11;
15544 char *osalt_pos
= strchr (version_pos
, '*');
15546 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15548 u32 version_len
= osalt_pos
- version_pos
;
15550 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15554 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15556 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15558 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15560 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15562 encryptedVerifier_pos
++;
15564 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15566 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15568 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15570 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15572 encryptedVerifierHash_pos
++;
15574 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15576 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15578 const uint version
= *version_pos
- 0x30;
15580 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15586 oldoffice34
->version
= version
;
15588 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15589 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15590 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15591 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15593 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15594 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15595 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15596 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15598 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15599 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15600 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15601 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15602 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15604 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15605 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15606 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15607 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15608 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15614 salt
->salt_len
= 16;
15616 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15617 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15618 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15619 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15621 // this is a workaround as office produces multiple documents with the same salt
15623 salt
->salt_len
+= 32;
15625 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15626 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15627 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15628 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15629 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15630 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15631 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15632 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15638 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15639 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15640 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15641 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15643 return (PARSER_OK
);
15646 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15648 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15650 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15653 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15655 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15657 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15659 u32
*digest
= (u32
*) hash_buf
->digest
;
15661 salt_t
*salt
= hash_buf
->salt
;
15663 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15669 char *version_pos
= input_buf
+ 11;
15671 char *osalt_pos
= strchr (version_pos
, '*');
15673 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15675 u32 version_len
= osalt_pos
- version_pos
;
15677 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15681 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15683 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15685 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15687 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15689 encryptedVerifier_pos
++;
15691 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15693 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15695 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15697 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15699 encryptedVerifierHash_pos
++;
15701 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15703 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15705 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15707 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15711 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15713 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15715 const uint version
= *version_pos
- 0x30;
15717 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15723 oldoffice34
->version
= version
;
15725 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15726 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15727 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15728 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15730 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15731 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15732 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15733 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15735 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15736 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15737 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15738 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15739 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15741 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15742 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15743 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15744 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15745 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15747 oldoffice34
->rc4key
[1] = 0;
15748 oldoffice34
->rc4key
[0] = 0;
15750 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15751 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15752 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15753 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15754 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15755 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15756 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15757 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15758 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15759 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15761 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15762 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15768 salt
->salt_len
= 16;
15770 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15771 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15772 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15773 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15775 // this is a workaround as office produces multiple documents with the same salt
15777 salt
->salt_len
+= 32;
15779 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15780 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15781 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15782 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15783 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15784 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15785 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15786 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15792 digest
[0] = oldoffice34
->rc4key
[0];
15793 digest
[1] = oldoffice34
->rc4key
[1];
15797 return (PARSER_OK
);
15800 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15802 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15804 u32
*digest
= (u32
*) hash_buf
->digest
;
15806 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15807 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15808 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15809 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15811 digest
[0] = byte_swap_32 (digest
[0]);
15812 digest
[1] = byte_swap_32 (digest
[1]);
15813 digest
[2] = byte_swap_32 (digest
[2]);
15814 digest
[3] = byte_swap_32 (digest
[3]);
15816 return (PARSER_OK
);
15819 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15821 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15823 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15825 u32
*digest
= (u32
*) hash_buf
->digest
;
15827 salt_t
*salt
= hash_buf
->salt
;
15829 char *signature_pos
= input_buf
;
15831 char *salt_pos
= strchr (signature_pos
, '$');
15833 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15835 u32 signature_len
= salt_pos
- signature_pos
;
15837 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15841 char *hash_pos
= strchr (salt_pos
, '$');
15843 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15845 u32 salt_len
= hash_pos
- salt_pos
;
15847 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15851 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15853 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15855 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15856 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15857 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15858 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15859 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15861 digest
[0] -= SHA1M_A
;
15862 digest
[1] -= SHA1M_B
;
15863 digest
[2] -= SHA1M_C
;
15864 digest
[3] -= SHA1M_D
;
15865 digest
[4] -= SHA1M_E
;
15867 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15869 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15871 salt
->salt_len
= salt_len
;
15873 return (PARSER_OK
);
15876 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15878 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15880 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15882 u32
*digest
= (u32
*) hash_buf
->digest
;
15884 salt_t
*salt
= hash_buf
->salt
;
15886 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15892 char *iter_pos
= input_buf
+ 14;
15894 const int iter
= atoi (iter_pos
);
15896 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15898 salt
->salt_iter
= iter
- 1;
15900 char *salt_pos
= strchr (iter_pos
, '$');
15902 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15906 char *hash_pos
= strchr (salt_pos
, '$');
15908 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15910 const uint salt_len
= hash_pos
- salt_pos
;
15914 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15916 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15918 salt
->salt_len
= salt_len
;
15920 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15921 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15923 // add some stuff to normal salt to make sorted happy
15925 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15926 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15927 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15928 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15929 salt
->salt_buf
[4] = salt
->salt_iter
;
15931 // base64 decode hash
15935 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15937 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15939 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15941 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15943 memcpy (digest
, tmp_buf
, 32);
15945 digest
[0] = byte_swap_32 (digest
[0]);
15946 digest
[1] = byte_swap_32 (digest
[1]);
15947 digest
[2] = byte_swap_32 (digest
[2]);
15948 digest
[3] = byte_swap_32 (digest
[3]);
15949 digest
[4] = byte_swap_32 (digest
[4]);
15950 digest
[5] = byte_swap_32 (digest
[5]);
15951 digest
[6] = byte_swap_32 (digest
[6]);
15952 digest
[7] = byte_swap_32 (digest
[7]);
15954 return (PARSER_OK
);
15957 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15959 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15961 u32
*digest
= (u32
*) hash_buf
->digest
;
15963 salt_t
*salt
= hash_buf
->salt
;
15965 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15966 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15970 digest
[0] = byte_swap_32 (digest
[0]);
15971 digest
[1] = byte_swap_32 (digest
[1]);
15973 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15974 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15975 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15977 char iter_c
= input_buf
[17];
15978 char iter_d
= input_buf
[19];
15980 // atm only defaults, let's see if there's more request
15981 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15982 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15984 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15986 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15987 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15988 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15989 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15991 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15992 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15993 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15994 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15996 salt
->salt_len
= 16;
15998 return (PARSER_OK
);
16001 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16003 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16005 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16007 u32
*digest
= (u32
*) hash_buf
->digest
;
16009 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16011 salt_t
*salt
= hash_buf
->salt
;
16013 char *salt_pos
= input_buf
+ 10;
16015 char *hash_pos
= strchr (salt_pos
, '$');
16017 uint salt_len
= hash_pos
- salt_pos
;
16019 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16023 uint hash_len
= input_len
- 10 - salt_len
- 1;
16025 // base64 decode salt
16029 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16031 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16033 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16035 tmp_buf
[salt_len
] = 0x80;
16037 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16039 salt
->salt_len
= salt_len
;
16041 // base64 decode salt
16043 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16045 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16047 uint user_len
= hash_len
- 32;
16049 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16051 user_len
--; // skip the trailing space
16053 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16054 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16055 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16056 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16058 digest
[0] = byte_swap_32 (digest
[0]);
16059 digest
[1] = byte_swap_32 (digest
[1]);
16060 digest
[2] = byte_swap_32 (digest
[2]);
16061 digest
[3] = byte_swap_32 (digest
[3]);
16063 // store username for host only (output hash if cracked)
16065 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16066 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16068 return (PARSER_OK
);
16071 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16073 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16075 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16077 u32
*digest
= (u32
*) hash_buf
->digest
;
16079 salt_t
*salt
= hash_buf
->salt
;
16081 char *iter_pos
= input_buf
+ 10;
16083 u32 iter
= atoi (iter_pos
);
16087 return (PARSER_SALT_ITERATION
);
16090 iter
--; // first iteration is special
16092 salt
->salt_iter
= iter
;
16094 char *base64_pos
= strchr (iter_pos
, '}');
16096 if (base64_pos
== NULL
)
16098 return (PARSER_SIGNATURE_UNMATCHED
);
16103 // base64 decode salt
16105 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16109 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16111 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16113 if (decoded_len
< 24)
16115 return (PARSER_SALT_LENGTH
);
16120 uint salt_len
= decoded_len
- 20;
16122 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16123 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16125 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16127 salt
->salt_len
= salt_len
;
16131 u32
*digest_ptr
= (u32
*) tmp_buf
;
16133 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16134 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16135 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16136 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16137 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16139 return (PARSER_OK
);
16142 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16144 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16146 u32
*digest
= (u32
*) hash_buf
->digest
;
16148 salt_t
*salt
= hash_buf
->salt
;
16150 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16151 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16152 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16153 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16154 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16156 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16158 uint salt_len
= input_len
- 40 - 1;
16160 char *salt_buf
= input_buf
+ 40 + 1;
16162 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16164 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16166 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16168 salt
->salt_len
= salt_len
;
16170 return (PARSER_OK
);
16173 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16175 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16177 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16179 u32
*digest
= (u32
*) hash_buf
->digest
;
16181 salt_t
*salt
= hash_buf
->salt
;
16183 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16189 char *V_pos
= input_buf
+ 5;
16191 char *R_pos
= strchr (V_pos
, '*');
16193 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16195 u32 V_len
= R_pos
- V_pos
;
16199 char *bits_pos
= strchr (R_pos
, '*');
16201 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16203 u32 R_len
= bits_pos
- R_pos
;
16207 char *P_pos
= strchr (bits_pos
, '*');
16209 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16211 u32 bits_len
= P_pos
- bits_pos
;
16215 char *enc_md_pos
= strchr (P_pos
, '*');
16217 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16219 u32 P_len
= enc_md_pos
- P_pos
;
16223 char *id_len_pos
= strchr (enc_md_pos
, '*');
16225 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16227 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16231 char *id_buf_pos
= strchr (id_len_pos
, '*');
16233 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16235 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16239 char *u_len_pos
= strchr (id_buf_pos
, '*');
16241 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16243 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16245 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16249 char *u_buf_pos
= strchr (u_len_pos
, '*');
16251 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16253 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16257 char *o_len_pos
= strchr (u_buf_pos
, '*');
16259 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16261 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16263 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16267 char *o_buf_pos
= strchr (o_len_pos
, '*');
16269 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16271 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16275 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;
16277 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16281 const int V
= atoi (V_pos
);
16282 const int R
= atoi (R_pos
);
16283 const int P
= atoi (P_pos
);
16285 if (V
!= 1) return (PARSER_SALT_VALUE
);
16286 if (R
!= 2) return (PARSER_SALT_VALUE
);
16288 const int enc_md
= atoi (enc_md_pos
);
16290 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16292 const int id_len
= atoi (id_len_pos
);
16293 const int u_len
= atoi (u_len_pos
);
16294 const int o_len
= atoi (o_len_pos
);
16296 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16297 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16298 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16300 const int bits
= atoi (bits_pos
);
16302 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16304 // copy data to esalt
16310 pdf
->enc_md
= enc_md
;
16312 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16313 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16314 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16315 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16316 pdf
->id_len
= id_len
;
16318 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16319 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16320 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16321 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16322 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16323 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16324 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16325 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16326 pdf
->u_len
= u_len
;
16328 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16329 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16330 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16331 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16332 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16333 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16334 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16335 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16336 pdf
->o_len
= o_len
;
16338 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16339 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16340 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16341 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16343 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16344 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16345 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16346 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16347 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16348 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16349 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16350 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16352 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16353 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16354 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16355 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16356 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16357 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16358 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16359 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16361 // we use ID for salt, maybe needs to change, we will see...
16363 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16364 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16365 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16366 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16367 salt
->salt_len
= pdf
->id_len
;
16369 digest
[0] = pdf
->u_buf
[0];
16370 digest
[1] = pdf
->u_buf
[1];
16371 digest
[2] = pdf
->u_buf
[2];
16372 digest
[3] = pdf
->u_buf
[3];
16374 return (PARSER_OK
);
16377 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16379 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16382 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16384 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16386 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16388 u32
*digest
= (u32
*) hash_buf
->digest
;
16390 salt_t
*salt
= hash_buf
->salt
;
16392 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16398 char *V_pos
= input_buf
+ 5;
16400 char *R_pos
= strchr (V_pos
, '*');
16402 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16404 u32 V_len
= R_pos
- V_pos
;
16408 char *bits_pos
= strchr (R_pos
, '*');
16410 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16412 u32 R_len
= bits_pos
- R_pos
;
16416 char *P_pos
= strchr (bits_pos
, '*');
16418 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16420 u32 bits_len
= P_pos
- bits_pos
;
16424 char *enc_md_pos
= strchr (P_pos
, '*');
16426 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16428 u32 P_len
= enc_md_pos
- P_pos
;
16432 char *id_len_pos
= strchr (enc_md_pos
, '*');
16434 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16436 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16440 char *id_buf_pos
= strchr (id_len_pos
, '*');
16442 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16444 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16448 char *u_len_pos
= strchr (id_buf_pos
, '*');
16450 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16452 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16454 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16458 char *u_buf_pos
= strchr (u_len_pos
, '*');
16460 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16462 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16466 char *o_len_pos
= strchr (u_buf_pos
, '*');
16468 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16470 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16472 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16476 char *o_buf_pos
= strchr (o_len_pos
, '*');
16478 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16480 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16484 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16486 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16488 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16490 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16494 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;
16496 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16500 const int V
= atoi (V_pos
);
16501 const int R
= atoi (R_pos
);
16502 const int P
= atoi (P_pos
);
16504 if (V
!= 1) return (PARSER_SALT_VALUE
);
16505 if (R
!= 2) return (PARSER_SALT_VALUE
);
16507 const int enc_md
= atoi (enc_md_pos
);
16509 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16511 const int id_len
= atoi (id_len_pos
);
16512 const int u_len
= atoi (u_len_pos
);
16513 const int o_len
= atoi (o_len_pos
);
16515 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16516 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16517 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16519 const int bits
= atoi (bits_pos
);
16521 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16523 // copy data to esalt
16529 pdf
->enc_md
= enc_md
;
16531 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16532 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16533 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16534 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16535 pdf
->id_len
= id_len
;
16537 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16538 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16539 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16540 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16541 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16542 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16543 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16544 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16545 pdf
->u_len
= u_len
;
16547 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16548 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16549 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16550 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16551 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16552 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16553 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16554 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16555 pdf
->o_len
= o_len
;
16557 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16558 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16559 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16560 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16562 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16563 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16564 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16565 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16566 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16567 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16568 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16569 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16571 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16572 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16573 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16574 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16575 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16576 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16577 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16578 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16580 pdf
->rc4key
[1] = 0;
16581 pdf
->rc4key
[0] = 0;
16583 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16584 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16585 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16586 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16587 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16588 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16589 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16590 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16591 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16592 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16594 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16595 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16597 // we use ID for salt, maybe needs to change, we will see...
16599 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16600 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16601 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16602 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16603 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16604 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16605 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16606 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16607 salt
->salt_len
= pdf
->id_len
+ 16;
16609 digest
[0] = pdf
->rc4key
[0];
16610 digest
[1] = pdf
->rc4key
[1];
16614 return (PARSER_OK
);
16617 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16619 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16621 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16623 u32
*digest
= (u32
*) hash_buf
->digest
;
16625 salt_t
*salt
= hash_buf
->salt
;
16627 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16633 char *V_pos
= input_buf
+ 5;
16635 char *R_pos
= strchr (V_pos
, '*');
16637 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16639 u32 V_len
= R_pos
- V_pos
;
16643 char *bits_pos
= strchr (R_pos
, '*');
16645 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16647 u32 R_len
= bits_pos
- R_pos
;
16651 char *P_pos
= strchr (bits_pos
, '*');
16653 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16655 u32 bits_len
= P_pos
- bits_pos
;
16659 char *enc_md_pos
= strchr (P_pos
, '*');
16661 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16663 u32 P_len
= enc_md_pos
- P_pos
;
16667 char *id_len_pos
= strchr (enc_md_pos
, '*');
16669 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16671 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16675 char *id_buf_pos
= strchr (id_len_pos
, '*');
16677 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16679 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16683 char *u_len_pos
= strchr (id_buf_pos
, '*');
16685 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16687 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16689 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16693 char *u_buf_pos
= strchr (u_len_pos
, '*');
16695 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16697 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16701 char *o_len_pos
= strchr (u_buf_pos
, '*');
16703 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16705 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16707 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16711 char *o_buf_pos
= strchr (o_len_pos
, '*');
16713 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16715 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16719 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;
16721 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16725 const int V
= atoi (V_pos
);
16726 const int R
= atoi (R_pos
);
16727 const int P
= atoi (P_pos
);
16731 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16732 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16734 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16736 const int id_len
= atoi (id_len_pos
);
16737 const int u_len
= atoi (u_len_pos
);
16738 const int o_len
= atoi (o_len_pos
);
16740 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16742 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16743 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16745 const int bits
= atoi (bits_pos
);
16747 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16753 enc_md
= atoi (enc_md_pos
);
16756 // copy data to esalt
16762 pdf
->enc_md
= enc_md
;
16764 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16765 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16766 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16767 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16771 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16772 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16773 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16774 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16777 pdf
->id_len
= id_len
;
16779 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16780 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16781 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16782 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16783 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16784 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16785 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16786 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16787 pdf
->u_len
= u_len
;
16789 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16790 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16791 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16792 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16793 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16794 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16795 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16796 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16797 pdf
->o_len
= o_len
;
16799 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16800 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16801 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16802 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16806 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16807 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16808 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16809 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16812 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16813 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16814 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16815 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16816 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16817 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16818 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16819 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16821 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16822 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16823 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16824 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16825 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16826 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16827 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16828 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16830 // precompute rc4 data for later use
16846 uint salt_pc_block
[32];
16848 char *salt_pc_ptr
= (char *) salt_pc_block
;
16850 memcpy (salt_pc_ptr
, padding
, 32);
16851 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16853 uint salt_pc_digest
[4];
16855 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16857 pdf
->rc4data
[0] = salt_pc_digest
[0];
16858 pdf
->rc4data
[1] = salt_pc_digest
[1];
16860 // we use ID for salt, maybe needs to change, we will see...
16862 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16863 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16864 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16865 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16866 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16867 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16868 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16869 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16870 salt
->salt_len
= pdf
->id_len
+ 16;
16872 salt
->salt_iter
= ROUNDS_PDF14
;
16874 digest
[0] = pdf
->u_buf
[0];
16875 digest
[1] = pdf
->u_buf
[1];
16879 return (PARSER_OK
);
16882 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16884 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16886 if (ret
!= PARSER_OK
)
16891 u32
*digest
= (u32
*) hash_buf
->digest
;
16893 salt_t
*salt
= hash_buf
->salt
;
16895 digest
[0] -= SHA256M_A
;
16896 digest
[1] -= SHA256M_B
;
16897 digest
[2] -= SHA256M_C
;
16898 digest
[3] -= SHA256M_D
;
16899 digest
[4] -= SHA256M_E
;
16900 digest
[5] -= SHA256M_F
;
16901 digest
[6] -= SHA256M_G
;
16902 digest
[7] -= SHA256M_H
;
16904 salt
->salt_buf
[2] = 0x80;
16906 return (PARSER_OK
);
16909 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16911 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16913 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16915 u32
*digest
= (u32
*) hash_buf
->digest
;
16917 salt_t
*salt
= hash_buf
->salt
;
16919 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16925 char *V_pos
= input_buf
+ 5;
16927 char *R_pos
= strchr (V_pos
, '*');
16929 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16931 u32 V_len
= R_pos
- V_pos
;
16935 char *bits_pos
= strchr (R_pos
, '*');
16937 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16939 u32 R_len
= bits_pos
- R_pos
;
16943 char *P_pos
= strchr (bits_pos
, '*');
16945 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16947 u32 bits_len
= P_pos
- bits_pos
;
16951 char *enc_md_pos
= strchr (P_pos
, '*');
16953 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16955 u32 P_len
= enc_md_pos
- P_pos
;
16959 char *id_len_pos
= strchr (enc_md_pos
, '*');
16961 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16963 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16967 char *id_buf_pos
= strchr (id_len_pos
, '*');
16969 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16971 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16975 char *u_len_pos
= strchr (id_buf_pos
, '*');
16977 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16979 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16983 char *u_buf_pos
= strchr (u_len_pos
, '*');
16985 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16987 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16991 char *o_len_pos
= strchr (u_buf_pos
, '*');
16993 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16995 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16999 char *o_buf_pos
= strchr (o_len_pos
, '*');
17001 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17003 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17007 char *last
= strchr (o_buf_pos
, '*');
17009 if (last
== NULL
) last
= input_buf
+ input_len
;
17011 u32 o_buf_len
= last
- o_buf_pos
;
17015 const int V
= atoi (V_pos
);
17016 const int R
= atoi (R_pos
);
17020 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17021 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17023 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17025 const int bits
= atoi (bits_pos
);
17027 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17029 int enc_md
= atoi (enc_md_pos
);
17031 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17033 const uint id_len
= atoi (id_len_pos
);
17034 const uint u_len
= atoi (u_len_pos
);
17035 const uint o_len
= atoi (o_len_pos
);
17037 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17038 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17039 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17040 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17041 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17042 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17043 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17044 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17046 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17047 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17048 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17050 // copy data to esalt
17052 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17054 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17056 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17059 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17060 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17062 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17063 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17065 salt
->salt_len
= 8;
17066 salt
->salt_iter
= ROUNDS_PDF17L8
;
17068 digest
[0] = pdf
->u_buf
[0];
17069 digest
[1] = pdf
->u_buf
[1];
17070 digest
[2] = pdf
->u_buf
[2];
17071 digest
[3] = pdf
->u_buf
[3];
17072 digest
[4] = pdf
->u_buf
[4];
17073 digest
[5] = pdf
->u_buf
[5];
17074 digest
[6] = pdf
->u_buf
[6];
17075 digest
[7] = pdf
->u_buf
[7];
17077 return (PARSER_OK
);
17080 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17082 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17084 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17086 u32
*digest
= (u32
*) hash_buf
->digest
;
17088 salt_t
*salt
= hash_buf
->salt
;
17090 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17098 char *iter_pos
= input_buf
+ 7;
17100 u32 iter
= atoi (iter_pos
);
17102 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17103 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17105 // first is *raw* salt
17107 char *salt_pos
= strchr (iter_pos
, ':');
17109 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17113 char *hash_pos
= strchr (salt_pos
, ':');
17115 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17117 u32 salt_len
= hash_pos
- salt_pos
;
17119 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17123 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17125 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17129 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17131 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17133 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17135 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17136 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17138 salt
->salt_len
= salt_len
;
17139 salt
->salt_iter
= iter
- 1;
17145 memset (tmp_buf
, 0, sizeof (tmp_buf
));
17147 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17149 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17151 memcpy (digest
, tmp_buf
, 16);
17153 digest
[0] = byte_swap_32 (digest
[0]);
17154 digest
[1] = byte_swap_32 (digest
[1]);
17155 digest
[2] = byte_swap_32 (digest
[2]);
17156 digest
[3] = byte_swap_32 (digest
[3]);
17158 // add some stuff to normal salt to make sorted happy
17160 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17161 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17162 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17163 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17164 salt
->salt_buf
[4] = salt
->salt_iter
;
17166 return (PARSER_OK
);
17169 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17171 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17173 u32
*digest
= (u32
*) hash_buf
->digest
;
17175 salt_t
*salt
= hash_buf
->salt
;
17177 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17178 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17179 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17180 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17182 digest
[0] = byte_swap_32 (digest
[0]);
17183 digest
[1] = byte_swap_32 (digest
[1]);
17184 digest
[2] = byte_swap_32 (digest
[2]);
17185 digest
[3] = byte_swap_32 (digest
[3]);
17187 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17189 uint salt_len
= input_len
- 32 - 1;
17191 char *salt_buf
= input_buf
+ 32 + 1;
17193 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17195 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17197 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17199 salt
->salt_len
= salt_len
;
17201 return (PARSER_OK
);
17204 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17206 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17208 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17210 u32
*digest
= (u32
*) hash_buf
->digest
;
17212 salt_t
*salt
= hash_buf
->salt
;
17214 char *user_pos
= input_buf
+ 10;
17216 char *salt_pos
= strchr (user_pos
, '*');
17218 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17222 char *hash_pos
= strchr (salt_pos
, '*');
17226 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17228 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17230 uint user_len
= salt_pos
- user_pos
- 1;
17232 uint salt_len
= hash_pos
- salt_pos
- 1;
17234 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17240 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17241 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17242 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17243 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17245 digest
[0] = byte_swap_32 (digest
[0]);
17246 digest
[1] = byte_swap_32 (digest
[1]);
17247 digest
[2] = byte_swap_32 (digest
[2]);
17248 digest
[3] = byte_swap_32 (digest
[3]);
17250 digest
[0] -= MD5M_A
;
17251 digest
[1] -= MD5M_B
;
17252 digest
[2] -= MD5M_C
;
17253 digest
[3] -= MD5M_D
;
17259 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17261 // first 4 bytes are the "challenge"
17263 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17264 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17265 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17266 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17268 // append the user name
17270 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17272 salt
->salt_len
= 4 + user_len
;
17274 return (PARSER_OK
);
17277 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17279 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17281 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17283 u32
*digest
= (u32
*) hash_buf
->digest
;
17285 salt_t
*salt
= hash_buf
->salt
;
17287 char *salt_pos
= input_buf
+ 9;
17289 char *hash_pos
= strchr (salt_pos
, '*');
17291 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17295 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17297 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17299 uint salt_len
= hash_pos
- salt_pos
- 1;
17301 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17307 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17308 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17309 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17310 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17311 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17317 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17319 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17321 salt
->salt_len
= salt_len
;
17323 return (PARSER_OK
);
17326 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17328 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17330 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17332 u32
*digest
= (u32
*) hash_buf
->digest
;
17334 salt_t
*salt
= hash_buf
->salt
;
17336 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17342 char *cry_master_len_pos
= input_buf
+ 9;
17344 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17346 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17348 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17350 cry_master_buf_pos
++;
17352 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17354 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17356 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17358 cry_salt_len_pos
++;
17360 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17362 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17364 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17366 cry_salt_buf_pos
++;
17368 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17370 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17372 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17376 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17378 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17380 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17384 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17386 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17388 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17392 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17394 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17396 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17398 public_key_len_pos
++;
17400 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17402 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17404 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17406 public_key_buf_pos
++;
17408 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;
17410 const uint cry_master_len
= atoi (cry_master_len_pos
);
17411 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17412 const uint ckey_len
= atoi (ckey_len_pos
);
17413 const uint public_key_len
= atoi (public_key_len_pos
);
17415 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17416 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17417 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17418 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17420 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17422 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17424 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17427 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17429 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17431 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17434 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17436 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17438 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17441 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17442 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17443 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17446 * store digest (should be unique enought, hopefully)
17449 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17450 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17451 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17452 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17458 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17460 const uint cry_rounds
= atoi (cry_rounds_pos
);
17462 salt
->salt_iter
= cry_rounds
- 1;
17464 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17466 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17468 salt
->salt_len
= salt_len
;
17470 return (PARSER_OK
);
17473 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17475 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17477 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17479 u32
*digest
= (u32
*) hash_buf
->digest
;
17481 salt_t
*salt
= hash_buf
->salt
;
17483 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17485 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17487 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17489 memcpy (temp_input_buf
, input_buf
, input_len
);
17493 char *URI_server_pos
= temp_input_buf
+ 6;
17495 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17497 if (URI_client_pos
== NULL
)
17499 myfree (temp_input_buf
);
17501 return (PARSER_SEPARATOR_UNMATCHED
);
17504 URI_client_pos
[0] = 0;
17507 uint URI_server_len
= strlen (URI_server_pos
);
17509 if (URI_server_len
> 512)
17511 myfree (temp_input_buf
);
17513 return (PARSER_SALT_LENGTH
);
17518 char *user_pos
= strchr (URI_client_pos
, '*');
17520 if (user_pos
== NULL
)
17522 myfree (temp_input_buf
);
17524 return (PARSER_SEPARATOR_UNMATCHED
);
17530 uint URI_client_len
= strlen (URI_client_pos
);
17532 if (URI_client_len
> 512)
17534 myfree (temp_input_buf
);
17536 return (PARSER_SALT_LENGTH
);
17541 char *realm_pos
= strchr (user_pos
, '*');
17543 if (realm_pos
== NULL
)
17545 myfree (temp_input_buf
);
17547 return (PARSER_SEPARATOR_UNMATCHED
);
17553 uint user_len
= strlen (user_pos
);
17555 if (user_len
> 116)
17557 myfree (temp_input_buf
);
17559 return (PARSER_SALT_LENGTH
);
17564 char *method_pos
= strchr (realm_pos
, '*');
17566 if (method_pos
== NULL
)
17568 myfree (temp_input_buf
);
17570 return (PARSER_SEPARATOR_UNMATCHED
);
17576 uint realm_len
= strlen (realm_pos
);
17578 if (realm_len
> 116)
17580 myfree (temp_input_buf
);
17582 return (PARSER_SALT_LENGTH
);
17587 char *URI_prefix_pos
= strchr (method_pos
, '*');
17589 if (URI_prefix_pos
== NULL
)
17591 myfree (temp_input_buf
);
17593 return (PARSER_SEPARATOR_UNMATCHED
);
17596 URI_prefix_pos
[0] = 0;
17599 uint method_len
= strlen (method_pos
);
17601 if (method_len
> 246)
17603 myfree (temp_input_buf
);
17605 return (PARSER_SALT_LENGTH
);
17610 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17612 if (URI_resource_pos
== NULL
)
17614 myfree (temp_input_buf
);
17616 return (PARSER_SEPARATOR_UNMATCHED
);
17619 URI_resource_pos
[0] = 0;
17620 URI_resource_pos
++;
17622 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17624 if (URI_prefix_len
> 245)
17626 myfree (temp_input_buf
);
17628 return (PARSER_SALT_LENGTH
);
17633 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17635 if (URI_suffix_pos
== NULL
)
17637 myfree (temp_input_buf
);
17639 return (PARSER_SEPARATOR_UNMATCHED
);
17642 URI_suffix_pos
[0] = 0;
17645 uint URI_resource_len
= strlen (URI_resource_pos
);
17647 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17649 myfree (temp_input_buf
);
17651 return (PARSER_SALT_LENGTH
);
17656 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17658 if (nonce_pos
== NULL
)
17660 myfree (temp_input_buf
);
17662 return (PARSER_SEPARATOR_UNMATCHED
);
17668 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17670 if (URI_suffix_len
> 245)
17672 myfree (temp_input_buf
);
17674 return (PARSER_SALT_LENGTH
);
17679 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17681 if (nonce_client_pos
== NULL
)
17683 myfree (temp_input_buf
);
17685 return (PARSER_SEPARATOR_UNMATCHED
);
17688 nonce_client_pos
[0] = 0;
17689 nonce_client_pos
++;
17691 uint nonce_len
= strlen (nonce_pos
);
17693 if (nonce_len
< 1 || nonce_len
> 50)
17695 myfree (temp_input_buf
);
17697 return (PARSER_SALT_LENGTH
);
17702 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17704 if (nonce_count_pos
== NULL
)
17706 myfree (temp_input_buf
);
17708 return (PARSER_SEPARATOR_UNMATCHED
);
17711 nonce_count_pos
[0] = 0;
17714 uint nonce_client_len
= strlen (nonce_client_pos
);
17716 if (nonce_client_len
> 50)
17718 myfree (temp_input_buf
);
17720 return (PARSER_SALT_LENGTH
);
17725 char *qop_pos
= strchr (nonce_count_pos
, '*');
17727 if (qop_pos
== NULL
)
17729 myfree (temp_input_buf
);
17731 return (PARSER_SEPARATOR_UNMATCHED
);
17737 uint nonce_count_len
= strlen (nonce_count_pos
);
17739 if (nonce_count_len
> 50)
17741 myfree (temp_input_buf
);
17743 return (PARSER_SALT_LENGTH
);
17748 char *directive_pos
= strchr (qop_pos
, '*');
17750 if (directive_pos
== NULL
)
17752 myfree (temp_input_buf
);
17754 return (PARSER_SEPARATOR_UNMATCHED
);
17757 directive_pos
[0] = 0;
17760 uint qop_len
= strlen (qop_pos
);
17764 myfree (temp_input_buf
);
17766 return (PARSER_SALT_LENGTH
);
17771 char *digest_pos
= strchr (directive_pos
, '*');
17773 if (digest_pos
== NULL
)
17775 myfree (temp_input_buf
);
17777 return (PARSER_SEPARATOR_UNMATCHED
);
17783 uint directive_len
= strlen (directive_pos
);
17785 if (directive_len
!= 3)
17787 myfree (temp_input_buf
);
17789 return (PARSER_SALT_LENGTH
);
17792 if (memcmp (directive_pos
, "MD5", 3))
17794 log_info ("ERROR: only the MD5 directive is currently supported\n");
17796 myfree (temp_input_buf
);
17798 return (PARSER_SIP_AUTH_DIRECTIVE
);
17802 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17807 uint md5_max_len
= 4 * 64;
17809 uint md5_remaining_len
= md5_max_len
;
17811 uint tmp_md5_buf
[64] = { 0 };
17813 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17815 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17817 md5_len
+= method_len
+ 1;
17818 tmp_md5_ptr
+= method_len
+ 1;
17820 if (URI_prefix_len
> 0)
17822 md5_remaining_len
= md5_max_len
- md5_len
;
17824 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17826 md5_len
+= URI_prefix_len
+ 1;
17827 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17830 md5_remaining_len
= md5_max_len
- md5_len
;
17832 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17834 md5_len
+= URI_resource_len
;
17835 tmp_md5_ptr
+= URI_resource_len
;
17837 if (URI_suffix_len
> 0)
17839 md5_remaining_len
= md5_max_len
- md5_len
;
17841 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17843 md5_len
+= 1 + URI_suffix_len
;
17846 uint tmp_digest
[4] = { 0 };
17848 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17850 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17851 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17852 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17853 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17859 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17861 uint esalt_len
= 0;
17863 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17865 // there are 2 possibilities for the esalt:
17867 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17869 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17871 if (esalt_len
> max_esalt_len
)
17873 myfree (temp_input_buf
);
17875 return (PARSER_SALT_LENGTH
);
17878 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17890 esalt_len
= 1 + nonce_len
+ 1 + 32;
17892 if (esalt_len
> max_esalt_len
)
17894 myfree (temp_input_buf
);
17896 return (PARSER_SALT_LENGTH
);
17899 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17907 // add 0x80 to esalt
17909 esalt_buf_ptr
[esalt_len
] = 0x80;
17911 sip
->esalt_len
= esalt_len
;
17917 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17919 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17921 uint max_salt_len
= 119;
17923 if (salt_len
> max_salt_len
)
17925 myfree (temp_input_buf
);
17927 return (PARSER_SALT_LENGTH
);
17930 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17932 sip
->salt_len
= salt_len
;
17935 * fake salt (for sorting)
17938 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17942 uint fake_salt_len
= salt_len
;
17944 if (fake_salt_len
> max_salt_len
)
17946 fake_salt_len
= max_salt_len
;
17949 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17951 salt
->salt_len
= fake_salt_len
;
17957 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17958 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17959 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17960 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17962 digest
[0] = byte_swap_32 (digest
[0]);
17963 digest
[1] = byte_swap_32 (digest
[1]);
17964 digest
[2] = byte_swap_32 (digest
[2]);
17965 digest
[3] = byte_swap_32 (digest
[3]);
17967 myfree (temp_input_buf
);
17969 return (PARSER_OK
);
17972 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17974 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17976 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17978 u32
*digest
= (u32
*) hash_buf
->digest
;
17980 salt_t
*salt
= hash_buf
->salt
;
17984 char *digest_pos
= input_buf
;
17986 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17993 char *salt_buf
= input_buf
+ 8 + 1;
17997 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17999 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18001 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18003 salt
->salt_len
= salt_len
;
18005 return (PARSER_OK
);
18008 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18010 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18012 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18014 u32
*digest
= (u32
*) hash_buf
->digest
;
18016 salt_t
*salt
= hash_buf
->salt
;
18018 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18024 char *p_buf_pos
= input_buf
+ 4;
18026 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18028 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18030 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18032 NumCyclesPower_pos
++;
18034 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18036 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18038 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18042 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18044 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18046 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18050 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18052 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18054 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18058 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18060 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18062 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18066 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18068 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18070 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18074 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18076 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18078 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18082 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18084 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18086 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18090 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18092 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18094 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18098 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;
18100 const uint iter
= atoi (NumCyclesPower_pos
);
18101 const uint crc
= atoi (crc_buf_pos
);
18102 const uint p_buf
= atoi (p_buf_pos
);
18103 const uint salt_len
= atoi (salt_len_pos
);
18104 const uint iv_len
= atoi (iv_len_pos
);
18105 const uint unpack_size
= atoi (unpack_size_pos
);
18106 const uint data_len
= atoi (data_len_pos
);
18112 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18113 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18115 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18117 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18119 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18125 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18126 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18127 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18128 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18130 seven_zip
->iv_len
= iv_len
;
18132 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18134 seven_zip
->salt_len
= 0;
18136 seven_zip
->crc
= crc
;
18138 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18140 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18142 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18145 seven_zip
->data_len
= data_len
;
18147 seven_zip
->unpack_size
= unpack_size
;
18151 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18152 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18153 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18154 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18156 salt
->salt_len
= 16;
18158 salt
->salt_sign
[0] = iter
;
18160 salt
->salt_iter
= 1 << iter
;
18171 return (PARSER_OK
);
18174 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18176 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18178 u32
*digest
= (u32
*) hash_buf
->digest
;
18180 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18181 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18182 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18183 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18184 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18185 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18186 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18187 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18189 digest
[0] = byte_swap_32 (digest
[0]);
18190 digest
[1] = byte_swap_32 (digest
[1]);
18191 digest
[2] = byte_swap_32 (digest
[2]);
18192 digest
[3] = byte_swap_32 (digest
[3]);
18193 digest
[4] = byte_swap_32 (digest
[4]);
18194 digest
[5] = byte_swap_32 (digest
[5]);
18195 digest
[6] = byte_swap_32 (digest
[6]);
18196 digest
[7] = byte_swap_32 (digest
[7]);
18198 return (PARSER_OK
);
18201 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18203 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18205 u32
*digest
= (u32
*) hash_buf
->digest
;
18207 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18208 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18209 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18210 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18211 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18212 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18213 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18214 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18215 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18216 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18217 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18218 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18219 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18220 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18221 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18222 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18224 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18225 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18226 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18227 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18228 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18229 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18230 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18231 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18232 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18233 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18234 digest
[10] = byte_swap_32 (digest
[10]);
18235 digest
[11] = byte_swap_32 (digest
[11]);
18236 digest
[12] = byte_swap_32 (digest
[12]);
18237 digest
[13] = byte_swap_32 (digest
[13]);
18238 digest
[14] = byte_swap_32 (digest
[14]);
18239 digest
[15] = byte_swap_32 (digest
[15]);
18241 return (PARSER_OK
);
18244 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18246 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18248 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18250 u32
*digest
= (u32
*) hash_buf
->digest
;
18252 salt_t
*salt
= hash_buf
->salt
;
18254 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18262 char *iter_pos
= input_buf
+ 4;
18264 u32 iter
= atoi (iter_pos
);
18266 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18267 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18269 // first is *raw* salt
18271 char *salt_pos
= strchr (iter_pos
, ':');
18273 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18277 char *hash_pos
= strchr (salt_pos
, ':');
18279 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18281 u32 salt_len
= hash_pos
- salt_pos
;
18283 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18287 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18289 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18293 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18295 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18297 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18299 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18300 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18302 salt
->salt_len
= salt_len
;
18303 salt
->salt_iter
= iter
- 1;
18309 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18311 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18313 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18315 memcpy (digest
, tmp_buf
, 16);
18317 // add some stuff to normal salt to make sorted happy
18319 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18320 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18321 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18322 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18323 salt
->salt_buf
[4] = salt
->salt_iter
;
18325 return (PARSER_OK
);
18328 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18330 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18332 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18334 u32
*digest
= (u32
*) hash_buf
->digest
;
18336 salt_t
*salt
= hash_buf
->salt
;
18338 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18346 char *iter_pos
= input_buf
+ 5;
18348 u32 iter
= atoi (iter_pos
);
18350 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18351 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18353 // first is *raw* salt
18355 char *salt_pos
= strchr (iter_pos
, ':');
18357 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18361 char *hash_pos
= strchr (salt_pos
, ':');
18363 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18365 u32 salt_len
= hash_pos
- salt_pos
;
18367 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18371 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18373 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18377 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18379 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18381 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18383 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18384 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18386 salt
->salt_len
= salt_len
;
18387 salt
->salt_iter
= iter
- 1;
18393 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18395 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18397 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18399 memcpy (digest
, tmp_buf
, 16);
18401 digest
[0] = byte_swap_32 (digest
[0]);
18402 digest
[1] = byte_swap_32 (digest
[1]);
18403 digest
[2] = byte_swap_32 (digest
[2]);
18404 digest
[3] = byte_swap_32 (digest
[3]);
18406 // add some stuff to normal salt to make sorted happy
18408 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18409 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18410 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18411 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18412 salt
->salt_buf
[4] = salt
->salt_iter
;
18414 return (PARSER_OK
);
18417 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18419 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18421 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18423 u64
*digest
= (u64
*) hash_buf
->digest
;
18425 salt_t
*salt
= hash_buf
->salt
;
18427 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18435 char *iter_pos
= input_buf
+ 7;
18437 u32 iter
= atoi (iter_pos
);
18439 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18440 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18442 // first is *raw* salt
18444 char *salt_pos
= strchr (iter_pos
, ':');
18446 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18450 char *hash_pos
= strchr (salt_pos
, ':');
18452 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18454 u32 salt_len
= hash_pos
- salt_pos
;
18456 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18460 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18462 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18466 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18468 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18470 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18472 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18473 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18475 salt
->salt_len
= salt_len
;
18476 salt
->salt_iter
= iter
- 1;
18482 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18484 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18486 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18488 memcpy (digest
, tmp_buf
, 64);
18490 digest
[0] = byte_swap_64 (digest
[0]);
18491 digest
[1] = byte_swap_64 (digest
[1]);
18492 digest
[2] = byte_swap_64 (digest
[2]);
18493 digest
[3] = byte_swap_64 (digest
[3]);
18494 digest
[4] = byte_swap_64 (digest
[4]);
18495 digest
[5] = byte_swap_64 (digest
[5]);
18496 digest
[6] = byte_swap_64 (digest
[6]);
18497 digest
[7] = byte_swap_64 (digest
[7]);
18499 // add some stuff to normal salt to make sorted happy
18501 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18502 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18503 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18504 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18505 salt
->salt_buf
[4] = salt
->salt_iter
;
18507 return (PARSER_OK
);
18510 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18512 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18514 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18516 uint
*digest
= (uint
*) hash_buf
->digest
;
18518 salt_t
*salt
= hash_buf
->salt
;
18524 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18526 char *hash_pos
= strchr (salt_pos
, '$');
18528 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18530 u32 salt_len
= hash_pos
- salt_pos
;
18532 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18536 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18538 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18542 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18543 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18561 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18562 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18564 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18565 salt
->salt_len
= 8;
18567 return (PARSER_OK
);
18570 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18572 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18574 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18576 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18578 if (c19
& 3) return (PARSER_HASH_VALUE
);
18580 salt_t
*salt
= hash_buf
->salt
;
18582 u32
*digest
= (u32
*) hash_buf
->digest
;
18586 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18587 | itoa64_to_int (input_buf
[2]) << 6
18588 | itoa64_to_int (input_buf
[3]) << 12
18589 | itoa64_to_int (input_buf
[4]) << 18;
18593 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18594 | itoa64_to_int (input_buf
[6]) << 6
18595 | itoa64_to_int (input_buf
[7]) << 12
18596 | itoa64_to_int (input_buf
[8]) << 18;
18598 salt
->salt_len
= 4;
18602 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18604 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18606 memcpy (digest
, tmp_buf
, 8);
18610 IP (digest
[0], digest
[1], tt
);
18612 digest
[0] = rotr32 (digest
[0], 31);
18613 digest
[1] = rotr32 (digest
[1], 31);
18617 return (PARSER_OK
);
18620 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18622 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18624 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18626 u32
*digest
= (u32
*) hash_buf
->digest
;
18628 salt_t
*salt
= hash_buf
->salt
;
18634 char *type_pos
= input_buf
+ 6 + 1;
18636 char *salt_pos
= strchr (type_pos
, '*');
18638 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18640 u32 type_len
= salt_pos
- type_pos
;
18642 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18646 char *crypted_pos
= strchr (salt_pos
, '*');
18648 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18650 u32 salt_len
= crypted_pos
- salt_pos
;
18652 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18656 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18658 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18664 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18665 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18667 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18668 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18670 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18671 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18672 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18673 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18675 salt
->salt_len
= 24;
18676 salt
->salt_iter
= ROUNDS_RAR3
;
18678 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18679 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18681 digest
[0] = 0xc43d7b00;
18682 digest
[1] = 0x40070000;
18686 return (PARSER_OK
);
18689 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18691 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18693 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18695 u32
*digest
= (u32
*) hash_buf
->digest
;
18697 salt_t
*salt
= hash_buf
->salt
;
18699 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18705 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18707 char *param1_pos
= strchr (param0_pos
, '$');
18709 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18711 u32 param0_len
= param1_pos
- param0_pos
;
18715 char *param2_pos
= strchr (param1_pos
, '$');
18717 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18719 u32 param1_len
= param2_pos
- param1_pos
;
18723 char *param3_pos
= strchr (param2_pos
, '$');
18725 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18727 u32 param2_len
= param3_pos
- param2_pos
;
18731 char *param4_pos
= strchr (param3_pos
, '$');
18733 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18735 u32 param3_len
= param4_pos
- param3_pos
;
18739 char *param5_pos
= strchr (param4_pos
, '$');
18741 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18743 u32 param4_len
= param5_pos
- param4_pos
;
18747 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18749 char *salt_buf
= param1_pos
;
18750 char *iv
= param3_pos
;
18751 char *pswcheck
= param5_pos
;
18753 const uint salt_len
= atoi (param0_pos
);
18754 const uint iterations
= atoi (param2_pos
);
18755 const uint pswcheck_len
= atoi (param4_pos
);
18761 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18762 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18763 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18765 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18766 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18767 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18773 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18774 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18775 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18776 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18778 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18779 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18780 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18781 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18783 salt
->salt_len
= 16;
18785 salt
->salt_sign
[0] = iterations
;
18787 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18793 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18794 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18798 return (PARSER_OK
);
18801 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18803 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18805 u32
*digest
= (u32
*) hash_buf
->digest
;
18807 salt_t
*salt
= hash_buf
->salt
;
18809 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18810 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18811 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18812 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18813 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18814 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18815 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18816 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18818 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18820 uint salt_len
= input_len
- 64 - 1;
18822 char *salt_buf
= input_buf
+ 64 + 1;
18824 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18826 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18828 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18830 salt
->salt_len
= salt_len
;
18833 * we can precompute the first sha256 transform
18838 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18839 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18840 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18841 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18842 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18843 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18844 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18845 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18846 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18847 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18848 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18849 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18850 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18851 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18852 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18853 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18857 pc256
[0] = SHA256M_A
;
18858 pc256
[1] = SHA256M_B
;
18859 pc256
[2] = SHA256M_C
;
18860 pc256
[3] = SHA256M_D
;
18861 pc256
[4] = SHA256M_E
;
18862 pc256
[5] = SHA256M_F
;
18863 pc256
[6] = SHA256M_G
;
18864 pc256
[7] = SHA256M_H
;
18866 sha256_64 (w
, pc256
);
18868 salt
->salt_buf_pc
[0] = pc256
[0];
18869 salt
->salt_buf_pc
[1] = pc256
[1];
18870 salt
->salt_buf_pc
[2] = pc256
[2];
18871 salt
->salt_buf_pc
[3] = pc256
[3];
18872 salt
->salt_buf_pc
[4] = pc256
[4];
18873 salt
->salt_buf_pc
[5] = pc256
[5];
18874 salt
->salt_buf_pc
[6] = pc256
[6];
18875 salt
->salt_buf_pc
[7] = pc256
[7];
18877 digest
[0] -= pc256
[0];
18878 digest
[1] -= pc256
[1];
18879 digest
[2] -= pc256
[2];
18880 digest
[3] -= pc256
[3];
18881 digest
[4] -= pc256
[4];
18882 digest
[5] -= pc256
[5];
18883 digest
[6] -= pc256
[6];
18884 digest
[7] -= pc256
[7];
18886 return (PARSER_OK
);
18889 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18891 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18893 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18895 u32
*digest
= (u32
*) hash_buf
->digest
;
18897 salt_t
*salt
= hash_buf
->salt
;
18903 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18905 char *data_buf_pos
= strchr (data_len_pos
, '$');
18907 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18909 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18911 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18912 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18916 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18918 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18920 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18922 u32 data_len
= atoi (data_len_pos
);
18924 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18930 char *salt_pos
= data_buf_pos
;
18932 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18933 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18934 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
18935 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
18937 // this is actually the CT, which is also the hash later (if matched)
18939 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
18940 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
18941 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
18942 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
18944 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18946 salt
->salt_iter
= 10 - 1;
18952 digest
[0] = salt
->salt_buf
[4];
18953 digest
[1] = salt
->salt_buf
[5];
18954 digest
[2] = salt
->salt_buf
[6];
18955 digest
[3] = salt
->salt_buf
[7];
18957 return (PARSER_OK
);
18960 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18962 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18964 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18966 u32
*digest
= (u32
*) hash_buf
->digest
;
18968 salt_t
*salt
= hash_buf
->salt
;
18974 char *salt_pos
= input_buf
+ 11 + 1;
18976 char *iter_pos
= strchr (salt_pos
, ',');
18978 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18980 u32 salt_len
= iter_pos
- salt_pos
;
18982 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18986 char *hash_pos
= strchr (iter_pos
, ',');
18988 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18990 u32 iter_len
= hash_pos
- iter_pos
;
18992 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18996 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18998 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19004 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19005 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19006 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19007 salt
->salt_buf
[3] = 0x00018000;
19009 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19010 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19011 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19012 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19014 salt
->salt_len
= salt_len
/ 2;
19016 salt
->salt_iter
= atoi (iter_pos
) - 1;
19022 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19023 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19024 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19025 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19026 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19027 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19028 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19029 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19031 return (PARSER_OK
);
19034 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19036 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19038 u32
*digest
= (u32
*) hash_buf
->digest
;
19040 salt_t
*salt
= hash_buf
->salt
;
19046 char *hash_pos
= input_buf
+ 64;
19047 char *salt1_pos
= input_buf
+ 128;
19048 char *salt2_pos
= input_buf
;
19054 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19055 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19056 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19057 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19059 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19060 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19061 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19062 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19064 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19065 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19066 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19067 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19069 salt
->salt_len
= 48;
19071 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19077 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19078 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19079 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19080 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19081 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19082 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19083 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19084 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19086 return (PARSER_OK
);
19090 * parallel running threads
19095 BOOL WINAPI
sigHandler_default (DWORD sig
)
19099 case CTRL_CLOSE_EVENT
:
19102 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19103 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19104 * function otherwise it is too late (e.g. after returning from this function)
19109 SetConsoleCtrlHandler (NULL
, TRUE
);
19116 case CTRL_LOGOFF_EVENT
:
19117 case CTRL_SHUTDOWN_EVENT
:
19121 SetConsoleCtrlHandler (NULL
, TRUE
);
19129 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19133 case CTRL_CLOSE_EVENT
:
19137 SetConsoleCtrlHandler (NULL
, TRUE
);
19144 case CTRL_LOGOFF_EVENT
:
19145 case CTRL_SHUTDOWN_EVENT
:
19149 SetConsoleCtrlHandler (NULL
, TRUE
);
19157 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19159 if (callback
== NULL
)
19161 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19165 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19171 void sigHandler_default (int sig
)
19175 signal (sig
, NULL
);
19178 void sigHandler_benchmark (int sig
)
19182 signal (sig
, NULL
);
19185 void hc_signal (void (callback
) (int))
19187 if (callback
== NULL
) callback
= SIG_DFL
;
19189 signal (SIGINT
, callback
);
19190 signal (SIGTERM
, callback
);
19191 signal (SIGABRT
, callback
);
19196 void status_display ();
19198 void *thread_keypress (void *p
)
19200 int benchmark
= *((int *) p
);
19202 uint quiet
= data
.quiet
;
19206 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19208 int ch
= tty_getchar();
19210 if (ch
== -1) break;
19212 if (ch
== 0) continue;
19218 hc_thread_mutex_lock (mux_display
);
19233 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19234 if (quiet
== 0) fflush (stdout
);
19246 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19247 if (quiet
== 0) fflush (stdout
);
19259 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19260 if (quiet
== 0) fflush (stdout
);
19272 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19273 if (quiet
== 0) fflush (stdout
);
19281 if (benchmark
== 1) break;
19283 stop_at_checkpoint ();
19287 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19288 if (quiet
== 0) fflush (stdout
);
19296 if (benchmark
== 1)
19308 hc_thread_mutex_unlock (mux_display
);
19320 bool class_num (const u8 c
)
19322 return ((c
>= '0') && (c
<= '9'));
19325 bool class_lower (const u8 c
)
19327 return ((c
>= 'a') && (c
<= 'z'));
19330 bool class_upper (const u8 c
)
19332 return ((c
>= 'A') && (c
<= 'Z'));
19335 bool class_alpha (const u8 c
)
19337 return (class_lower (c
) || class_upper (c
));
19340 int conv_ctoi (const u8 c
)
19346 else if (class_upper (c
))
19348 return c
- 'A' + 10;
19354 int conv_itoc (const u8 c
)
19362 return c
+ 'A' - 10;
19372 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19373 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19374 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19375 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19376 #define MAX_KERNEL_RULES 255
19377 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19378 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19379 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19381 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19382 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19383 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19384 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19386 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19391 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19393 switch (rule_buf
[rule_pos
])
19399 case RULE_OP_MANGLE_NOOP
:
19400 SET_NAME (rule
, rule_buf
[rule_pos
]);
19403 case RULE_OP_MANGLE_LREST
:
19404 SET_NAME (rule
, rule_buf
[rule_pos
]);
19407 case RULE_OP_MANGLE_UREST
:
19408 SET_NAME (rule
, rule_buf
[rule_pos
]);
19411 case RULE_OP_MANGLE_LREST_UFIRST
:
19412 SET_NAME (rule
, rule_buf
[rule_pos
]);
19415 case RULE_OP_MANGLE_UREST_LFIRST
:
19416 SET_NAME (rule
, rule_buf
[rule_pos
]);
19419 case RULE_OP_MANGLE_TREST
:
19420 SET_NAME (rule
, rule_buf
[rule_pos
]);
19423 case RULE_OP_MANGLE_TOGGLE_AT
:
19424 SET_NAME (rule
, rule_buf
[rule_pos
]);
19425 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19428 case RULE_OP_MANGLE_REVERSE
:
19429 SET_NAME (rule
, rule_buf
[rule_pos
]);
19432 case RULE_OP_MANGLE_DUPEWORD
:
19433 SET_NAME (rule
, rule_buf
[rule_pos
]);
19436 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19437 SET_NAME (rule
, rule_buf
[rule_pos
]);
19438 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19441 case RULE_OP_MANGLE_REFLECT
:
19442 SET_NAME (rule
, rule_buf
[rule_pos
]);
19445 case RULE_OP_MANGLE_ROTATE_LEFT
:
19446 SET_NAME (rule
, rule_buf
[rule_pos
]);
19449 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19450 SET_NAME (rule
, rule_buf
[rule_pos
]);
19453 case RULE_OP_MANGLE_APPEND
:
19454 SET_NAME (rule
, rule_buf
[rule_pos
]);
19455 SET_P0 (rule
, rule_buf
[rule_pos
]);
19458 case RULE_OP_MANGLE_PREPEND
:
19459 SET_NAME (rule
, rule_buf
[rule_pos
]);
19460 SET_P0 (rule
, rule_buf
[rule_pos
]);
19463 case RULE_OP_MANGLE_DELETE_FIRST
:
19464 SET_NAME (rule
, rule_buf
[rule_pos
]);
19467 case RULE_OP_MANGLE_DELETE_LAST
:
19468 SET_NAME (rule
, rule_buf
[rule_pos
]);
19471 case RULE_OP_MANGLE_DELETE_AT
:
19472 SET_NAME (rule
, rule_buf
[rule_pos
]);
19473 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19476 case RULE_OP_MANGLE_EXTRACT
:
19477 SET_NAME (rule
, rule_buf
[rule_pos
]);
19478 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19479 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19482 case RULE_OP_MANGLE_OMIT
:
19483 SET_NAME (rule
, rule_buf
[rule_pos
]);
19484 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19485 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19488 case RULE_OP_MANGLE_INSERT
:
19489 SET_NAME (rule
, rule_buf
[rule_pos
]);
19490 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19491 SET_P1 (rule
, rule_buf
[rule_pos
]);
19494 case RULE_OP_MANGLE_OVERSTRIKE
:
19495 SET_NAME (rule
, rule_buf
[rule_pos
]);
19496 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19497 SET_P1 (rule
, rule_buf
[rule_pos
]);
19500 case RULE_OP_MANGLE_TRUNCATE_AT
:
19501 SET_NAME (rule
, rule_buf
[rule_pos
]);
19502 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19505 case RULE_OP_MANGLE_REPLACE
:
19506 SET_NAME (rule
, rule_buf
[rule_pos
]);
19507 SET_P0 (rule
, rule_buf
[rule_pos
]);
19508 SET_P1 (rule
, rule_buf
[rule_pos
]);
19511 case RULE_OP_MANGLE_PURGECHAR
:
19515 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19519 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19520 SET_NAME (rule
, rule_buf
[rule_pos
]);
19521 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19524 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19525 SET_NAME (rule
, rule_buf
[rule_pos
]);
19526 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19529 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19530 SET_NAME (rule
, rule_buf
[rule_pos
]);
19533 case RULE_OP_MANGLE_SWITCH_FIRST
:
19534 SET_NAME (rule
, rule_buf
[rule_pos
]);
19537 case RULE_OP_MANGLE_SWITCH_LAST
:
19538 SET_NAME (rule
, rule_buf
[rule_pos
]);
19541 case RULE_OP_MANGLE_SWITCH_AT
:
19542 SET_NAME (rule
, rule_buf
[rule_pos
]);
19543 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19544 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19547 case RULE_OP_MANGLE_CHR_SHIFTL
:
19548 SET_NAME (rule
, rule_buf
[rule_pos
]);
19549 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19552 case RULE_OP_MANGLE_CHR_SHIFTR
:
19553 SET_NAME (rule
, rule_buf
[rule_pos
]);
19554 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19557 case RULE_OP_MANGLE_CHR_INCR
:
19558 SET_NAME (rule
, rule_buf
[rule_pos
]);
19559 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19562 case RULE_OP_MANGLE_CHR_DECR
:
19563 SET_NAME (rule
, rule_buf
[rule_pos
]);
19564 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19567 case RULE_OP_MANGLE_REPLACE_NP1
:
19568 SET_NAME (rule
, rule_buf
[rule_pos
]);
19569 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19572 case RULE_OP_MANGLE_REPLACE_NM1
:
19573 SET_NAME (rule
, rule_buf
[rule_pos
]);
19574 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19577 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19578 SET_NAME (rule
, rule_buf
[rule_pos
]);
19579 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19582 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19583 SET_NAME (rule
, rule_buf
[rule_pos
]);
19584 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19587 case RULE_OP_MANGLE_TITLE
:
19588 SET_NAME (rule
, rule_buf
[rule_pos
]);
19597 if (rule_pos
< rule_len
) return (-1);
19602 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19606 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19610 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19614 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19618 case RULE_OP_MANGLE_NOOP
:
19619 rule_buf
[rule_pos
] = rule_cmd
;
19622 case RULE_OP_MANGLE_LREST
:
19623 rule_buf
[rule_pos
] = rule_cmd
;
19626 case RULE_OP_MANGLE_UREST
:
19627 rule_buf
[rule_pos
] = rule_cmd
;
19630 case RULE_OP_MANGLE_LREST_UFIRST
:
19631 rule_buf
[rule_pos
] = rule_cmd
;
19634 case RULE_OP_MANGLE_UREST_LFIRST
:
19635 rule_buf
[rule_pos
] = rule_cmd
;
19638 case RULE_OP_MANGLE_TREST
:
19639 rule_buf
[rule_pos
] = rule_cmd
;
19642 case RULE_OP_MANGLE_TOGGLE_AT
:
19643 rule_buf
[rule_pos
] = rule_cmd
;
19644 GET_P0_CONV (rule
);
19647 case RULE_OP_MANGLE_REVERSE
:
19648 rule_buf
[rule_pos
] = rule_cmd
;
19651 case RULE_OP_MANGLE_DUPEWORD
:
19652 rule_buf
[rule_pos
] = rule_cmd
;
19655 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19656 rule_buf
[rule_pos
] = rule_cmd
;
19657 GET_P0_CONV (rule
);
19660 case RULE_OP_MANGLE_REFLECT
:
19661 rule_buf
[rule_pos
] = rule_cmd
;
19664 case RULE_OP_MANGLE_ROTATE_LEFT
:
19665 rule_buf
[rule_pos
] = rule_cmd
;
19668 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19669 rule_buf
[rule_pos
] = rule_cmd
;
19672 case RULE_OP_MANGLE_APPEND
:
19673 rule_buf
[rule_pos
] = rule_cmd
;
19677 case RULE_OP_MANGLE_PREPEND
:
19678 rule_buf
[rule_pos
] = rule_cmd
;
19682 case RULE_OP_MANGLE_DELETE_FIRST
:
19683 rule_buf
[rule_pos
] = rule_cmd
;
19686 case RULE_OP_MANGLE_DELETE_LAST
:
19687 rule_buf
[rule_pos
] = rule_cmd
;
19690 case RULE_OP_MANGLE_DELETE_AT
:
19691 rule_buf
[rule_pos
] = rule_cmd
;
19692 GET_P0_CONV (rule
);
19695 case RULE_OP_MANGLE_EXTRACT
:
19696 rule_buf
[rule_pos
] = rule_cmd
;
19697 GET_P0_CONV (rule
);
19698 GET_P1_CONV (rule
);
19701 case RULE_OP_MANGLE_OMIT
:
19702 rule_buf
[rule_pos
] = rule_cmd
;
19703 GET_P0_CONV (rule
);
19704 GET_P1_CONV (rule
);
19707 case RULE_OP_MANGLE_INSERT
:
19708 rule_buf
[rule_pos
] = rule_cmd
;
19709 GET_P0_CONV (rule
);
19713 case RULE_OP_MANGLE_OVERSTRIKE
:
19714 rule_buf
[rule_pos
] = rule_cmd
;
19715 GET_P0_CONV (rule
);
19719 case RULE_OP_MANGLE_TRUNCATE_AT
:
19720 rule_buf
[rule_pos
] = rule_cmd
;
19721 GET_P0_CONV (rule
);
19724 case RULE_OP_MANGLE_REPLACE
:
19725 rule_buf
[rule_pos
] = rule_cmd
;
19730 case RULE_OP_MANGLE_PURGECHAR
:
19734 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19738 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19739 rule_buf
[rule_pos
] = rule_cmd
;
19740 GET_P0_CONV (rule
);
19743 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19744 rule_buf
[rule_pos
] = rule_cmd
;
19745 GET_P0_CONV (rule
);
19748 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19749 rule_buf
[rule_pos
] = rule_cmd
;
19752 case RULE_OP_MANGLE_SWITCH_FIRST
:
19753 rule_buf
[rule_pos
] = rule_cmd
;
19756 case RULE_OP_MANGLE_SWITCH_LAST
:
19757 rule_buf
[rule_pos
] = rule_cmd
;
19760 case RULE_OP_MANGLE_SWITCH_AT
:
19761 rule_buf
[rule_pos
] = rule_cmd
;
19762 GET_P0_CONV (rule
);
19763 GET_P1_CONV (rule
);
19766 case RULE_OP_MANGLE_CHR_SHIFTL
:
19767 rule_buf
[rule_pos
] = rule_cmd
;
19768 GET_P0_CONV (rule
);
19771 case RULE_OP_MANGLE_CHR_SHIFTR
:
19772 rule_buf
[rule_pos
] = rule_cmd
;
19773 GET_P0_CONV (rule
);
19776 case RULE_OP_MANGLE_CHR_INCR
:
19777 rule_buf
[rule_pos
] = rule_cmd
;
19778 GET_P0_CONV (rule
);
19781 case RULE_OP_MANGLE_CHR_DECR
:
19782 rule_buf
[rule_pos
] = rule_cmd
;
19783 GET_P0_CONV (rule
);
19786 case RULE_OP_MANGLE_REPLACE_NP1
:
19787 rule_buf
[rule_pos
] = rule_cmd
;
19788 GET_P0_CONV (rule
);
19791 case RULE_OP_MANGLE_REPLACE_NM1
:
19792 rule_buf
[rule_pos
] = rule_cmd
;
19793 GET_P0_CONV (rule
);
19796 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19797 rule_buf
[rule_pos
] = rule_cmd
;
19798 GET_P0_CONV (rule
);
19801 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19802 rule_buf
[rule_pos
] = rule_cmd
;
19803 GET_P0_CONV (rule
);
19806 case RULE_OP_MANGLE_TITLE
:
19807 rule_buf
[rule_pos
] = rule_cmd
;
19811 return rule_pos
- 1;
19829 * CPU rules : this is from hashcat sources, cpu based rules
19832 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19833 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19835 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19836 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19837 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19839 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19840 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19841 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19843 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19847 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19852 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19856 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19861 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19865 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19870 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19875 for (l
= 0; l
< arr_len
; l
++)
19877 r
= arr_len
- 1 - l
;
19881 MANGLE_SWITCH (arr
, l
, r
);
19887 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19889 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19891 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19893 return (arr_len
* 2);
19896 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19898 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19900 int orig_len
= arr_len
;
19904 for (i
= 0; i
< times
; i
++)
19906 memcpy (&arr
[arr_len
], arr
, orig_len
);
19908 arr_len
+= orig_len
;
19914 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19916 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19918 mangle_double (arr
, arr_len
);
19920 mangle_reverse (arr
+ arr_len
, arr_len
);
19922 return (arr_len
* 2);
19925 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19930 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19932 MANGLE_SWITCH (arr
, l
, r
);
19938 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19943 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19945 MANGLE_SWITCH (arr
, l
, r
);
19951 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19953 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19957 return (arr_len
+ 1);
19960 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19962 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19966 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19968 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19973 return (arr_len
+ 1);
19976 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19978 if (upos
>= arr_len
) return (arr_len
);
19982 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19984 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19987 return (arr_len
- 1);
19990 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19992 if (upos
>= arr_len
) return (arr_len
);
19994 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19998 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20000 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20006 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20008 if (upos
>= arr_len
) return (arr_len
);
20010 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20014 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20016 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20019 return (arr_len
- ulen
);
20022 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20024 if (upos
>= arr_len
) return (arr_len
);
20026 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20030 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20032 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20037 return (arr_len
+ 1);
20040 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
)
20042 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20044 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20046 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20048 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20050 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20052 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20054 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20056 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20058 return (arr_len
+ arr2_cpy
);
20061 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20063 if (upos
>= arr_len
) return (arr_len
);
20070 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20072 if (upos
>= arr_len
) return (arr_len
);
20074 memset (arr
+ upos
, 0, arr_len
- upos
);
20079 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20083 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20085 if (arr
[arr_pos
] != oldc
) continue;
20087 arr
[arr_pos
] = newc
;
20093 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20099 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20101 if (arr
[arr_pos
] == c
) continue;
20103 arr
[ret_len
] = arr
[arr_pos
];
20111 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20113 if (ulen
> arr_len
) return (arr_len
);
20115 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20119 memcpy (cs
, arr
, ulen
);
20123 for (i
= 0; i
< ulen
; i
++)
20127 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20133 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20135 if (ulen
> arr_len
) return (arr_len
);
20137 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20139 int upos
= arr_len
- ulen
;
20143 for (i
= 0; i
< ulen
; i
++)
20145 char c
= arr
[upos
+ i
];
20147 arr_len
= mangle_append (arr
, arr_len
, c
);
20153 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20155 if ( arr_len
== 0) return (arr_len
);
20156 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20158 char c
= arr
[upos
];
20162 for (i
= 0; i
< ulen
; i
++)
20164 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20170 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20172 if ( arr_len
== 0) return (arr_len
);
20173 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20177 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20179 int new_pos
= arr_pos
* 2;
20181 arr
[new_pos
] = arr
[arr_pos
];
20183 arr
[new_pos
+ 1] = arr
[arr_pos
];
20186 return (arr_len
* 2);
20189 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20191 if (upos
>= arr_len
) return (arr_len
);
20192 if (upos2
>= arr_len
) return (arr_len
);
20194 MANGLE_SWITCH (arr
, upos
, upos2
);
20199 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20201 MANGLE_SWITCH (arr
, upos
, upos2
);
20206 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20208 if (upos
>= arr_len
) return (arr_len
);
20215 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20217 if (upos
>= arr_len
) return (arr_len
);
20224 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20226 if (upos
>= arr_len
) return (arr_len
);
20233 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20235 if (upos
>= arr_len
) return (arr_len
);
20242 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20244 int upper_next
= 1;
20248 for (pos
= 0; pos
< arr_len
; pos
++)
20250 if (arr
[pos
] == ' ')
20261 MANGLE_UPPER_AT (arr
, pos
);
20265 MANGLE_LOWER_AT (arr
, pos
);
20272 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20274 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20280 for (j
= 0; j
< rp_gen_num
; j
++)
20287 switch ((char) get_random_num (0, 9))
20290 r
= get_random_num (0, sizeof (grp_op_nop
));
20291 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20295 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20296 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20297 p1
= get_random_num (0, sizeof (grp_pos
));
20298 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20302 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20303 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20304 p1
= get_random_num (1, 6);
20305 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20309 r
= get_random_num (0, sizeof (grp_op_chr
));
20310 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20311 p1
= get_random_num (0x20, 0x7e);
20312 rule_buf
[rule_pos
++] = (char) p1
;
20316 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20317 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20318 p1
= get_random_num (0x20, 0x7e);
20319 rule_buf
[rule_pos
++] = (char) p1
;
20320 p2
= get_random_num (0x20, 0x7e);
20322 p2
= get_random_num (0x20, 0x7e);
20323 rule_buf
[rule_pos
++] = (char) p2
;
20327 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20328 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20329 p1
= get_random_num (0, sizeof (grp_pos
));
20330 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20331 p2
= get_random_num (0x20, 0x7e);
20332 rule_buf
[rule_pos
++] = (char) p2
;
20336 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20337 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20338 p1
= get_random_num (0, sizeof (grp_pos
));
20339 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20340 p2
= get_random_num (0, sizeof (grp_pos
));
20342 p2
= get_random_num (0, sizeof (grp_pos
));
20343 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20347 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20348 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20349 p1
= get_random_num (0, sizeof (grp_pos
));
20350 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20351 p2
= get_random_num (1, sizeof (grp_pos
));
20353 p2
= get_random_num (1, sizeof (grp_pos
));
20354 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20358 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20359 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20360 p1
= get_random_num (0, sizeof (grp_pos
));
20361 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20362 p2
= get_random_num (1, sizeof (grp_pos
));
20363 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20364 p3
= get_random_num (0, sizeof (grp_pos
));
20365 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20373 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20375 char mem
[BLOCK_SIZE
];
20377 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20379 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20381 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
20383 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20385 int out_len
= in_len
;
20386 int mem_len
= in_len
;
20388 memcpy (out
, in
, out_len
);
20392 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20394 int upos
; int upos2
;
20397 switch (rule
[rule_pos
])
20402 case RULE_OP_MANGLE_NOOP
:
20405 case RULE_OP_MANGLE_LREST
:
20406 out_len
= mangle_lrest (out
, out_len
);
20409 case RULE_OP_MANGLE_UREST
:
20410 out_len
= mangle_urest (out
, out_len
);
20413 case RULE_OP_MANGLE_LREST_UFIRST
:
20414 out_len
= mangle_lrest (out
, out_len
);
20415 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20418 case RULE_OP_MANGLE_UREST_LFIRST
:
20419 out_len
= mangle_urest (out
, out_len
);
20420 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20423 case RULE_OP_MANGLE_TREST
:
20424 out_len
= mangle_trest (out
, out_len
);
20427 case RULE_OP_MANGLE_TOGGLE_AT
:
20428 NEXT_RULEPOS (rule_pos
);
20429 NEXT_RPTOI (rule
, rule_pos
, upos
);
20430 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20433 case RULE_OP_MANGLE_REVERSE
:
20434 out_len
= mangle_reverse (out
, out_len
);
20437 case RULE_OP_MANGLE_DUPEWORD
:
20438 out_len
= mangle_double (out
, out_len
);
20441 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20442 NEXT_RULEPOS (rule_pos
);
20443 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20444 out_len
= mangle_double_times (out
, out_len
, ulen
);
20447 case RULE_OP_MANGLE_REFLECT
:
20448 out_len
= mangle_reflect (out
, out_len
);
20451 case RULE_OP_MANGLE_ROTATE_LEFT
:
20452 mangle_rotate_left (out
, out_len
);
20455 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20456 mangle_rotate_right (out
, out_len
);
20459 case RULE_OP_MANGLE_APPEND
:
20460 NEXT_RULEPOS (rule_pos
);
20461 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20464 case RULE_OP_MANGLE_PREPEND
:
20465 NEXT_RULEPOS (rule_pos
);
20466 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20469 case RULE_OP_MANGLE_DELETE_FIRST
:
20470 out_len
= mangle_delete_at (out
, out_len
, 0);
20473 case RULE_OP_MANGLE_DELETE_LAST
:
20474 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20477 case RULE_OP_MANGLE_DELETE_AT
:
20478 NEXT_RULEPOS (rule_pos
);
20479 NEXT_RPTOI (rule
, rule_pos
, upos
);
20480 out_len
= mangle_delete_at (out
, out_len
, upos
);
20483 case RULE_OP_MANGLE_EXTRACT
:
20484 NEXT_RULEPOS (rule_pos
);
20485 NEXT_RPTOI (rule
, rule_pos
, upos
);
20486 NEXT_RULEPOS (rule_pos
);
20487 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20488 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20491 case RULE_OP_MANGLE_OMIT
:
20492 NEXT_RULEPOS (rule_pos
);
20493 NEXT_RPTOI (rule
, rule_pos
, upos
);
20494 NEXT_RULEPOS (rule_pos
);
20495 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20496 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20499 case RULE_OP_MANGLE_INSERT
:
20500 NEXT_RULEPOS (rule_pos
);
20501 NEXT_RPTOI (rule
, rule_pos
, upos
);
20502 NEXT_RULEPOS (rule_pos
);
20503 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20506 case RULE_OP_MANGLE_OVERSTRIKE
:
20507 NEXT_RULEPOS (rule_pos
);
20508 NEXT_RPTOI (rule
, rule_pos
, upos
);
20509 NEXT_RULEPOS (rule_pos
);
20510 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20513 case RULE_OP_MANGLE_TRUNCATE_AT
:
20514 NEXT_RULEPOS (rule_pos
);
20515 NEXT_RPTOI (rule
, rule_pos
, upos
);
20516 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20519 case RULE_OP_MANGLE_REPLACE
:
20520 NEXT_RULEPOS (rule_pos
);
20521 NEXT_RULEPOS (rule_pos
);
20522 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20525 case RULE_OP_MANGLE_PURGECHAR
:
20526 NEXT_RULEPOS (rule_pos
);
20527 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20530 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20534 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20535 NEXT_RULEPOS (rule_pos
);
20536 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20537 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20540 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20541 NEXT_RULEPOS (rule_pos
);
20542 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20543 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20546 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20547 out_len
= mangle_dupechar (out
, out_len
);
20550 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20551 NEXT_RULEPOS (rule_pos
);
20552 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20553 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20556 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20557 NEXT_RULEPOS (rule_pos
);
20558 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20559 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20562 case RULE_OP_MANGLE_SWITCH_FIRST
:
20563 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20566 case RULE_OP_MANGLE_SWITCH_LAST
:
20567 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20570 case RULE_OP_MANGLE_SWITCH_AT
:
20571 NEXT_RULEPOS (rule_pos
);
20572 NEXT_RPTOI (rule
, rule_pos
, upos
);
20573 NEXT_RULEPOS (rule_pos
);
20574 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20575 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20578 case RULE_OP_MANGLE_CHR_SHIFTL
:
20579 NEXT_RULEPOS (rule_pos
);
20580 NEXT_RPTOI (rule
, rule_pos
, upos
);
20581 mangle_chr_shiftl (out
, out_len
, upos
);
20584 case RULE_OP_MANGLE_CHR_SHIFTR
:
20585 NEXT_RULEPOS (rule_pos
);
20586 NEXT_RPTOI (rule
, rule_pos
, upos
);
20587 mangle_chr_shiftr (out
, out_len
, upos
);
20590 case RULE_OP_MANGLE_CHR_INCR
:
20591 NEXT_RULEPOS (rule_pos
);
20592 NEXT_RPTOI (rule
, rule_pos
, upos
);
20593 mangle_chr_incr (out
, out_len
, upos
);
20596 case RULE_OP_MANGLE_CHR_DECR
:
20597 NEXT_RULEPOS (rule_pos
);
20598 NEXT_RPTOI (rule
, rule_pos
, upos
);
20599 mangle_chr_decr (out
, out_len
, upos
);
20602 case RULE_OP_MANGLE_REPLACE_NP1
:
20603 NEXT_RULEPOS (rule_pos
);
20604 NEXT_RPTOI (rule
, rule_pos
, upos
);
20605 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20608 case RULE_OP_MANGLE_REPLACE_NM1
:
20609 NEXT_RULEPOS (rule_pos
);
20610 NEXT_RPTOI (rule
, rule_pos
, upos
);
20611 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20614 case RULE_OP_MANGLE_TITLE
:
20615 out_len
= mangle_title (out
, out_len
);
20618 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20619 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20620 NEXT_RULEPOS (rule_pos
);
20621 NEXT_RPTOI (rule
, rule_pos
, upos
);
20622 NEXT_RULEPOS (rule_pos
);
20623 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20624 NEXT_RULEPOS (rule_pos
);
20625 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20626 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20629 case RULE_OP_MANGLE_APPEND_MEMORY
:
20630 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20631 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20632 memcpy (out
+ out_len
, mem
, mem_len
);
20633 out_len
+= mem_len
;
20636 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20637 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20638 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20639 memcpy (mem
+ mem_len
, out
, out_len
);
20640 out_len
+= mem_len
;
20641 memcpy (out
, mem
, out_len
);
20644 case RULE_OP_MEMORIZE_WORD
:
20645 memcpy (mem
, out
, out_len
);
20649 case RULE_OP_REJECT_LESS
:
20650 NEXT_RULEPOS (rule_pos
);
20651 NEXT_RPTOI (rule
, rule_pos
, upos
);
20652 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20655 case RULE_OP_REJECT_GREATER
:
20656 NEXT_RULEPOS (rule_pos
);
20657 NEXT_RPTOI (rule
, rule_pos
, upos
);
20658 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20661 case RULE_OP_REJECT_CONTAIN
:
20662 NEXT_RULEPOS (rule_pos
);
20663 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20666 case RULE_OP_REJECT_NOT_CONTAIN
:
20667 NEXT_RULEPOS (rule_pos
);
20668 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20671 case RULE_OP_REJECT_EQUAL_FIRST
:
20672 NEXT_RULEPOS (rule_pos
);
20673 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20676 case RULE_OP_REJECT_EQUAL_LAST
:
20677 NEXT_RULEPOS (rule_pos
);
20678 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20681 case RULE_OP_REJECT_EQUAL_AT
:
20682 NEXT_RULEPOS (rule_pos
);
20683 NEXT_RPTOI (rule
, rule_pos
, upos
);
20684 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20685 NEXT_RULEPOS (rule_pos
);
20686 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20689 case RULE_OP_REJECT_CONTAINS
:
20690 NEXT_RULEPOS (rule_pos
);
20691 NEXT_RPTOI (rule
, rule_pos
, upos
);
20692 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20693 NEXT_RULEPOS (rule_pos
);
20694 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20695 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20698 case RULE_OP_REJECT_MEMORY
:
20699 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20703 return (RULE_RC_SYNTAX_ERROR
);
20708 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);