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
[user_len
+ 33];
5113 memset (hash_output
, 0, sizeof (hash_output
));
5115 memcpy (hash_output
, input_buf
, input_len
);
5117 if (pot_left_ptr
!= NULL
)
5119 // only show right part (because left part was already found)
5121 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5123 hash_output
[user_len
+ 16] = 0;
5126 if (pot_right_ptr
!= NULL
)
5128 // only show left part (because right part was already found)
5130 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5132 hash_output
[user_len
+ 16] = 0;
5135 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
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
));
10103 u32 salt
[5]; // unused, but makes better valid check
10104 u32 iv
[2]; // unused, but makes better valid check
10110 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10114 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10116 salt
->salt_buf
[0] = buf
.random
[0];
10117 salt
->salt_buf
[1] = buf
.random
[1];
10119 salt
->salt_len
= 8;
10120 salt
->salt_iter
= 1000;
10122 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10123 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10124 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10125 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10126 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10128 return (PARSER_OK
);
10131 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10133 u32
*digest
= (u32
*) hash_buf
->digest
;
10135 salt_t
*salt
= hash_buf
->salt
;
10137 if (input_len
== 0)
10139 log_error (".psafe3 not specified");
10144 FILE *fp
= fopen (input_buf
, "rb");
10148 log_error ("%s: %s", input_buf
, strerror (errno
));
10155 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10159 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10161 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10163 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10165 salt
->salt_iter
= in
.iterations
+ 1;
10167 salt
->salt_buf
[0] = in
.salt_buf
[0];
10168 salt
->salt_buf
[1] = in
.salt_buf
[1];
10169 salt
->salt_buf
[2] = in
.salt_buf
[2];
10170 salt
->salt_buf
[3] = in
.salt_buf
[3];
10171 salt
->salt_buf
[4] = in
.salt_buf
[4];
10172 salt
->salt_buf
[5] = in
.salt_buf
[5];
10173 salt
->salt_buf
[6] = in
.salt_buf
[6];
10174 salt
->salt_buf
[7] = in
.salt_buf
[7];
10176 salt
->salt_len
= 32;
10178 digest
[0] = in
.hash_buf
[0];
10179 digest
[1] = in
.hash_buf
[1];
10180 digest
[2] = in
.hash_buf
[2];
10181 digest
[3] = in
.hash_buf
[3];
10182 digest
[4] = in
.hash_buf
[4];
10183 digest
[5] = in
.hash_buf
[5];
10184 digest
[6] = in
.hash_buf
[6];
10185 digest
[7] = in
.hash_buf
[7];
10187 digest
[0] = byte_swap_32 (digest
[0]);
10188 digest
[1] = byte_swap_32 (digest
[1]);
10189 digest
[2] = byte_swap_32 (digest
[2]);
10190 digest
[3] = byte_swap_32 (digest
[3]);
10191 digest
[4] = byte_swap_32 (digest
[4]);
10192 digest
[5] = byte_swap_32 (digest
[5]);
10193 digest
[6] = byte_swap_32 (digest
[6]);
10194 digest
[7] = byte_swap_32 (digest
[7]);
10196 return (PARSER_OK
);
10199 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10201 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10203 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10205 u32
*digest
= (u32
*) hash_buf
->digest
;
10207 salt_t
*salt
= hash_buf
->salt
;
10209 char *iter_pos
= input_buf
+ 3;
10211 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10213 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10215 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10217 salt
->salt_iter
= salt_iter
;
10219 char *salt_pos
= iter_pos
+ 1;
10223 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10225 salt
->salt_len
= salt_len
;
10227 char *hash_pos
= salt_pos
+ salt_len
;
10229 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10231 return (PARSER_OK
);
10234 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10236 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10238 u32
*digest
= (u32
*) hash_buf
->digest
;
10240 salt_t
*salt
= hash_buf
->salt
;
10242 char *salt_pos
= input_buf
+ 3;
10244 uint iterations_len
= 0;
10246 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10250 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10252 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10253 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10257 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10261 iterations_len
+= 8;
10265 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10268 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10270 char *hash_pos
= strchr (salt_pos
, '$');
10272 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10274 uint salt_len
= hash_pos
- salt_pos
;
10276 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10278 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10280 salt
->salt_len
= salt_len
;
10284 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10286 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10288 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10290 return (PARSER_OK
);
10293 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10295 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10297 u32
*digest
= (u32
*) hash_buf
->digest
;
10299 salt_t
*salt
= hash_buf
->salt
;
10301 char *salt_pos
= input_buf
+ 6;
10303 uint iterations_len
= 0;
10305 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10309 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10311 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10312 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10316 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10320 iterations_len
+= 8;
10324 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10327 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10329 char *hash_pos
= strchr (salt_pos
, '$');
10331 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10333 uint salt_len
= hash_pos
- salt_pos
;
10335 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10337 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10339 salt
->salt_len
= salt_len
;
10343 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10345 return (PARSER_OK
);
10348 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10350 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10352 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10354 u32
*digest
= (u32
*) hash_buf
->digest
;
10356 salt_t
*salt
= hash_buf
->salt
;
10358 char *salt_pos
= input_buf
+ 14;
10360 char *hash_pos
= strchr (salt_pos
, '*');
10362 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10366 uint salt_len
= hash_pos
- salt_pos
- 1;
10368 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10370 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10372 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10374 salt
->salt_len
= salt_len
;
10378 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10380 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10382 memcpy (digest
, tmp_buf
, 20);
10384 digest
[0] = byte_swap_32 (digest
[0]);
10385 digest
[1] = byte_swap_32 (digest
[1]);
10386 digest
[2] = byte_swap_32 (digest
[2]);
10387 digest
[3] = byte_swap_32 (digest
[3]);
10388 digest
[4] = byte_swap_32 (digest
[4]);
10390 digest
[0] -= SHA1M_A
;
10391 digest
[1] -= SHA1M_B
;
10392 digest
[2] -= SHA1M_C
;
10393 digest
[3] -= SHA1M_D
;
10394 digest
[4] -= SHA1M_E
;
10396 return (PARSER_OK
);
10399 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10401 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10403 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10405 if (c12
& 3) return (PARSER_HASH_VALUE
);
10407 u32
*digest
= (u32
*) hash_buf
->digest
;
10409 salt_t
*salt
= hash_buf
->salt
;
10411 // for ascii_digest
10412 salt
->salt_sign
[0] = input_buf
[0];
10413 salt
->salt_sign
[1] = input_buf
[1];
10415 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10416 | itoa64_to_int (input_buf
[1]) << 6;
10418 salt
->salt_len
= 2;
10422 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10424 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10426 memcpy (digest
, tmp_buf
, 8);
10430 IP (digest
[0], digest
[1], tt
);
10435 return (PARSER_OK
);
10438 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10440 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10442 u32
*digest
= (u32
*) hash_buf
->digest
;
10444 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10445 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10446 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10447 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10449 digest
[0] = byte_swap_32 (digest
[0]);
10450 digest
[1] = byte_swap_32 (digest
[1]);
10451 digest
[2] = byte_swap_32 (digest
[2]);
10452 digest
[3] = byte_swap_32 (digest
[3]);
10454 digest
[0] -= MD4M_A
;
10455 digest
[1] -= MD4M_B
;
10456 digest
[2] -= MD4M_C
;
10457 digest
[3] -= MD4M_D
;
10459 return (PARSER_OK
);
10462 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10464 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10466 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10470 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10473 u32
*digest
= (u32
*) hash_buf
->digest
;
10475 salt_t
*salt
= hash_buf
->salt
;
10477 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10478 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10479 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10480 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10482 digest
[0] = byte_swap_32 (digest
[0]);
10483 digest
[1] = byte_swap_32 (digest
[1]);
10484 digest
[2] = byte_swap_32 (digest
[2]);
10485 digest
[3] = byte_swap_32 (digest
[3]);
10487 digest
[0] -= MD4M_A
;
10488 digest
[1] -= MD4M_B
;
10489 digest
[2] -= MD4M_C
;
10490 digest
[3] -= MD4M_D
;
10492 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10494 uint salt_len
= input_len
- 32 - 1;
10496 char *salt_buf
= input_buf
+ 32 + 1;
10498 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10500 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10502 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10504 salt
->salt_len
= salt_len
;
10506 return (PARSER_OK
);
10509 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10511 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10513 u32
*digest
= (u32
*) hash_buf
->digest
;
10515 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10516 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10517 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10518 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10520 digest
[0] = byte_swap_32 (digest
[0]);
10521 digest
[1] = byte_swap_32 (digest
[1]);
10522 digest
[2] = byte_swap_32 (digest
[2]);
10523 digest
[3] = byte_swap_32 (digest
[3]);
10525 digest
[0] -= MD5M_A
;
10526 digest
[1] -= MD5M_B
;
10527 digest
[2] -= MD5M_C
;
10528 digest
[3] -= MD5M_D
;
10530 return (PARSER_OK
);
10533 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10535 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10537 u32
*digest
= (u32
*) hash_buf
->digest
;
10539 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10540 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10544 digest
[0] = byte_swap_32 (digest
[0]);
10545 digest
[1] = byte_swap_32 (digest
[1]);
10547 return (PARSER_OK
);
10550 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10552 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10554 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10558 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10561 u32
*digest
= (u32
*) hash_buf
->digest
;
10563 salt_t
*salt
= hash_buf
->salt
;
10565 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10566 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10567 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10568 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10570 digest
[0] = byte_swap_32 (digest
[0]);
10571 digest
[1] = byte_swap_32 (digest
[1]);
10572 digest
[2] = byte_swap_32 (digest
[2]);
10573 digest
[3] = byte_swap_32 (digest
[3]);
10575 digest
[0] -= MD5M_A
;
10576 digest
[1] -= MD5M_B
;
10577 digest
[2] -= MD5M_C
;
10578 digest
[3] -= MD5M_D
;
10580 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10582 uint salt_len
= input_len
- 32 - 1;
10584 char *salt_buf
= input_buf
+ 32 + 1;
10586 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10588 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10590 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10592 salt
->salt_len
= salt_len
;
10594 return (PARSER_OK
);
10597 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10599 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10601 u32
*digest
= (u32
*) hash_buf
->digest
;
10603 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10604 | itoa64_to_int (input_buf
[ 1]) << 6
10605 | itoa64_to_int (input_buf
[ 2]) << 12
10606 | itoa64_to_int (input_buf
[ 3]) << 18;
10607 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10608 | itoa64_to_int (input_buf
[ 5]) << 6
10609 | itoa64_to_int (input_buf
[ 6]) << 12
10610 | itoa64_to_int (input_buf
[ 7]) << 18;
10611 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10612 | itoa64_to_int (input_buf
[ 9]) << 6
10613 | itoa64_to_int (input_buf
[10]) << 12
10614 | itoa64_to_int (input_buf
[11]) << 18;
10615 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10616 | itoa64_to_int (input_buf
[13]) << 6
10617 | itoa64_to_int (input_buf
[14]) << 12
10618 | itoa64_to_int (input_buf
[15]) << 18;
10620 digest
[0] -= MD5M_A
;
10621 digest
[1] -= MD5M_B
;
10622 digest
[2] -= MD5M_C
;
10623 digest
[3] -= MD5M_D
;
10625 digest
[0] &= 0x00ffffff;
10626 digest
[1] &= 0x00ffffff;
10627 digest
[2] &= 0x00ffffff;
10628 digest
[3] &= 0x00ffffff;
10630 return (PARSER_OK
);
10633 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10635 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10637 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10641 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10644 u32
*digest
= (u32
*) hash_buf
->digest
;
10646 salt_t
*salt
= hash_buf
->salt
;
10648 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10649 | itoa64_to_int (input_buf
[ 1]) << 6
10650 | itoa64_to_int (input_buf
[ 2]) << 12
10651 | itoa64_to_int (input_buf
[ 3]) << 18;
10652 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10653 | itoa64_to_int (input_buf
[ 5]) << 6
10654 | itoa64_to_int (input_buf
[ 6]) << 12
10655 | itoa64_to_int (input_buf
[ 7]) << 18;
10656 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10657 | itoa64_to_int (input_buf
[ 9]) << 6
10658 | itoa64_to_int (input_buf
[10]) << 12
10659 | itoa64_to_int (input_buf
[11]) << 18;
10660 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10661 | itoa64_to_int (input_buf
[13]) << 6
10662 | itoa64_to_int (input_buf
[14]) << 12
10663 | itoa64_to_int (input_buf
[15]) << 18;
10665 digest
[0] -= MD5M_A
;
10666 digest
[1] -= MD5M_B
;
10667 digest
[2] -= MD5M_C
;
10668 digest
[3] -= MD5M_D
;
10670 digest
[0] &= 0x00ffffff;
10671 digest
[1] &= 0x00ffffff;
10672 digest
[2] &= 0x00ffffff;
10673 digest
[3] &= 0x00ffffff;
10675 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10677 uint salt_len
= input_len
- 16 - 1;
10679 char *salt_buf
= input_buf
+ 16 + 1;
10681 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10683 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10685 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10687 salt
->salt_len
= salt_len
;
10689 return (PARSER_OK
);
10692 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10694 key
[0] = (nthash
[0] >> 0);
10695 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10696 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10697 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10698 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10699 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10700 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10701 key
[7] = (nthash
[6] << 1);
10713 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10715 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10717 u32
*digest
= (u32
*) hash_buf
->digest
;
10719 salt_t
*salt
= hash_buf
->salt
;
10721 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10727 char *user_pos
= input_buf
;
10729 char *unused_pos
= strchr (user_pos
, ':');
10731 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10733 uint user_len
= unused_pos
- user_pos
;
10735 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10739 char *domain_pos
= strchr (unused_pos
, ':');
10741 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10743 uint unused_len
= domain_pos
- unused_pos
;
10745 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10749 char *srvchall_pos
= strchr (domain_pos
, ':');
10751 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10753 uint domain_len
= srvchall_pos
- domain_pos
;
10755 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10759 char *hash_pos
= strchr (srvchall_pos
, ':');
10761 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10763 uint srvchall_len
= hash_pos
- srvchall_pos
;
10765 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10769 char *clichall_pos
= strchr (hash_pos
, ':');
10771 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10773 uint hash_len
= clichall_pos
- hash_pos
;
10775 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10779 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10781 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10784 * store some data for later use
10787 netntlm
->user_len
= user_len
* 2;
10788 netntlm
->domain_len
= domain_len
* 2;
10789 netntlm
->srvchall_len
= srvchall_len
/ 2;
10790 netntlm
->clichall_len
= clichall_len
/ 2;
10792 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10793 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10796 * handle username and domainname
10799 for (uint i
= 0; i
< user_len
; i
++)
10801 *userdomain_ptr
++ = user_pos
[i
];
10802 *userdomain_ptr
++ = 0;
10805 for (uint i
= 0; i
< domain_len
; i
++)
10807 *userdomain_ptr
++ = domain_pos
[i
];
10808 *userdomain_ptr
++ = 0;
10812 * handle server challenge encoding
10815 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10817 const char p0
= srvchall_pos
[i
+ 0];
10818 const char p1
= srvchall_pos
[i
+ 1];
10820 *chall_ptr
++ = hex_convert (p1
) << 0
10821 | hex_convert (p0
) << 4;
10825 * handle client challenge encoding
10828 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10830 const char p0
= clichall_pos
[i
+ 0];
10831 const char p1
= clichall_pos
[i
+ 1];
10833 *chall_ptr
++ = hex_convert (p1
) << 0
10834 | hex_convert (p0
) << 4;
10841 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10843 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10845 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10847 salt
->salt_len
= salt_len
;
10849 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10850 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10851 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10852 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10854 digest
[0] = byte_swap_32 (digest
[0]);
10855 digest
[1] = byte_swap_32 (digest
[1]);
10856 digest
[2] = byte_swap_32 (digest
[2]);
10857 digest
[3] = byte_swap_32 (digest
[3]);
10859 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10861 uint digest_tmp
[2];
10863 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10864 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10866 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10867 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10869 /* special case 2: ESS */
10871 if (srvchall_len
== 48)
10873 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10877 w
[ 0] = netntlm
->chall_buf
[6];
10878 w
[ 1] = netntlm
->chall_buf
[7];
10879 w
[ 2] = netntlm
->chall_buf
[0];
10880 w
[ 3] = netntlm
->chall_buf
[1];
10903 salt
->salt_buf
[0] = dgst
[0];
10904 salt
->salt_buf
[1] = dgst
[1];
10908 /* precompute netntlmv1 exploit start */
10910 for (uint i
= 0; i
< 0x10000; i
++)
10912 uint key_md4
[2] = { i
, 0 };
10913 uint key_des
[2] = { 0, 0 };
10915 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10920 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10922 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10924 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10926 if (data3
[0] != digest_tmp
[0]) continue;
10927 if (data3
[1] != digest_tmp
[1]) continue;
10929 salt
->salt_buf
[2] = i
;
10931 salt
->salt_len
= 24;
10936 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10937 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10939 /* precompute netntlmv1 exploit stop */
10943 IP (digest
[0], digest
[1], tt
);
10944 IP (digest
[2], digest
[3], tt
);
10946 digest
[0] = rotr32 (digest
[0], 29);
10947 digest
[1] = rotr32 (digest
[1], 29);
10948 digest
[2] = rotr32 (digest
[2], 29);
10949 digest
[3] = rotr32 (digest
[3], 29);
10951 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10953 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10954 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10956 return (PARSER_OK
);
10959 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10961 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10963 u32
*digest
= (u32
*) hash_buf
->digest
;
10965 salt_t
*salt
= hash_buf
->salt
;
10967 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10973 char *user_pos
= input_buf
;
10975 char *unused_pos
= strchr (user_pos
, ':');
10977 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10979 uint user_len
= unused_pos
- user_pos
;
10981 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10985 char *domain_pos
= strchr (unused_pos
, ':');
10987 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10989 uint unused_len
= domain_pos
- unused_pos
;
10991 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10995 char *srvchall_pos
= strchr (domain_pos
, ':');
10997 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10999 uint domain_len
= srvchall_pos
- domain_pos
;
11001 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11005 char *hash_pos
= strchr (srvchall_pos
, ':');
11007 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11009 uint srvchall_len
= hash_pos
- srvchall_pos
;
11011 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11015 char *clichall_pos
= strchr (hash_pos
, ':');
11017 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11019 uint hash_len
= clichall_pos
- hash_pos
;
11021 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11025 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11027 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11029 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11032 * store some data for later use
11035 netntlm
->user_len
= user_len
* 2;
11036 netntlm
->domain_len
= domain_len
* 2;
11037 netntlm
->srvchall_len
= srvchall_len
/ 2;
11038 netntlm
->clichall_len
= clichall_len
/ 2;
11040 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11041 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11044 * handle username and domainname
11047 for (uint i
= 0; i
< user_len
; i
++)
11049 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11050 *userdomain_ptr
++ = 0;
11053 for (uint i
= 0; i
< domain_len
; i
++)
11055 *userdomain_ptr
++ = domain_pos
[i
];
11056 *userdomain_ptr
++ = 0;
11059 *userdomain_ptr
++ = 0x80;
11062 * handle server challenge encoding
11065 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11067 const char p0
= srvchall_pos
[i
+ 0];
11068 const char p1
= srvchall_pos
[i
+ 1];
11070 *chall_ptr
++ = hex_convert (p1
) << 0
11071 | hex_convert (p0
) << 4;
11075 * handle client challenge encoding
11078 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11080 const char p0
= clichall_pos
[i
+ 0];
11081 const char p1
= clichall_pos
[i
+ 1];
11083 *chall_ptr
++ = hex_convert (p1
) << 0
11084 | hex_convert (p0
) << 4;
11087 *chall_ptr
++ = 0x80;
11090 * handle hash itself
11093 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11094 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11095 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11096 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11098 digest
[0] = byte_swap_32 (digest
[0]);
11099 digest
[1] = byte_swap_32 (digest
[1]);
11100 digest
[2] = byte_swap_32 (digest
[2]);
11101 digest
[3] = byte_swap_32 (digest
[3]);
11104 * reuse challange data as salt_buf, its the buffer that is most likely unique
11107 salt
->salt_buf
[0] = 0;
11108 salt
->salt_buf
[1] = 0;
11109 salt
->salt_buf
[2] = 0;
11110 salt
->salt_buf
[3] = 0;
11111 salt
->salt_buf
[4] = 0;
11112 salt
->salt_buf
[5] = 0;
11113 salt
->salt_buf
[6] = 0;
11114 salt
->salt_buf
[7] = 0;
11118 uptr
= (uint
*) netntlm
->userdomain_buf
;
11120 for (uint i
= 0; i
< 16; i
+= 16)
11122 md5_64 (uptr
, salt
->salt_buf
);
11125 uptr
= (uint
*) netntlm
->chall_buf
;
11127 for (uint i
= 0; i
< 256; i
+= 16)
11129 md5_64 (uptr
, salt
->salt_buf
);
11132 salt
->salt_len
= 16;
11134 return (PARSER_OK
);
11137 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11139 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11141 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11145 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11148 u32
*digest
= (u32
*) hash_buf
->digest
;
11150 salt_t
*salt
= hash_buf
->salt
;
11152 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11153 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11154 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11155 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11157 digest
[0] = byte_swap_32 (digest
[0]);
11158 digest
[1] = byte_swap_32 (digest
[1]);
11159 digest
[2] = byte_swap_32 (digest
[2]);
11160 digest
[3] = byte_swap_32 (digest
[3]);
11162 digest
[0] -= MD5M_A
;
11163 digest
[1] -= MD5M_B
;
11164 digest
[2] -= MD5M_C
;
11165 digest
[3] -= MD5M_D
;
11167 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11169 uint salt_len
= input_len
- 32 - 1;
11171 char *salt_buf
= input_buf
+ 32 + 1;
11173 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11175 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11177 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11179 salt
->salt_len
= salt_len
;
11181 return (PARSER_OK
);
11184 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11186 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11188 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11192 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11195 u32
*digest
= (u32
*) hash_buf
->digest
;
11197 salt_t
*salt
= hash_buf
->salt
;
11199 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11200 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11201 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11202 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11204 digest
[0] = byte_swap_32 (digest
[0]);
11205 digest
[1] = byte_swap_32 (digest
[1]);
11206 digest
[2] = byte_swap_32 (digest
[2]);
11207 digest
[3] = byte_swap_32 (digest
[3]);
11209 digest
[0] -= MD5M_A
;
11210 digest
[1] -= MD5M_B
;
11211 digest
[2] -= MD5M_C
;
11212 digest
[3] -= MD5M_D
;
11214 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11216 uint salt_len
= input_len
- 32 - 1;
11218 char *salt_buf
= input_buf
+ 32 + 1;
11220 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11222 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11224 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11226 salt
->salt_len
= salt_len
;
11228 return (PARSER_OK
);
11231 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11233 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11235 u32
*digest
= (u32
*) hash_buf
->digest
;
11237 salt_t
*salt
= hash_buf
->salt
;
11239 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11240 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11241 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11242 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11244 digest
[0] = byte_swap_32 (digest
[0]);
11245 digest
[1] = byte_swap_32 (digest
[1]);
11246 digest
[2] = byte_swap_32 (digest
[2]);
11247 digest
[3] = byte_swap_32 (digest
[3]);
11249 digest
[0] -= MD5M_A
;
11250 digest
[1] -= MD5M_B
;
11251 digest
[2] -= MD5M_C
;
11252 digest
[3] -= MD5M_D
;
11255 * This is a virtual salt. While the algorithm is basically not salted
11256 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11257 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11260 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11262 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11264 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11266 salt
->salt_len
= salt_len
;
11268 return (PARSER_OK
);
11271 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11273 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11275 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11279 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11282 u32
*digest
= (u32
*) hash_buf
->digest
;
11284 salt_t
*salt
= hash_buf
->salt
;
11286 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11287 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11288 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11289 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11291 digest
[0] = byte_swap_32 (digest
[0]);
11292 digest
[1] = byte_swap_32 (digest
[1]);
11293 digest
[2] = byte_swap_32 (digest
[2]);
11294 digest
[3] = byte_swap_32 (digest
[3]);
11296 digest
[0] -= MD5M_A
;
11297 digest
[1] -= MD5M_B
;
11298 digest
[2] -= MD5M_C
;
11299 digest
[3] -= MD5M_D
;
11301 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11303 uint salt_len
= input_len
- 32 - 1;
11305 char *salt_buf
= input_buf
+ 32 + 1;
11307 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11309 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11311 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11313 salt
->salt_len
= salt_len
;
11315 return (PARSER_OK
);
11318 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11320 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11322 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11326 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11329 u32
*digest
= (u32
*) hash_buf
->digest
;
11331 salt_t
*salt
= hash_buf
->salt
;
11333 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11334 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11335 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11336 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11338 digest
[0] = byte_swap_32 (digest
[0]);
11339 digest
[1] = byte_swap_32 (digest
[1]);
11340 digest
[2] = byte_swap_32 (digest
[2]);
11341 digest
[3] = byte_swap_32 (digest
[3]);
11343 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11345 uint salt_len
= input_len
- 32 - 1;
11347 char *salt_buf
= input_buf
+ 32 + 1;
11349 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11351 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11353 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11355 salt
->salt_len
= salt_len
;
11357 return (PARSER_OK
);
11360 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11362 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11364 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11368 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11371 u32
*digest
= (u32
*) hash_buf
->digest
;
11373 salt_t
*salt
= hash_buf
->salt
;
11375 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11376 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11377 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11378 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11380 digest
[0] = byte_swap_32 (digest
[0]);
11381 digest
[1] = byte_swap_32 (digest
[1]);
11382 digest
[2] = byte_swap_32 (digest
[2]);
11383 digest
[3] = byte_swap_32 (digest
[3]);
11385 digest
[0] -= MD4M_A
;
11386 digest
[1] -= MD4M_B
;
11387 digest
[2] -= MD4M_C
;
11388 digest
[3] -= MD4M_D
;
11390 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11392 uint salt_len
= input_len
- 32 - 1;
11394 char *salt_buf
= input_buf
+ 32 + 1;
11396 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11398 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11400 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11402 salt
->salt_len
= salt_len
;
11404 return (PARSER_OK
);
11407 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11409 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11411 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11415 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11418 u32
*digest
= (u32
*) hash_buf
->digest
;
11420 salt_t
*salt
= hash_buf
->salt
;
11422 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11423 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11424 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11425 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11427 digest
[0] = byte_swap_32 (digest
[0]);
11428 digest
[1] = byte_swap_32 (digest
[1]);
11429 digest
[2] = byte_swap_32 (digest
[2]);
11430 digest
[3] = byte_swap_32 (digest
[3]);
11432 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11434 uint salt_len
= input_len
- 32 - 1;
11436 char *salt_buf
= input_buf
+ 32 + 1;
11438 uint salt_pc_block
[16];
11440 memset (salt_pc_block
, 0, sizeof (salt_pc_block
));
11442 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11444 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11446 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11448 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11450 salt_pc_block
[14] = salt_len
* 8;
11452 uint salt_pc_digest
[4];
11454 salt_pc_digest
[0] = MAGIC_A
;
11455 salt_pc_digest
[1] = MAGIC_B
;
11456 salt_pc_digest
[2] = MAGIC_C
;
11457 salt_pc_digest
[3] = MAGIC_D
;
11459 md5_64 (salt_pc_block
, salt_pc_digest
);
11461 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11462 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11463 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11464 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11466 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11468 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11470 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11472 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11473 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11474 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11475 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11477 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11479 return (PARSER_OK
);
11482 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11484 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11486 u32
*digest
= (u32
*) hash_buf
->digest
;
11488 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11489 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11490 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11491 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11492 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11494 digest
[0] -= SHA1M_A
;
11495 digest
[1] -= SHA1M_B
;
11496 digest
[2] -= SHA1M_C
;
11497 digest
[3] -= SHA1M_D
;
11498 digest
[4] -= SHA1M_E
;
11500 return (PARSER_OK
);
11503 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11505 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11507 u32
*digest
= (u32
*) hash_buf
->digest
;
11509 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11510 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11511 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11512 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11513 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11515 return (PARSER_OK
);
11518 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11520 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11522 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11526 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11529 u32
*digest
= (u32
*) hash_buf
->digest
;
11531 salt_t
*salt
= hash_buf
->salt
;
11533 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11534 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11535 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11536 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11537 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11539 digest
[0] -= SHA1M_A
;
11540 digest
[1] -= SHA1M_B
;
11541 digest
[2] -= SHA1M_C
;
11542 digest
[3] -= SHA1M_D
;
11543 digest
[4] -= SHA1M_E
;
11545 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11547 uint salt_len
= input_len
- 40 - 1;
11549 char *salt_buf
= input_buf
+ 40 + 1;
11551 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11553 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11555 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11557 salt
->salt_len
= salt_len
;
11559 return (PARSER_OK
);
11562 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11564 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11566 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11568 u32
*digest
= (u32
*) hash_buf
->digest
;
11572 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11574 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11576 memcpy (digest
, tmp_buf
, 20);
11578 digest
[0] = byte_swap_32 (digest
[0]);
11579 digest
[1] = byte_swap_32 (digest
[1]);
11580 digest
[2] = byte_swap_32 (digest
[2]);
11581 digest
[3] = byte_swap_32 (digest
[3]);
11582 digest
[4] = byte_swap_32 (digest
[4]);
11584 digest
[0] -= SHA1M_A
;
11585 digest
[1] -= SHA1M_B
;
11586 digest
[2] -= SHA1M_C
;
11587 digest
[3] -= SHA1M_D
;
11588 digest
[4] -= SHA1M_E
;
11590 return (PARSER_OK
);
11593 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11595 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11597 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11599 u32
*digest
= (u32
*) hash_buf
->digest
;
11601 salt_t
*salt
= hash_buf
->salt
;
11605 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11607 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11609 memcpy (digest
, tmp_buf
, 20);
11611 salt
->salt_len
= tmp_len
- 20;
11613 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11615 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11617 char *ptr
= (char *) salt
->salt_buf
;
11619 ptr
[salt
->salt_len
] = 0x80;
11622 digest
[0] = byte_swap_32 (digest
[0]);
11623 digest
[1] = byte_swap_32 (digest
[1]);
11624 digest
[2] = byte_swap_32 (digest
[2]);
11625 digest
[3] = byte_swap_32 (digest
[3]);
11626 digest
[4] = byte_swap_32 (digest
[4]);
11628 digest
[0] -= SHA1M_A
;
11629 digest
[1] -= SHA1M_B
;
11630 digest
[2] -= SHA1M_C
;
11631 digest
[3] -= SHA1M_D
;
11632 digest
[4] -= SHA1M_E
;
11634 return (PARSER_OK
);
11637 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11639 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11641 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11643 u32
*digest
= (u32
*) hash_buf
->digest
;
11645 salt_t
*salt
= hash_buf
->salt
;
11647 char *salt_buf
= input_buf
+ 6;
11651 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11653 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11655 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11657 salt
->salt_len
= salt_len
;
11659 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11661 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11662 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11663 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11664 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11665 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11667 digest
[0] -= SHA1M_A
;
11668 digest
[1] -= SHA1M_B
;
11669 digest
[2] -= SHA1M_C
;
11670 digest
[3] -= SHA1M_D
;
11671 digest
[4] -= SHA1M_E
;
11673 return (PARSER_OK
);
11676 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11678 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11680 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11682 u32
*digest
= (u32
*) hash_buf
->digest
;
11684 salt_t
*salt
= hash_buf
->salt
;
11686 char *salt_buf
= input_buf
+ 6;
11690 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11692 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11694 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11696 salt
->salt_len
= salt_len
;
11698 char *hash_pos
= input_buf
+ 6 + 8;
11700 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11701 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11702 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11703 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11704 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11706 digest
[0] -= SHA1M_A
;
11707 digest
[1] -= SHA1M_B
;
11708 digest
[2] -= SHA1M_C
;
11709 digest
[3] -= SHA1M_D
;
11710 digest
[4] -= SHA1M_E
;
11712 return (PARSER_OK
);
11715 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11717 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11719 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11721 u64
*digest
= (u64
*) hash_buf
->digest
;
11723 salt_t
*salt
= hash_buf
->salt
;
11725 char *salt_buf
= input_buf
+ 6;
11729 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11731 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11733 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11735 salt
->salt_len
= salt_len
;
11737 char *hash_pos
= input_buf
+ 6 + 8;
11739 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11740 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11741 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11742 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11743 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11744 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11745 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11746 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11748 digest
[0] -= SHA512M_A
;
11749 digest
[1] -= SHA512M_B
;
11750 digest
[2] -= SHA512M_C
;
11751 digest
[3] -= SHA512M_D
;
11752 digest
[4] -= SHA512M_E
;
11753 digest
[5] -= SHA512M_F
;
11754 digest
[6] -= SHA512M_G
;
11755 digest
[7] -= SHA512M_H
;
11757 return (PARSER_OK
);
11760 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11762 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11764 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11768 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11771 u32
*digest
= (u32
*) hash_buf
->digest
;
11773 salt_t
*salt
= hash_buf
->salt
;
11775 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11776 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11780 digest
[0] = byte_swap_32 (digest
[0]);
11781 digest
[1] = byte_swap_32 (digest
[1]);
11783 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11785 uint salt_len
= input_len
- 16 - 1;
11787 char *salt_buf
= input_buf
+ 16 + 1;
11789 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11791 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11793 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11795 salt
->salt_len
= salt_len
;
11797 return (PARSER_OK
);
11800 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11802 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11804 u32
*digest
= (u32
*) hash_buf
->digest
;
11806 salt_t
*salt
= hash_buf
->salt
;
11808 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11809 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11810 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11811 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11812 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11814 digest
[0] -= SHA1M_A
;
11815 digest
[1] -= SHA1M_B
;
11816 digest
[2] -= SHA1M_C
;
11817 digest
[3] -= SHA1M_D
;
11818 digest
[4] -= SHA1M_E
;
11820 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11822 uint salt_len
= input_len
- 40 - 1;
11824 char *salt_buf
= input_buf
+ 40 + 1;
11826 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11828 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11830 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11832 salt
->salt_len
= salt_len
;
11834 return (PARSER_OK
);
11837 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11839 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11841 u32
*digest
= (u32
*) hash_buf
->digest
;
11843 salt_t
*salt
= hash_buf
->salt
;
11845 char *hash_pos
= input_buf
;
11847 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11848 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11849 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11850 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11851 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11852 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11853 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11854 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11855 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11856 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11857 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11858 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11859 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11860 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11861 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11862 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11864 char *salt_pos
= input_buf
+ 128;
11866 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11867 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11868 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11869 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11871 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11872 salt
->salt_len
= 16;
11874 return (PARSER_OK
);
11877 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11879 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11881 u32
*digest
= (u32
*) hash_buf
->digest
;
11883 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11884 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11885 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11886 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11887 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11888 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11889 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11890 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11892 digest
[0] -= SHA256M_A
;
11893 digest
[1] -= SHA256M_B
;
11894 digest
[2] -= SHA256M_C
;
11895 digest
[3] -= SHA256M_D
;
11896 digest
[4] -= SHA256M_E
;
11897 digest
[5] -= SHA256M_F
;
11898 digest
[6] -= SHA256M_G
;
11899 digest
[7] -= SHA256M_H
;
11901 return (PARSER_OK
);
11904 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11906 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11908 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11912 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11915 u32
*digest
= (u32
*) hash_buf
->digest
;
11917 salt_t
*salt
= hash_buf
->salt
;
11919 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11920 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11921 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11922 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11923 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11924 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11925 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11926 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11928 digest
[0] -= SHA256M_A
;
11929 digest
[1] -= SHA256M_B
;
11930 digest
[2] -= SHA256M_C
;
11931 digest
[3] -= SHA256M_D
;
11932 digest
[4] -= SHA256M_E
;
11933 digest
[5] -= SHA256M_F
;
11934 digest
[6] -= SHA256M_G
;
11935 digest
[7] -= SHA256M_H
;
11937 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11939 uint salt_len
= input_len
- 64 - 1;
11941 char *salt_buf
= input_buf
+ 64 + 1;
11943 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11945 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11947 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11949 salt
->salt_len
= salt_len
;
11951 return (PARSER_OK
);
11954 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11956 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11958 u64
*digest
= (u64
*) hash_buf
->digest
;
11960 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11961 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11962 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11963 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11964 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11965 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11969 digest
[0] -= SHA384M_A
;
11970 digest
[1] -= SHA384M_B
;
11971 digest
[2] -= SHA384M_C
;
11972 digest
[3] -= SHA384M_D
;
11973 digest
[4] -= SHA384M_E
;
11974 digest
[5] -= SHA384M_F
;
11978 return (PARSER_OK
);
11981 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11983 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11985 u64
*digest
= (u64
*) hash_buf
->digest
;
11987 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11988 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11989 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11990 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11991 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11992 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11993 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11994 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11996 digest
[0] -= SHA512M_A
;
11997 digest
[1] -= SHA512M_B
;
11998 digest
[2] -= SHA512M_C
;
11999 digest
[3] -= SHA512M_D
;
12000 digest
[4] -= SHA512M_E
;
12001 digest
[5] -= SHA512M_F
;
12002 digest
[6] -= SHA512M_G
;
12003 digest
[7] -= SHA512M_H
;
12005 return (PARSER_OK
);
12008 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12010 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12012 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12016 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12019 u64
*digest
= (u64
*) hash_buf
->digest
;
12021 salt_t
*salt
= hash_buf
->salt
;
12023 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12024 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12025 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12026 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12027 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12028 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12029 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12030 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12032 digest
[0] -= SHA512M_A
;
12033 digest
[1] -= SHA512M_B
;
12034 digest
[2] -= SHA512M_C
;
12035 digest
[3] -= SHA512M_D
;
12036 digest
[4] -= SHA512M_E
;
12037 digest
[5] -= SHA512M_F
;
12038 digest
[6] -= SHA512M_G
;
12039 digest
[7] -= SHA512M_H
;
12041 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12043 uint salt_len
= input_len
- 128 - 1;
12045 char *salt_buf
= input_buf
+ 128 + 1;
12047 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12049 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12051 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12053 salt
->salt_len
= salt_len
;
12055 return (PARSER_OK
);
12058 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12060 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12062 u64
*digest
= (u64
*) hash_buf
->digest
;
12064 salt_t
*salt
= hash_buf
->salt
;
12066 char *salt_pos
= input_buf
+ 3;
12068 uint iterations_len
= 0;
12070 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12074 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12076 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12077 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12081 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12085 iterations_len
+= 8;
12089 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12092 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12094 char *hash_pos
= strchr (salt_pos
, '$');
12096 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12098 uint salt_len
= hash_pos
- salt_pos
;
12100 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12102 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12104 salt
->salt_len
= salt_len
;
12108 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12110 return (PARSER_OK
);
12113 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12115 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12117 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12119 u64
*digest
= (u64
*) hash_buf
->digest
;
12121 salt_t
*salt
= hash_buf
->salt
;
12123 uint keccak_mdlen
= input_len
/ 2;
12125 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12127 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12129 digest
[i
] = byte_swap_64 (digest
[i
]);
12132 salt
->keccak_mdlen
= keccak_mdlen
;
12134 return (PARSER_OK
);
12137 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12139 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12141 u32
*digest
= (u32
*) hash_buf
->digest
;
12143 salt_t
*salt
= hash_buf
->salt
;
12145 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12148 * Parse that strange long line
12155 in_off
[0] = strtok (input_buf
, ":");
12157 in_len
[0] = strlen (in_off
[0]);
12161 for (i
= 1; i
< 9; i
++)
12163 in_off
[i
] = strtok (NULL
, ":");
12165 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12167 in_len
[i
] = strlen (in_off
[i
]);
12172 ptr
= (char *) ikepsk
->msg_buf
;
12174 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12175 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12176 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12177 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12178 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12179 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12183 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12185 ptr
= (char *) ikepsk
->nr_buf
;
12187 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12188 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12192 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12195 * Store to database
12200 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12201 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12202 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12203 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12205 digest
[0] = byte_swap_32 (digest
[0]);
12206 digest
[1] = byte_swap_32 (digest
[1]);
12207 digest
[2] = byte_swap_32 (digest
[2]);
12208 digest
[3] = byte_swap_32 (digest
[3]);
12210 salt
->salt_len
= 32;
12212 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12213 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12214 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12215 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12216 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12217 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12218 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12219 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12221 return (PARSER_OK
);
12224 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12226 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12228 u32
*digest
= (u32
*) hash_buf
->digest
;
12230 salt_t
*salt
= hash_buf
->salt
;
12232 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12235 * Parse that strange long line
12242 in_off
[0] = strtok (input_buf
, ":");
12244 in_len
[0] = strlen (in_off
[0]);
12248 for (i
= 1; i
< 9; i
++)
12250 in_off
[i
] = strtok (NULL
, ":");
12252 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12254 in_len
[i
] = strlen (in_off
[i
]);
12259 ptr
= (char *) ikepsk
->msg_buf
;
12261 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12262 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12263 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12264 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12265 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12266 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12270 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12272 ptr
= (char *) ikepsk
->nr_buf
;
12274 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12275 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12279 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12282 * Store to database
12287 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12288 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12289 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12290 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12291 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12293 salt
->salt_len
= 32;
12295 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12296 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12297 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12298 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12299 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12300 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12301 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12302 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12304 return (PARSER_OK
);
12307 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12309 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12311 u32
*digest
= (u32
*) hash_buf
->digest
;
12313 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12314 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12315 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12316 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12317 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12319 digest
[0] = byte_swap_32 (digest
[0]);
12320 digest
[1] = byte_swap_32 (digest
[1]);
12321 digest
[2] = byte_swap_32 (digest
[2]);
12322 digest
[3] = byte_swap_32 (digest
[3]);
12323 digest
[4] = byte_swap_32 (digest
[4]);
12325 return (PARSER_OK
);
12328 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12330 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12332 u32
*digest
= (u32
*) hash_buf
->digest
;
12334 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12335 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12336 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12337 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12338 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12339 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12340 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12341 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12342 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12343 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12344 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12345 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12346 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12347 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12348 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12349 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12351 return (PARSER_OK
);
12354 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12356 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12358 u32
*digest
= (u32
*) hash_buf
->digest
;
12360 salt_t
*salt
= hash_buf
->salt
;
12362 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12363 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12364 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12365 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12366 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12368 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12370 uint salt_len
= input_len
- 40 - 1;
12372 char *salt_buf
= input_buf
+ 40 + 1;
12374 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12376 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12378 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12380 salt
->salt_len
= salt_len
;
12382 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12384 return (PARSER_OK
);
12387 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12389 u32
*digest
= (u32
*) hash_buf
->digest
;
12391 salt_t
*salt
= hash_buf
->salt
;
12393 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12395 if (input_len
== 0)
12397 log_error ("TrueCrypt container not specified");
12402 FILE *fp
= fopen (input_buf
, "rb");
12406 log_error ("%s: %s", input_buf
, strerror (errno
));
12413 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12417 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12419 memcpy (tc
->salt_buf
, buf
, 64);
12421 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12423 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12425 salt
->salt_len
= 4;
12427 salt
->salt_iter
= 1000 - 1;
12429 digest
[0] = tc
->data_buf
[0];
12431 return (PARSER_OK
);
12434 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12436 u32
*digest
= (u32
*) hash_buf
->digest
;
12438 salt_t
*salt
= hash_buf
->salt
;
12440 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12442 if (input_len
== 0)
12444 log_error ("TrueCrypt container not specified");
12449 FILE *fp
= fopen (input_buf
, "rb");
12453 log_error ("%s: %s", input_buf
, strerror (errno
));
12460 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12464 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12466 memcpy (tc
->salt_buf
, buf
, 64);
12468 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12470 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12472 salt
->salt_len
= 4;
12474 salt
->salt_iter
= 2000 - 1;
12476 digest
[0] = tc
->data_buf
[0];
12478 return (PARSER_OK
);
12481 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12483 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12485 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12487 u32
*digest
= (u32
*) hash_buf
->digest
;
12489 salt_t
*salt
= hash_buf
->salt
;
12491 char *salt_pos
= input_buf
+ 6;
12493 char *hash_pos
= strchr (salt_pos
, '$');
12495 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12497 uint salt_len
= hash_pos
- salt_pos
;
12499 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12501 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12503 salt
->salt_len
= salt_len
;
12505 salt
->salt_iter
= 1000;
12509 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12511 return (PARSER_OK
);
12514 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12516 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12518 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12520 u32
*digest
= (u32
*) hash_buf
->digest
;
12522 salt_t
*salt
= hash_buf
->salt
;
12524 char *iter_pos
= input_buf
+ 7;
12526 char *salt_pos
= strchr (iter_pos
, '$');
12528 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12532 char *hash_pos
= strchr (salt_pos
, '$');
12534 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12536 uint salt_len
= hash_pos
- salt_pos
;
12538 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12540 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12542 salt
->salt_len
= salt_len
;
12544 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12546 salt
->salt_sign
[0] = atoi (salt_iter
);
12548 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12552 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12554 digest
[0] = byte_swap_32 (digest
[0]);
12555 digest
[1] = byte_swap_32 (digest
[1]);
12556 digest
[2] = byte_swap_32 (digest
[2]);
12557 digest
[3] = byte_swap_32 (digest
[3]);
12558 digest
[4] = byte_swap_32 (digest
[4]);
12560 return (PARSER_OK
);
12563 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12565 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12567 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12569 u32
*digest
= (u32
*) hash_buf
->digest
;
12571 salt_t
*salt
= hash_buf
->salt
;
12573 char *iter_pos
= input_buf
+ 9;
12575 char *salt_pos
= strchr (iter_pos
, '$');
12577 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12581 char *hash_pos
= strchr (salt_pos
, '$');
12583 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12585 uint salt_len
= hash_pos
- salt_pos
;
12587 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12589 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12591 salt
->salt_len
= salt_len
;
12593 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12595 salt
->salt_sign
[0] = atoi (salt_iter
);
12597 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12601 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12603 digest
[0] = byte_swap_32 (digest
[0]);
12604 digest
[1] = byte_swap_32 (digest
[1]);
12605 digest
[2] = byte_swap_32 (digest
[2]);
12606 digest
[3] = byte_swap_32 (digest
[3]);
12607 digest
[4] = byte_swap_32 (digest
[4]);
12608 digest
[5] = byte_swap_32 (digest
[5]);
12609 digest
[6] = byte_swap_32 (digest
[6]);
12610 digest
[7] = byte_swap_32 (digest
[7]);
12612 return (PARSER_OK
);
12615 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12617 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12619 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12621 u64
*digest
= (u64
*) hash_buf
->digest
;
12623 salt_t
*salt
= hash_buf
->salt
;
12625 char *iter_pos
= input_buf
+ 9;
12627 char *salt_pos
= strchr (iter_pos
, '$');
12629 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12633 char *hash_pos
= strchr (salt_pos
, '$');
12635 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12637 uint salt_len
= hash_pos
- salt_pos
;
12639 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12641 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12643 salt
->salt_len
= salt_len
;
12645 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12647 salt
->salt_sign
[0] = atoi (salt_iter
);
12649 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12653 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12655 digest
[0] = byte_swap_64 (digest
[0]);
12656 digest
[1] = byte_swap_64 (digest
[1]);
12657 digest
[2] = byte_swap_64 (digest
[2]);
12658 digest
[3] = byte_swap_64 (digest
[3]);
12659 digest
[4] = byte_swap_64 (digest
[4]);
12660 digest
[5] = byte_swap_64 (digest
[5]);
12661 digest
[6] = byte_swap_64 (digest
[6]);
12662 digest
[7] = byte_swap_64 (digest
[7]);
12664 return (PARSER_OK
);
12667 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12669 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12671 u32
*digest
= (u32
*) hash_buf
->digest
;
12673 salt_t
*salt
= hash_buf
->salt
;
12675 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12681 char *iterations_pos
= input_buf
;
12683 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12685 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12687 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12689 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12693 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12695 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12697 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12699 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12701 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12703 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12708 * pbkdf2 iterations
12711 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12714 * handle salt encoding
12717 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12719 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12721 const char p0
= saltbuf_pos
[i
+ 0];
12722 const char p1
= saltbuf_pos
[i
+ 1];
12724 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12725 | hex_convert (p0
) << 4;
12728 salt
->salt_len
= saltbuf_len
/ 2;
12731 * handle cipher encoding
12734 uint
*tmp
= (uint
*) mymalloc (32);
12736 char *cipherbuf_ptr
= (char *) tmp
;
12738 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12740 const char p0
= cipherbuf_pos
[i
+ 0];
12741 const char p1
= cipherbuf_pos
[i
+ 1];
12743 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12744 | hex_convert (p0
) << 4;
12747 // iv is stored at salt_buf 4 (length 16)
12748 // data is stored at salt_buf 8 (length 16)
12750 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12751 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12752 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12753 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12755 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12756 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12757 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12758 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12762 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12764 const char p0
= cipherbuf_pos
[j
+ 0];
12765 const char p1
= cipherbuf_pos
[j
+ 1];
12767 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12768 | hex_convert (p0
) << 4;
12775 digest
[0] = 0x10101010;
12776 digest
[1] = 0x10101010;
12777 digest
[2] = 0x10101010;
12778 digest
[3] = 0x10101010;
12780 return (PARSER_OK
);
12783 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12785 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12787 u32
*digest
= (u32
*) hash_buf
->digest
;
12789 salt_t
*salt
= hash_buf
->salt
;
12791 char *hashbuf_pos
= input_buf
;
12793 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12795 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12797 uint hash_len
= iterations_pos
- hashbuf_pos
;
12799 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12803 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12805 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12807 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12811 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12813 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12815 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12817 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12819 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12821 salt
->salt_len
= salt_len
;
12823 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12825 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12826 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12827 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12828 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12830 return (PARSER_OK
);
12833 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12835 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12837 u32
*digest
= (u32
*) hash_buf
->digest
;
12839 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12840 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12841 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12842 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12843 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12844 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12845 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12846 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12848 digest
[0] = byte_swap_32 (digest
[0]);
12849 digest
[1] = byte_swap_32 (digest
[1]);
12850 digest
[2] = byte_swap_32 (digest
[2]);
12851 digest
[3] = byte_swap_32 (digest
[3]);
12852 digest
[4] = byte_swap_32 (digest
[4]);
12853 digest
[5] = byte_swap_32 (digest
[5]);
12854 digest
[6] = byte_swap_32 (digest
[6]);
12855 digest
[7] = byte_swap_32 (digest
[7]);
12857 return (PARSER_OK
);
12860 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12862 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12864 u32
*digest
= (u32
*) hash_buf
->digest
;
12866 salt_t
*salt
= hash_buf
->salt
;
12868 char *salt_pos
= input_buf
+ 3;
12870 uint iterations_len
= 0;
12872 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12876 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12878 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12879 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12883 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12887 iterations_len
+= 8;
12891 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12894 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12896 char *hash_pos
= strchr (salt_pos
, '$');
12898 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12900 uint salt_len
= hash_pos
- salt_pos
;
12902 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12904 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12906 salt
->salt_len
= salt_len
;
12910 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12912 return (PARSER_OK
);
12915 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12917 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12919 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12921 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12923 u64
*digest
= (u64
*) hash_buf
->digest
;
12925 salt_t
*salt
= hash_buf
->salt
;
12927 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12929 char *iter_pos
= input_buf
+ 4;
12931 char *salt_pos
= strchr (iter_pos
, '$');
12933 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12937 char *hash_pos
= strchr (salt_pos
, '$');
12939 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12941 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12945 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12946 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12947 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12948 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12949 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12950 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12951 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12952 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12954 uint salt_len
= hash_pos
- salt_pos
- 1;
12956 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12958 salt
->salt_len
= salt_len
/ 2;
12960 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12961 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12962 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12963 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12964 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12965 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12966 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12967 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12969 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12970 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12971 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12972 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12973 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12974 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12975 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12976 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12977 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12978 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12980 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12982 salt
->salt_iter
= atoi (iter_pos
) - 1;
12984 return (PARSER_OK
);
12987 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12989 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12991 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12993 u32
*digest
= (u32
*) hash_buf
->digest
;
12995 salt_t
*salt
= hash_buf
->salt
;
12997 char *salt_pos
= input_buf
+ 14;
12999 char *hash_pos
= strchr (salt_pos
, '*');
13001 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13005 uint salt_len
= hash_pos
- salt_pos
- 1;
13007 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13009 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13011 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13013 salt
->salt_len
= salt_len
;
13017 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13019 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13021 memcpy (digest
, tmp_buf
, 32);
13023 digest
[0] = byte_swap_32 (digest
[0]);
13024 digest
[1] = byte_swap_32 (digest
[1]);
13025 digest
[2] = byte_swap_32 (digest
[2]);
13026 digest
[3] = byte_swap_32 (digest
[3]);
13027 digest
[4] = byte_swap_32 (digest
[4]);
13028 digest
[5] = byte_swap_32 (digest
[5]);
13029 digest
[6] = byte_swap_32 (digest
[6]);
13030 digest
[7] = byte_swap_32 (digest
[7]);
13032 digest
[0] -= SHA256M_A
;
13033 digest
[1] -= SHA256M_B
;
13034 digest
[2] -= SHA256M_C
;
13035 digest
[3] -= SHA256M_D
;
13036 digest
[4] -= SHA256M_E
;
13037 digest
[5] -= SHA256M_F
;
13038 digest
[6] -= SHA256M_G
;
13039 digest
[7] -= SHA256M_H
;
13041 return (PARSER_OK
);
13044 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13046 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13048 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13050 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13052 u64
*digest
= (u64
*) hash_buf
->digest
;
13054 salt_t
*salt
= hash_buf
->salt
;
13056 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13058 char *iter_pos
= input_buf
+ 19;
13060 char *salt_pos
= strchr (iter_pos
, '.');
13062 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13066 char *hash_pos
= strchr (salt_pos
, '.');
13068 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13070 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13074 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13075 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13076 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13077 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13078 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13079 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13080 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13081 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13083 uint salt_len
= hash_pos
- salt_pos
- 1;
13087 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13091 for (i
= 0; i
< salt_len
; i
++)
13093 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13096 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13097 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13099 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13101 salt
->salt_len
= salt_len
;
13103 salt
->salt_iter
= atoi (iter_pos
) - 1;
13105 return (PARSER_OK
);
13108 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13110 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13112 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13114 u64
*digest
= (u64
*) hash_buf
->digest
;
13116 salt_t
*salt
= hash_buf
->salt
;
13120 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13122 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13124 memcpy (digest
, tmp_buf
, 64);
13126 digest
[0] = byte_swap_64 (digest
[0]);
13127 digest
[1] = byte_swap_64 (digest
[1]);
13128 digest
[2] = byte_swap_64 (digest
[2]);
13129 digest
[3] = byte_swap_64 (digest
[3]);
13130 digest
[4] = byte_swap_64 (digest
[4]);
13131 digest
[5] = byte_swap_64 (digest
[5]);
13132 digest
[6] = byte_swap_64 (digest
[6]);
13133 digest
[7] = byte_swap_64 (digest
[7]);
13135 digest
[0] -= SHA512M_A
;
13136 digest
[1] -= SHA512M_B
;
13137 digest
[2] -= SHA512M_C
;
13138 digest
[3] -= SHA512M_D
;
13139 digest
[4] -= SHA512M_E
;
13140 digest
[5] -= SHA512M_F
;
13141 digest
[6] -= SHA512M_G
;
13142 digest
[7] -= SHA512M_H
;
13144 salt
->salt_len
= tmp_len
- 64;
13146 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13148 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13150 char *ptr
= (char *) salt
->salt_buf
;
13152 ptr
[salt
->salt_len
] = 0x80;
13155 return (PARSER_OK
);
13158 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13160 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13162 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13166 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13169 u32
*digest
= (u32
*) hash_buf
->digest
;
13171 salt_t
*salt
= hash_buf
->salt
;
13173 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13174 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13175 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13176 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13178 digest
[0] = byte_swap_32 (digest
[0]);
13179 digest
[1] = byte_swap_32 (digest
[1]);
13180 digest
[2] = byte_swap_32 (digest
[2]);
13181 digest
[3] = byte_swap_32 (digest
[3]);
13183 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13185 uint salt_len
= input_len
- 32 - 1;
13187 char *salt_buf
= input_buf
+ 32 + 1;
13189 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13191 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13193 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13195 salt
->salt_len
= salt_len
;
13197 return (PARSER_OK
);
13200 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13202 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13204 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13208 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13211 u32
*digest
= (u32
*) hash_buf
->digest
;
13213 salt_t
*salt
= hash_buf
->salt
;
13215 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13216 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13217 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13218 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13219 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13221 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13223 uint salt_len
= input_len
- 40 - 1;
13225 char *salt_buf
= input_buf
+ 40 + 1;
13227 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13229 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13231 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13233 salt
->salt_len
= salt_len
;
13235 return (PARSER_OK
);
13238 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13240 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13242 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13246 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13249 u32
*digest
= (u32
*) hash_buf
->digest
;
13251 salt_t
*salt
= hash_buf
->salt
;
13253 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13254 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13255 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13256 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13257 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13258 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13259 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13260 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13262 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13264 uint salt_len
= input_len
- 64 - 1;
13266 char *salt_buf
= input_buf
+ 64 + 1;
13268 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13270 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13272 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13274 salt
->salt_len
= salt_len
;
13276 return (PARSER_OK
);
13279 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13281 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13283 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13287 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13290 u64
*digest
= (u64
*) hash_buf
->digest
;
13292 salt_t
*salt
= hash_buf
->salt
;
13294 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13295 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13296 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13297 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13298 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13299 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13300 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13301 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13303 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13305 uint salt_len
= input_len
- 128 - 1;
13307 char *salt_buf
= input_buf
+ 128 + 1;
13309 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13311 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13313 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13315 salt
->salt_len
= salt_len
;
13317 return (PARSER_OK
);
13320 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13322 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13324 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13326 u32
*digest
= (u32
*) hash_buf
->digest
;
13328 salt_t
*salt
= hash_buf
->salt
;
13330 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13336 char *user_pos
= input_buf
+ 10 + 1;
13338 char *realm_pos
= strchr (user_pos
, '$');
13340 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13342 uint user_len
= realm_pos
- user_pos
;
13344 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13348 char *salt_pos
= strchr (realm_pos
, '$');
13350 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13352 uint realm_len
= salt_pos
- realm_pos
;
13354 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13358 char *data_pos
= strchr (salt_pos
, '$');
13360 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13362 uint salt_len
= data_pos
- salt_pos
;
13364 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13368 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13370 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13376 memcpy (krb5pa
->user
, user_pos
, user_len
);
13377 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13378 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13380 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13382 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13384 const char p0
= data_pos
[i
+ 0];
13385 const char p1
= data_pos
[i
+ 1];
13387 *timestamp_ptr
++ = hex_convert (p1
) << 0
13388 | hex_convert (p0
) << 4;
13391 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13393 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13395 const char p0
= data_pos
[i
+ 0];
13396 const char p1
= data_pos
[i
+ 1];
13398 *checksum_ptr
++ = hex_convert (p1
) << 0
13399 | hex_convert (p0
) << 4;
13403 * copy some data to generic buffers to make sorting happy
13406 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13407 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13408 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13409 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13410 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13411 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13412 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13413 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13414 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13416 salt
->salt_len
= 36;
13418 digest
[0] = krb5pa
->checksum
[0];
13419 digest
[1] = krb5pa
->checksum
[1];
13420 digest
[2] = krb5pa
->checksum
[2];
13421 digest
[3] = krb5pa
->checksum
[3];
13423 return (PARSER_OK
);
13426 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13428 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13430 u32
*digest
= (u32
*) hash_buf
->digest
;
13432 salt_t
*salt
= hash_buf
->salt
;
13438 char *salt_pos
= input_buf
;
13440 char *hash_pos
= strchr (salt_pos
, '$');
13442 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13444 uint salt_len
= hash_pos
- salt_pos
;
13446 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13450 uint hash_len
= input_len
- 1 - salt_len
;
13452 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13460 for (uint i
= 0; i
< salt_len
; i
++)
13462 if (salt_pos
[i
] == ' ') continue;
13467 // SAP user names cannot be longer than 12 characters
13468 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13470 // SAP user name cannot start with ! or ?
13471 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13477 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13479 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13481 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13483 salt
->salt_len
= salt_len
;
13485 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13486 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13490 digest
[0] = byte_swap_32 (digest
[0]);
13491 digest
[1] = byte_swap_32 (digest
[1]);
13493 return (PARSER_OK
);
13496 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13498 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13500 u32
*digest
= (u32
*) hash_buf
->digest
;
13502 salt_t
*salt
= hash_buf
->salt
;
13508 char *salt_pos
= input_buf
;
13510 char *hash_pos
= strchr (salt_pos
, '$');
13512 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13514 uint salt_len
= hash_pos
- salt_pos
;
13516 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13520 uint hash_len
= input_len
- 1 - salt_len
;
13522 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13530 for (uint i
= 0; i
< salt_len
; i
++)
13532 if (salt_pos
[i
] == ' ') continue;
13537 // SAP user names cannot be longer than 12 characters
13538 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13539 // so far nobody complained so we stay with this because it helps in optimization
13540 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13542 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13544 // SAP user name cannot start with ! or ?
13545 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13551 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13553 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13555 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13557 salt
->salt_len
= salt_len
;
13559 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13560 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13561 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13562 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13563 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13565 return (PARSER_OK
);
13568 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13570 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13572 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13574 u64
*digest
= (u64
*) hash_buf
->digest
;
13576 salt_t
*salt
= hash_buf
->salt
;
13578 char *iter_pos
= input_buf
+ 3;
13580 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13582 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13584 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13586 salt
->salt_iter
= salt_iter
;
13588 char *salt_pos
= iter_pos
+ 1;
13592 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13594 salt
->salt_len
= salt_len
;
13596 char *hash_pos
= salt_pos
+ salt_len
;
13598 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13602 char *tmp
= (char *) salt
->salt_buf_pc
;
13604 tmp
[0] = hash_pos
[42];
13608 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13609 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13610 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13611 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13617 return (PARSER_OK
);
13620 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13622 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13624 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13626 u32
*digest
= (u32
*) hash_buf
->digest
;
13628 salt_t
*salt
= hash_buf
->salt
;
13630 char *salt_buf
= input_buf
+ 6;
13632 uint salt_len
= 16;
13634 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13636 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13638 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13640 salt
->salt_len
= salt_len
;
13642 char *hash_pos
= input_buf
+ 6 + 16;
13644 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13645 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13646 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13647 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13648 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13649 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13650 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13651 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13653 return (PARSER_OK
);
13656 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13658 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13660 u32
*digest
= (u32
*) hash_buf
->digest
;
13662 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13663 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13667 return (PARSER_OK
);
13670 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13672 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13674 u32
*digest
= (u32
*) hash_buf
->digest
;
13676 salt_t
*salt
= hash_buf
->salt
;
13678 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13680 char *saltbuf_pos
= input_buf
;
13682 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13684 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13686 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13688 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13689 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13691 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13695 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13697 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13699 char *salt_ptr
= (char *) saltbuf_pos
;
13700 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13705 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13707 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13710 rakp_ptr
[j
] = 0x80;
13712 rakp
->salt_len
= j
;
13714 for (i
= 0; i
< 64; i
++)
13716 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13719 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13720 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13721 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13722 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13723 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13724 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13725 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13726 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13728 salt
->salt_len
= 32; // muss min. 32 haben
13730 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13731 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13732 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13733 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13734 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13736 return (PARSER_OK
);
13739 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13741 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13743 u32
*digest
= (u32
*) hash_buf
->digest
;
13745 salt_t
*salt
= hash_buf
->salt
;
13747 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13749 char *salt_pos
= input_buf
+ 1;
13751 memcpy (salt
->salt_buf
, salt_pos
, 8);
13753 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13754 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13756 salt
->salt_len
= 8;
13758 char *hash_pos
= salt_pos
+ 8;
13760 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13761 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13762 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13763 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13764 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13766 digest
[0] -= SHA1M_A
;
13767 digest
[1] -= SHA1M_B
;
13768 digest
[2] -= SHA1M_C
;
13769 digest
[3] -= SHA1M_D
;
13770 digest
[4] -= SHA1M_E
;
13772 return (PARSER_OK
);
13775 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13777 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13779 u32
*digest
= (u32
*) hash_buf
->digest
;
13781 salt_t
*salt
= hash_buf
->salt
;
13783 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13784 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13785 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13786 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13788 digest
[0] = byte_swap_32 (digest
[0]);
13789 digest
[1] = byte_swap_32 (digest
[1]);
13790 digest
[2] = byte_swap_32 (digest
[2]);
13791 digest
[3] = byte_swap_32 (digest
[3]);
13793 digest
[0] -= MD5M_A
;
13794 digest
[1] -= MD5M_B
;
13795 digest
[2] -= MD5M_C
;
13796 digest
[3] -= MD5M_D
;
13798 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13800 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13802 u32
*salt_buf
= salt
->salt_buf
;
13804 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13805 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13806 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13807 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13809 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13810 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13811 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13812 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13814 salt
->salt_len
= 16 + 1;
13816 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13818 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13820 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13822 return (PARSER_OK
);
13825 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13827 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13829 u32
*digest
= (u32
*) hash_buf
->digest
;
13831 salt_t
*salt
= hash_buf
->salt
;
13833 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13839 char *hashbuf_pos
= input_buf
;
13841 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13843 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13845 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13847 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13851 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13853 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13855 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13857 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13861 char *databuf_pos
= strchr (iteration_pos
, ':');
13863 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13865 const uint iteration_len
= databuf_pos
- iteration_pos
;
13867 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13868 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13870 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13872 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13873 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13879 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13880 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13881 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13882 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13883 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13884 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13885 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13886 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13890 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13892 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13894 const char p0
= saltbuf_pos
[i
+ 0];
13895 const char p1
= saltbuf_pos
[i
+ 1];
13897 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13898 | hex_convert (p0
) << 4;
13901 salt
->salt_buf
[4] = 0x01000000;
13902 salt
->salt_buf
[5] = 0x80;
13904 salt
->salt_len
= saltbuf_len
/ 2;
13908 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13912 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13914 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13916 const char p0
= databuf_pos
[i
+ 0];
13917 const char p1
= databuf_pos
[i
+ 1];
13919 *databuf_ptr
++ = hex_convert (p1
) << 0
13920 | hex_convert (p0
) << 4;
13923 *databuf_ptr
++ = 0x80;
13925 for (uint i
= 0; i
< 512; i
++)
13927 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13930 cloudkey
->data_len
= databuf_len
/ 2;
13932 return (PARSER_OK
);
13935 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13937 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13939 u32
*digest
= (u32
*) hash_buf
->digest
;
13941 salt_t
*salt
= hash_buf
->salt
;
13947 char *hashbuf_pos
= input_buf
;
13949 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13951 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13953 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13955 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13959 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13961 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13963 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13965 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13967 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13971 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13973 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13975 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13977 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13979 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13983 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13985 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13986 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13988 // ok, the plan for this algorithm is the following:
13989 // we have 2 salts here, the domain-name and a random salt
13990 // while both are used in the initial transformation,
13991 // only the random salt is used in the following iterations
13992 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13993 // and one that includes only the real salt (stored into salt_buf[]).
13994 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13998 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14000 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14002 memcpy (digest
, tmp_buf
, 20);
14004 digest
[0] = byte_swap_32 (digest
[0]);
14005 digest
[1] = byte_swap_32 (digest
[1]);
14006 digest
[2] = byte_swap_32 (digest
[2]);
14007 digest
[3] = byte_swap_32 (digest
[3]);
14008 digest
[4] = byte_swap_32 (digest
[4]);
14012 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14014 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14016 char *len_ptr
= NULL
;
14018 for (uint i
= 0; i
< domainbuf_len
; i
++)
14020 if (salt_buf_pc_ptr
[i
] == '.')
14022 len_ptr
= &salt_buf_pc_ptr
[i
];
14032 salt
->salt_buf_pc
[7] = domainbuf_len
;
14036 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14038 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14040 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14042 salt
->salt_len
= salt_len
;
14046 salt
->salt_iter
= atoi (iteration_pos
);
14048 return (PARSER_OK
);
14051 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14053 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14055 u32
*digest
= (u32
*) hash_buf
->digest
;
14057 salt_t
*salt
= hash_buf
->salt
;
14059 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14060 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14061 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14062 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14063 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14065 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14067 uint salt_len
= input_len
- 40 - 1;
14069 char *salt_buf
= input_buf
+ 40 + 1;
14071 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14073 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14075 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14077 salt
->salt_len
= salt_len
;
14079 return (PARSER_OK
);
14082 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14084 const u8 ascii_to_ebcdic
[] =
14086 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14087 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14088 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14089 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14090 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14091 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14092 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14093 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14094 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14095 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14096 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14097 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14098 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14099 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14100 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14101 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14104 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14106 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14108 u32
*digest
= (u32
*) hash_buf
->digest
;
14110 salt_t
*salt
= hash_buf
->salt
;
14112 char *salt_pos
= input_buf
+ 6 + 1;
14114 char *digest_pos
= strchr (salt_pos
, '*');
14116 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14118 uint salt_len
= digest_pos
- salt_pos
;
14120 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14122 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14124 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14128 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14129 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14131 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14133 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14135 salt
->salt_len
= salt_len
;
14137 for (uint i
= 0; i
< salt_len
; i
++)
14139 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14141 for (uint i
= salt_len
; i
< 8; i
++)
14143 salt_buf_pc_ptr
[i
] = 0x40;
14148 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14150 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14151 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14153 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14154 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14156 digest
[0] = byte_swap_32 (digest
[0]);
14157 digest
[1] = byte_swap_32 (digest
[1]);
14159 IP (digest
[0], digest
[1], tt
);
14161 digest
[0] = rotr32 (digest
[0], 29);
14162 digest
[1] = rotr32 (digest
[1], 29);
14166 return (PARSER_OK
);
14169 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14171 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14173 u32
*digest
= (u32
*) hash_buf
->digest
;
14175 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14176 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14177 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14178 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14180 digest
[0] = byte_swap_32 (digest
[0]);
14181 digest
[1] = byte_swap_32 (digest
[1]);
14182 digest
[2] = byte_swap_32 (digest
[2]);
14183 digest
[3] = byte_swap_32 (digest
[3]);
14185 return (PARSER_OK
);
14188 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14190 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14192 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14194 u32
*digest
= (u32
*) hash_buf
->digest
;
14196 salt_t
*salt
= hash_buf
->salt
;
14200 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14202 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14204 tmp_buf
[3] += -4; // dont ask!
14206 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14208 salt
->salt_len
= 5;
14210 memcpy (digest
, tmp_buf
+ 5, 9);
14212 // yes, only 9 byte are needed to crack, but 10 to display
14214 salt
->salt_buf_pc
[7] = input_buf
[20];
14216 return (PARSER_OK
);
14219 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14221 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14223 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14225 u32
*digest
= (u32
*) hash_buf
->digest
;
14227 salt_t
*salt
= hash_buf
->salt
;
14231 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14233 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14235 tmp_buf
[3] += -4; // dont ask!
14239 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14241 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)
14245 char tmp_iter_buf
[11];
14247 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14249 tmp_iter_buf
[10] = 0;
14251 salt
->salt_iter
= atoi (tmp_iter_buf
);
14253 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14255 return (PARSER_SALT_ITERATION
);
14258 salt
->salt_iter
--; // first round in init
14260 // 2 additional bytes for display only
14262 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14263 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14267 memcpy (digest
, tmp_buf
+ 28, 8);
14269 digest
[0] = byte_swap_32 (digest
[0]);
14270 digest
[1] = byte_swap_32 (digest
[1]);
14274 return (PARSER_OK
);
14277 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14279 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14281 u32
*digest
= (u32
*) hash_buf
->digest
;
14283 salt_t
*salt
= hash_buf
->salt
;
14285 char *salt_buf_pos
= input_buf
;
14287 char *hash_buf_pos
= salt_buf_pos
+ 6;
14289 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14290 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14291 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14292 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14293 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14294 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14295 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14296 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14298 digest
[0] -= SHA256M_A
;
14299 digest
[1] -= SHA256M_B
;
14300 digest
[2] -= SHA256M_C
;
14301 digest
[3] -= SHA256M_D
;
14302 digest
[4] -= SHA256M_E
;
14303 digest
[5] -= SHA256M_F
;
14304 digest
[6] -= SHA256M_G
;
14305 digest
[7] -= SHA256M_H
;
14307 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14309 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14311 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14313 salt
->salt_len
= salt_len
;
14315 return (PARSER_OK
);
14318 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14320 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14322 u32
*digest
= (u32
*) hash_buf
->digest
;
14324 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14326 salt_t
*salt
= hash_buf
->salt
;
14328 char *salt_buf
= input_buf
+ 6;
14330 char *digest_buf
= strchr (salt_buf
, '$');
14332 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14334 uint salt_len
= digest_buf
- salt_buf
;
14336 digest_buf
++; // skip the '$' symbol
14338 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14340 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14342 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14344 salt
->salt_len
= salt_len
;
14346 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14347 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14348 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14349 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14351 digest
[0] = byte_swap_32 (digest
[0]);
14352 digest
[1] = byte_swap_32 (digest
[1]);
14353 digest
[2] = byte_swap_32 (digest
[2]);
14354 digest
[3] = byte_swap_32 (digest
[3]);
14356 digest
[0] -= MD5M_A
;
14357 digest
[1] -= MD5M_B
;
14358 digest
[2] -= MD5M_C
;
14359 digest
[3] -= MD5M_D
;
14361 return (PARSER_OK
);
14364 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14366 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14368 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14370 u32
*digest
= (u32
*) hash_buf
->digest
;
14372 salt_t
*salt
= hash_buf
->salt
;
14374 char *salt_buf
= input_buf
+ 3;
14376 char *digest_buf
= strchr (salt_buf
, '$');
14378 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14380 uint salt_len
= digest_buf
- salt_buf
;
14382 digest_buf
++; // skip the '$' symbol
14384 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14386 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14388 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14390 salt_buf_ptr
[salt_len
] = 0x2d;
14392 salt
->salt_len
= salt_len
+ 1;
14394 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14395 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14396 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14397 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14399 digest
[0] = byte_swap_32 (digest
[0]);
14400 digest
[1] = byte_swap_32 (digest
[1]);
14401 digest
[2] = byte_swap_32 (digest
[2]);
14402 digest
[3] = byte_swap_32 (digest
[3]);
14404 digest
[0] -= MD5M_A
;
14405 digest
[1] -= MD5M_B
;
14406 digest
[2] -= MD5M_C
;
14407 digest
[3] -= MD5M_D
;
14409 return (PARSER_OK
);
14412 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14414 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14416 u32
*digest
= (u32
*) hash_buf
->digest
;
14420 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14422 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14424 memcpy (digest
, tmp_buf
, 20);
14426 digest
[0] = byte_swap_32 (digest
[0]);
14427 digest
[1] = byte_swap_32 (digest
[1]);
14428 digest
[2] = byte_swap_32 (digest
[2]);
14429 digest
[3] = byte_swap_32 (digest
[3]);
14430 digest
[4] = byte_swap_32 (digest
[4]);
14432 digest
[0] -= SHA1M_A
;
14433 digest
[1] -= SHA1M_B
;
14434 digest
[2] -= SHA1M_C
;
14435 digest
[3] -= SHA1M_D
;
14436 digest
[4] -= SHA1M_E
;
14438 return (PARSER_OK
);
14441 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14443 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14445 u32
*digest
= (u32
*) hash_buf
->digest
;
14447 salt_t
*salt
= hash_buf
->salt
;
14449 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14450 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14451 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14452 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14454 digest
[0] = byte_swap_32 (digest
[0]);
14455 digest
[1] = byte_swap_32 (digest
[1]);
14456 digest
[2] = byte_swap_32 (digest
[2]);
14457 digest
[3] = byte_swap_32 (digest
[3]);
14459 digest
[0] -= MD5M_A
;
14460 digest
[1] -= MD5M_B
;
14461 digest
[2] -= MD5M_C
;
14462 digest
[3] -= MD5M_D
;
14464 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14466 uint salt_len
= input_len
- 32 - 1;
14468 char *salt_buf
= input_buf
+ 32 + 1;
14470 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14472 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14474 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14477 * add static "salt" part
14480 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14484 salt
->salt_len
= salt_len
;
14486 return (PARSER_OK
);
14489 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14491 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14493 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14495 u32
*digest
= (u32
*) hash_buf
->digest
;
14497 salt_t
*salt
= hash_buf
->salt
;
14499 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14505 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14507 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14509 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14511 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14513 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14517 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14519 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14521 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14523 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14527 char *keybuf_pos
= strchr (keylen_pos
, '$');
14529 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14531 uint keylen_len
= keybuf_pos
- keylen_pos
;
14533 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14537 char *databuf_pos
= strchr (keybuf_pos
, '$');
14539 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14541 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14543 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14547 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14549 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14555 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14556 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14557 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14558 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14560 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14561 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14562 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14563 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14565 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14566 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14567 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14568 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14570 salt
->salt_len
= 16;
14571 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14573 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14575 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14578 return (PARSER_OK
);
14581 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14583 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14585 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14587 u32
*digest
= (u32
*) hash_buf
->digest
;
14589 salt_t
*salt
= hash_buf
->salt
;
14595 // first is the N salt parameter
14597 char *N_pos
= input_buf
+ 6;
14599 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14603 salt
->scrypt_N
= atoi (N_pos
);
14607 char *r_pos
= strchr (N_pos
, ':');
14609 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14613 salt
->scrypt_r
= atoi (r_pos
);
14617 char *p_pos
= strchr (r_pos
, ':');
14619 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14623 salt
->scrypt_p
= atoi (p_pos
);
14627 char *saltbuf_pos
= strchr (p_pos
, ':');
14629 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14633 char *hash_pos
= strchr (saltbuf_pos
, ':');
14635 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14643 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14645 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14647 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14649 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14651 salt
->salt_len
= tmp_len
;
14652 salt
->salt_iter
= 1;
14654 // digest - base64 decode
14656 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14658 tmp_len
= input_len
- (hash_pos
- input_buf
);
14660 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14662 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14664 memcpy (digest
, tmp_buf
, 32);
14666 return (PARSER_OK
);
14669 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14671 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14673 u32
*digest
= (u32
*) hash_buf
->digest
;
14675 salt_t
*salt
= hash_buf
->salt
;
14681 char decrypted
[76]; // iv + hash
14683 juniper_decrypt_hash (input_buf
, decrypted
);
14685 char *md5crypt_hash
= decrypted
+ 12;
14687 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14689 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14691 char *salt_pos
= md5crypt_hash
+ 3;
14693 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14695 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14697 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14701 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14703 return (PARSER_OK
);
14706 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14708 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14710 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14712 u32
*digest
= (u32
*) hash_buf
->digest
;
14714 salt_t
*salt
= hash_buf
->salt
;
14716 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14722 // first is *raw* salt
14724 char *salt_pos
= input_buf
+ 3;
14726 char *hash_pos
= strchr (salt_pos
, '$');
14728 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14730 uint salt_len
= hash_pos
- salt_pos
;
14732 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14736 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14738 memcpy (salt_buf_ptr
, salt_pos
, 14);
14740 salt_buf_ptr
[17] = 0x01;
14741 salt_buf_ptr
[18] = 0x80;
14743 // add some stuff to normal salt to make sorted happy
14745 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14746 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14747 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14748 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14750 salt
->salt_len
= salt_len
;
14751 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14753 // base64 decode hash
14757 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14759 uint hash_len
= input_len
- 3 - salt_len
- 1;
14761 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14763 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14765 memcpy (digest
, tmp_buf
, 32);
14767 digest
[0] = byte_swap_32 (digest
[0]);
14768 digest
[1] = byte_swap_32 (digest
[1]);
14769 digest
[2] = byte_swap_32 (digest
[2]);
14770 digest
[3] = byte_swap_32 (digest
[3]);
14771 digest
[4] = byte_swap_32 (digest
[4]);
14772 digest
[5] = byte_swap_32 (digest
[5]);
14773 digest
[6] = byte_swap_32 (digest
[6]);
14774 digest
[7] = byte_swap_32 (digest
[7]);
14776 return (PARSER_OK
);
14779 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14781 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14783 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14785 u32
*digest
= (u32
*) hash_buf
->digest
;
14787 salt_t
*salt
= hash_buf
->salt
;
14793 // first is *raw* salt
14795 char *salt_pos
= input_buf
+ 3;
14797 char *hash_pos
= strchr (salt_pos
, '$');
14799 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14801 uint salt_len
= hash_pos
- salt_pos
;
14803 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14805 salt
->salt_len
= salt_len
;
14808 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14810 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14811 salt_buf_ptr
[salt_len
] = 0;
14813 // base64 decode hash
14817 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14819 uint hash_len
= input_len
- 3 - salt_len
- 1;
14821 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14823 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14825 memcpy (digest
, tmp_buf
, 32);
14828 salt
->scrypt_N
= 16384;
14829 salt
->scrypt_r
= 1;
14830 salt
->scrypt_p
= 1;
14831 salt
->salt_iter
= 1;
14833 return (PARSER_OK
);
14836 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14838 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14840 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14842 u32
*digest
= (u32
*) hash_buf
->digest
;
14844 salt_t
*salt
= hash_buf
->salt
;
14846 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14852 char *version_pos
= input_buf
+ 8 + 1;
14854 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14856 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14858 u32 version_len
= verifierHashSize_pos
- version_pos
;
14860 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14862 verifierHashSize_pos
++;
14864 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14866 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14868 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14870 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14874 char *saltSize_pos
= strchr (keySize_pos
, '*');
14876 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14878 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14880 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14884 char *osalt_pos
= strchr (saltSize_pos
, '*');
14886 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14888 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14890 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14894 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14896 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14898 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14900 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14902 encryptedVerifier_pos
++;
14904 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14906 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14908 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14910 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14912 encryptedVerifierHash_pos
++;
14914 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;
14916 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14918 const uint version
= atoi (version_pos
);
14920 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14922 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14924 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14926 const uint keySize
= atoi (keySize_pos
);
14928 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14930 office2007
->keySize
= keySize
;
14932 const uint saltSize
= atoi (saltSize_pos
);
14934 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14940 salt
->salt_len
= 16;
14941 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14943 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14944 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14945 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14946 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14952 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14953 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14954 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14955 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14957 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14958 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14959 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14960 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14961 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14967 digest
[0] = office2007
->encryptedVerifierHash
[0];
14968 digest
[1] = office2007
->encryptedVerifierHash
[1];
14969 digest
[2] = office2007
->encryptedVerifierHash
[2];
14970 digest
[3] = office2007
->encryptedVerifierHash
[3];
14972 return (PARSER_OK
);
14975 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14977 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14979 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14981 u32
*digest
= (u32
*) hash_buf
->digest
;
14983 salt_t
*salt
= hash_buf
->salt
;
14985 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14991 char *version_pos
= input_buf
+ 8 + 1;
14993 char *spinCount_pos
= strchr (version_pos
, '*');
14995 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14997 u32 version_len
= spinCount_pos
- version_pos
;
14999 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15003 char *keySize_pos
= strchr (spinCount_pos
, '*');
15005 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15007 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15009 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15013 char *saltSize_pos
= strchr (keySize_pos
, '*');
15015 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15017 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15019 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15023 char *osalt_pos
= strchr (saltSize_pos
, '*');
15025 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15027 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15029 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15033 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15035 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15037 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15039 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15041 encryptedVerifier_pos
++;
15043 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15045 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15047 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15049 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15051 encryptedVerifierHash_pos
++;
15053 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;
15055 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15057 const uint version
= atoi (version_pos
);
15059 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15061 const uint spinCount
= atoi (spinCount_pos
);
15063 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15065 const uint keySize
= atoi (keySize_pos
);
15067 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15069 const uint saltSize
= atoi (saltSize_pos
);
15071 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15077 salt
->salt_len
= 16;
15078 salt
->salt_iter
= spinCount
;
15080 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15081 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15082 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15083 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15089 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15090 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15091 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15092 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15094 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15095 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15096 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15097 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15098 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15099 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15100 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15101 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15107 digest
[0] = office2010
->encryptedVerifierHash
[0];
15108 digest
[1] = office2010
->encryptedVerifierHash
[1];
15109 digest
[2] = office2010
->encryptedVerifierHash
[2];
15110 digest
[3] = office2010
->encryptedVerifierHash
[3];
15112 return (PARSER_OK
);
15115 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15117 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15119 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15121 u32
*digest
= (u32
*) hash_buf
->digest
;
15123 salt_t
*salt
= hash_buf
->salt
;
15125 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15131 char *version_pos
= input_buf
+ 8 + 1;
15133 char *spinCount_pos
= strchr (version_pos
, '*');
15135 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15137 u32 version_len
= spinCount_pos
- version_pos
;
15139 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15143 char *keySize_pos
= strchr (spinCount_pos
, '*');
15145 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15147 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15149 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15153 char *saltSize_pos
= strchr (keySize_pos
, '*');
15155 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15157 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15159 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15163 char *osalt_pos
= strchr (saltSize_pos
, '*');
15165 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15167 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15169 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15173 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15175 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15177 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15179 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15181 encryptedVerifier_pos
++;
15183 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15185 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15187 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15189 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15191 encryptedVerifierHash_pos
++;
15193 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;
15195 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15197 const uint version
= atoi (version_pos
);
15199 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15201 const uint spinCount
= atoi (spinCount_pos
);
15203 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15205 const uint keySize
= atoi (keySize_pos
);
15207 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15209 const uint saltSize
= atoi (saltSize_pos
);
15211 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15217 salt
->salt_len
= 16;
15218 salt
->salt_iter
= spinCount
;
15220 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15221 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15222 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15223 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15229 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15230 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15231 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15232 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15234 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15235 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15236 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15237 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15238 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15239 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15240 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15241 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15247 digest
[0] = office2013
->encryptedVerifierHash
[0];
15248 digest
[1] = office2013
->encryptedVerifierHash
[1];
15249 digest
[2] = office2013
->encryptedVerifierHash
[2];
15250 digest
[3] = office2013
->encryptedVerifierHash
[3];
15252 return (PARSER_OK
);
15255 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15257 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15259 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15261 u32
*digest
= (u32
*) hash_buf
->digest
;
15263 salt_t
*salt
= hash_buf
->salt
;
15265 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15271 char *version_pos
= input_buf
+ 11;
15273 char *osalt_pos
= strchr (version_pos
, '*');
15275 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15277 u32 version_len
= osalt_pos
- version_pos
;
15279 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15283 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15285 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15287 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15289 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15291 encryptedVerifier_pos
++;
15293 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15295 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15297 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15299 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15301 encryptedVerifierHash_pos
++;
15303 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15305 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15307 const uint version
= *version_pos
- 0x30;
15309 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15315 oldoffice01
->version
= version
;
15317 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15318 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15319 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15320 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15322 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15323 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15324 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15325 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15327 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15328 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15329 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15330 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15332 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15333 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15334 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15335 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15341 salt
->salt_len
= 16;
15343 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15344 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15345 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15346 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15348 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15349 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15350 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15351 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15353 // this is a workaround as office produces multiple documents with the same salt
15355 salt
->salt_len
+= 32;
15357 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15358 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15359 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15360 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15361 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15362 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15363 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15364 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15370 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15371 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15372 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15373 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15375 return (PARSER_OK
);
15378 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15380 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15383 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15385 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15387 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15389 u32
*digest
= (u32
*) hash_buf
->digest
;
15391 salt_t
*salt
= hash_buf
->salt
;
15393 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15399 char *version_pos
= input_buf
+ 11;
15401 char *osalt_pos
= strchr (version_pos
, '*');
15403 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15405 u32 version_len
= osalt_pos
- version_pos
;
15407 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15411 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15413 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15415 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15417 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15419 encryptedVerifier_pos
++;
15421 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15423 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15425 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15427 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15429 encryptedVerifierHash_pos
++;
15431 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15433 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15435 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15437 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15441 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15443 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15445 const uint version
= *version_pos
- 0x30;
15447 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15453 oldoffice01
->version
= version
;
15455 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15456 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15457 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15458 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15460 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15461 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15462 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15463 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15465 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15466 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15467 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15468 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15470 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15471 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15472 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15473 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15475 oldoffice01
->rc4key
[1] = 0;
15476 oldoffice01
->rc4key
[0] = 0;
15478 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15479 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15480 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15481 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15482 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15483 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15484 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15485 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15486 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15487 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15489 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15490 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15496 salt
->salt_len
= 16;
15498 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15499 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15500 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15501 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15503 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15504 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15505 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15506 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15508 // this is a workaround as office produces multiple documents with the same salt
15510 salt
->salt_len
+= 32;
15512 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15513 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15514 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15515 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15516 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15517 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15518 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15519 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15525 digest
[0] = oldoffice01
->rc4key
[0];
15526 digest
[1] = oldoffice01
->rc4key
[1];
15530 return (PARSER_OK
);
15533 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15535 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15537 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15539 u32
*digest
= (u32
*) hash_buf
->digest
;
15541 salt_t
*salt
= hash_buf
->salt
;
15543 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15549 char *version_pos
= input_buf
+ 11;
15551 char *osalt_pos
= strchr (version_pos
, '*');
15553 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15555 u32 version_len
= osalt_pos
- version_pos
;
15557 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15561 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15563 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15565 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15567 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15569 encryptedVerifier_pos
++;
15571 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15573 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15575 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15577 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15579 encryptedVerifierHash_pos
++;
15581 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15583 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15585 const uint version
= *version_pos
- 0x30;
15587 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15593 oldoffice34
->version
= version
;
15595 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15596 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15597 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15598 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15600 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15601 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15602 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15603 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15605 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15606 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15607 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15608 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15609 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15611 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15612 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15613 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15614 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15615 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15621 salt
->salt_len
= 16;
15623 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15624 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15625 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15626 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15628 // this is a workaround as office produces multiple documents with the same salt
15630 salt
->salt_len
+= 32;
15632 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15633 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15634 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15635 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15636 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15637 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15638 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15639 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15645 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15646 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15647 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15648 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15650 return (PARSER_OK
);
15653 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15655 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15657 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15660 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15662 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15664 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15666 u32
*digest
= (u32
*) hash_buf
->digest
;
15668 salt_t
*salt
= hash_buf
->salt
;
15670 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15676 char *version_pos
= input_buf
+ 11;
15678 char *osalt_pos
= strchr (version_pos
, '*');
15680 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15682 u32 version_len
= osalt_pos
- version_pos
;
15684 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15688 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15690 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15692 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15694 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15696 encryptedVerifier_pos
++;
15698 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15700 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15702 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15704 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15706 encryptedVerifierHash_pos
++;
15708 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15710 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15712 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15714 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15718 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15720 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15722 const uint version
= *version_pos
- 0x30;
15724 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15730 oldoffice34
->version
= version
;
15732 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15733 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15734 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15735 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15737 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15738 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15739 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15740 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15742 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15743 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15744 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15745 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15746 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15748 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15749 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15750 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15751 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15752 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15754 oldoffice34
->rc4key
[1] = 0;
15755 oldoffice34
->rc4key
[0] = 0;
15757 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15758 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15759 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15760 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15761 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15762 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15763 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15764 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15765 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15766 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15768 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15769 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15775 salt
->salt_len
= 16;
15777 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15778 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15779 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15780 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15782 // this is a workaround as office produces multiple documents with the same salt
15784 salt
->salt_len
+= 32;
15786 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15787 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15788 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15789 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15790 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15791 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15792 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15793 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15799 digest
[0] = oldoffice34
->rc4key
[0];
15800 digest
[1] = oldoffice34
->rc4key
[1];
15804 return (PARSER_OK
);
15807 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15809 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15811 u32
*digest
= (u32
*) hash_buf
->digest
;
15813 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15814 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15815 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15816 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15818 digest
[0] = byte_swap_32 (digest
[0]);
15819 digest
[1] = byte_swap_32 (digest
[1]);
15820 digest
[2] = byte_swap_32 (digest
[2]);
15821 digest
[3] = byte_swap_32 (digest
[3]);
15823 return (PARSER_OK
);
15826 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15828 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15830 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15832 u32
*digest
= (u32
*) hash_buf
->digest
;
15834 salt_t
*salt
= hash_buf
->salt
;
15836 char *signature_pos
= input_buf
;
15838 char *salt_pos
= strchr (signature_pos
, '$');
15840 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15842 u32 signature_len
= salt_pos
- signature_pos
;
15844 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15848 char *hash_pos
= strchr (salt_pos
, '$');
15850 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15852 u32 salt_len
= hash_pos
- salt_pos
;
15854 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15858 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15860 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15862 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15863 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15864 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15865 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15866 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15868 digest
[0] -= SHA1M_A
;
15869 digest
[1] -= SHA1M_B
;
15870 digest
[2] -= SHA1M_C
;
15871 digest
[3] -= SHA1M_D
;
15872 digest
[4] -= SHA1M_E
;
15874 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15876 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15878 salt
->salt_len
= salt_len
;
15880 return (PARSER_OK
);
15883 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15885 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15887 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15889 u32
*digest
= (u32
*) hash_buf
->digest
;
15891 salt_t
*salt
= hash_buf
->salt
;
15893 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15899 char *iter_pos
= input_buf
+ 14;
15901 const int iter
= atoi (iter_pos
);
15903 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15905 salt
->salt_iter
= iter
- 1;
15907 char *salt_pos
= strchr (iter_pos
, '$');
15909 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15913 char *hash_pos
= strchr (salt_pos
, '$');
15915 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15917 const uint salt_len
= hash_pos
- salt_pos
;
15921 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15923 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15925 salt
->salt_len
= salt_len
;
15927 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15928 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15930 // add some stuff to normal salt to make sorted happy
15932 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15933 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15934 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15935 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15936 salt
->salt_buf
[4] = salt
->salt_iter
;
15938 // base64 decode hash
15942 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15944 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15946 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15948 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15950 memcpy (digest
, tmp_buf
, 32);
15952 digest
[0] = byte_swap_32 (digest
[0]);
15953 digest
[1] = byte_swap_32 (digest
[1]);
15954 digest
[2] = byte_swap_32 (digest
[2]);
15955 digest
[3] = byte_swap_32 (digest
[3]);
15956 digest
[4] = byte_swap_32 (digest
[4]);
15957 digest
[5] = byte_swap_32 (digest
[5]);
15958 digest
[6] = byte_swap_32 (digest
[6]);
15959 digest
[7] = byte_swap_32 (digest
[7]);
15961 return (PARSER_OK
);
15964 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15966 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15968 u32
*digest
= (u32
*) hash_buf
->digest
;
15970 salt_t
*salt
= hash_buf
->salt
;
15972 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15973 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15977 digest
[0] = byte_swap_32 (digest
[0]);
15978 digest
[1] = byte_swap_32 (digest
[1]);
15980 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15981 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15982 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15984 char iter_c
= input_buf
[17];
15985 char iter_d
= input_buf
[19];
15987 // atm only defaults, let's see if there's more request
15988 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15989 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15991 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15993 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15994 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15995 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15996 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15998 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15999 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16000 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16001 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16003 salt
->salt_len
= 16;
16005 return (PARSER_OK
);
16008 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16010 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16012 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16014 u32
*digest
= (u32
*) hash_buf
->digest
;
16016 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16018 salt_t
*salt
= hash_buf
->salt
;
16020 char *salt_pos
= input_buf
+ 10;
16022 char *hash_pos
= strchr (salt_pos
, '$');
16024 uint salt_len
= hash_pos
- salt_pos
;
16026 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16030 uint hash_len
= input_len
- 10 - salt_len
- 1;
16032 // base64 decode salt
16036 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16038 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16040 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16042 tmp_buf
[salt_len
] = 0x80;
16044 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16046 salt
->salt_len
= salt_len
;
16048 // base64 decode salt
16050 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16052 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16054 uint user_len
= hash_len
- 32;
16056 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16058 user_len
--; // skip the trailing space
16060 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16061 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16062 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16063 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16065 digest
[0] = byte_swap_32 (digest
[0]);
16066 digest
[1] = byte_swap_32 (digest
[1]);
16067 digest
[2] = byte_swap_32 (digest
[2]);
16068 digest
[3] = byte_swap_32 (digest
[3]);
16070 // store username for host only (output hash if cracked)
16072 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16073 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16075 return (PARSER_OK
);
16078 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16080 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16082 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16084 u32
*digest
= (u32
*) hash_buf
->digest
;
16086 salt_t
*salt
= hash_buf
->salt
;
16088 char *iter_pos
= input_buf
+ 10;
16090 u32 iter
= atoi (iter_pos
);
16094 return (PARSER_SALT_ITERATION
);
16097 iter
--; // first iteration is special
16099 salt
->salt_iter
= iter
;
16101 char *base64_pos
= strchr (iter_pos
, '}');
16103 if (base64_pos
== NULL
)
16105 return (PARSER_SIGNATURE_UNMATCHED
);
16110 // base64 decode salt
16112 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16116 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16118 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16120 if (decoded_len
< 24)
16122 return (PARSER_SALT_LENGTH
);
16127 uint salt_len
= decoded_len
- 20;
16129 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16130 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16132 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16134 salt
->salt_len
= salt_len
;
16138 u32
*digest_ptr
= (u32
*) tmp_buf
;
16140 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16141 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16142 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16143 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16144 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16146 return (PARSER_OK
);
16149 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16151 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16153 u32
*digest
= (u32
*) hash_buf
->digest
;
16155 salt_t
*salt
= hash_buf
->salt
;
16157 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16158 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16159 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16160 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16161 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16163 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16165 uint salt_len
= input_len
- 40 - 1;
16167 char *salt_buf
= input_buf
+ 40 + 1;
16169 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16171 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16173 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16175 salt
->salt_len
= salt_len
;
16177 return (PARSER_OK
);
16180 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16182 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16184 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16186 u32
*digest
= (u32
*) hash_buf
->digest
;
16188 salt_t
*salt
= hash_buf
->salt
;
16190 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16196 char *V_pos
= input_buf
+ 5;
16198 char *R_pos
= strchr (V_pos
, '*');
16200 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16202 u32 V_len
= R_pos
- V_pos
;
16206 char *bits_pos
= strchr (R_pos
, '*');
16208 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16210 u32 R_len
= bits_pos
- R_pos
;
16214 char *P_pos
= strchr (bits_pos
, '*');
16216 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16218 u32 bits_len
= P_pos
- bits_pos
;
16222 char *enc_md_pos
= strchr (P_pos
, '*');
16224 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16226 u32 P_len
= enc_md_pos
- P_pos
;
16230 char *id_len_pos
= strchr (enc_md_pos
, '*');
16232 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16234 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16238 char *id_buf_pos
= strchr (id_len_pos
, '*');
16240 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16242 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16246 char *u_len_pos
= strchr (id_buf_pos
, '*');
16248 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16250 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16252 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16256 char *u_buf_pos
= strchr (u_len_pos
, '*');
16258 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16260 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16264 char *o_len_pos
= strchr (u_buf_pos
, '*');
16266 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16268 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16270 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16274 char *o_buf_pos
= strchr (o_len_pos
, '*');
16276 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16278 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16282 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;
16284 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16288 const int V
= atoi (V_pos
);
16289 const int R
= atoi (R_pos
);
16290 const int P
= atoi (P_pos
);
16292 if (V
!= 1) return (PARSER_SALT_VALUE
);
16293 if (R
!= 2) return (PARSER_SALT_VALUE
);
16295 const int enc_md
= atoi (enc_md_pos
);
16297 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16299 const int id_len
= atoi (id_len_pos
);
16300 const int u_len
= atoi (u_len_pos
);
16301 const int o_len
= atoi (o_len_pos
);
16303 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16304 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16305 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16307 const int bits
= atoi (bits_pos
);
16309 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16311 // copy data to esalt
16317 pdf
->enc_md
= enc_md
;
16319 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16320 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16321 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16322 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16323 pdf
->id_len
= id_len
;
16325 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16326 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16327 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16328 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16329 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16330 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16331 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16332 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16333 pdf
->u_len
= u_len
;
16335 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16336 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16337 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16338 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16339 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16340 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16341 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16342 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16343 pdf
->o_len
= o_len
;
16345 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16346 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16347 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16348 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16350 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16351 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16352 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16353 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16354 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16355 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16356 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16357 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16359 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16360 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16361 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16362 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16363 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16364 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16365 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16366 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16368 // we use ID for salt, maybe needs to change, we will see...
16370 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16371 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16372 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16373 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16374 salt
->salt_len
= pdf
->id_len
;
16376 digest
[0] = pdf
->u_buf
[0];
16377 digest
[1] = pdf
->u_buf
[1];
16378 digest
[2] = pdf
->u_buf
[2];
16379 digest
[3] = pdf
->u_buf
[3];
16381 return (PARSER_OK
);
16384 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16386 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16389 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16391 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16393 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16395 u32
*digest
= (u32
*) hash_buf
->digest
;
16397 salt_t
*salt
= hash_buf
->salt
;
16399 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16405 char *V_pos
= input_buf
+ 5;
16407 char *R_pos
= strchr (V_pos
, '*');
16409 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16411 u32 V_len
= R_pos
- V_pos
;
16415 char *bits_pos
= strchr (R_pos
, '*');
16417 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16419 u32 R_len
= bits_pos
- R_pos
;
16423 char *P_pos
= strchr (bits_pos
, '*');
16425 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16427 u32 bits_len
= P_pos
- bits_pos
;
16431 char *enc_md_pos
= strchr (P_pos
, '*');
16433 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16435 u32 P_len
= enc_md_pos
- P_pos
;
16439 char *id_len_pos
= strchr (enc_md_pos
, '*');
16441 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16443 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16447 char *id_buf_pos
= strchr (id_len_pos
, '*');
16449 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16451 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16455 char *u_len_pos
= strchr (id_buf_pos
, '*');
16457 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16459 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16461 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16465 char *u_buf_pos
= strchr (u_len_pos
, '*');
16467 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16469 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16473 char *o_len_pos
= strchr (u_buf_pos
, '*');
16475 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16477 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16479 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16483 char *o_buf_pos
= strchr (o_len_pos
, '*');
16485 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16487 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16491 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16493 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16495 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16497 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16501 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;
16503 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16507 const int V
= atoi (V_pos
);
16508 const int R
= atoi (R_pos
);
16509 const int P
= atoi (P_pos
);
16511 if (V
!= 1) return (PARSER_SALT_VALUE
);
16512 if (R
!= 2) return (PARSER_SALT_VALUE
);
16514 const int enc_md
= atoi (enc_md_pos
);
16516 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16518 const int id_len
= atoi (id_len_pos
);
16519 const int u_len
= atoi (u_len_pos
);
16520 const int o_len
= atoi (o_len_pos
);
16522 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16523 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16524 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16526 const int bits
= atoi (bits_pos
);
16528 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16530 // copy data to esalt
16536 pdf
->enc_md
= enc_md
;
16538 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16539 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16540 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16541 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16542 pdf
->id_len
= id_len
;
16544 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16545 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16546 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16547 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16548 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16549 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16550 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16551 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16552 pdf
->u_len
= u_len
;
16554 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16555 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16556 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16557 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16558 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16559 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16560 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16561 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16562 pdf
->o_len
= o_len
;
16564 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16565 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16566 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16567 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16569 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16570 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16571 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16572 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16573 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16574 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16575 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16576 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16578 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16579 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16580 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16581 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16582 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16583 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16584 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16585 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16587 pdf
->rc4key
[1] = 0;
16588 pdf
->rc4key
[0] = 0;
16590 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16591 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16592 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16593 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16594 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16595 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16596 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16597 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16598 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16599 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16601 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16602 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16604 // we use ID for salt, maybe needs to change, we will see...
16606 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16607 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16608 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16609 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16610 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16611 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16612 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16613 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16614 salt
->salt_len
= pdf
->id_len
+ 16;
16616 digest
[0] = pdf
->rc4key
[0];
16617 digest
[1] = pdf
->rc4key
[1];
16621 return (PARSER_OK
);
16624 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16626 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16628 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16630 u32
*digest
= (u32
*) hash_buf
->digest
;
16632 salt_t
*salt
= hash_buf
->salt
;
16634 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16640 char *V_pos
= input_buf
+ 5;
16642 char *R_pos
= strchr (V_pos
, '*');
16644 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16646 u32 V_len
= R_pos
- V_pos
;
16650 char *bits_pos
= strchr (R_pos
, '*');
16652 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16654 u32 R_len
= bits_pos
- R_pos
;
16658 char *P_pos
= strchr (bits_pos
, '*');
16660 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16662 u32 bits_len
= P_pos
- bits_pos
;
16666 char *enc_md_pos
= strchr (P_pos
, '*');
16668 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16670 u32 P_len
= enc_md_pos
- P_pos
;
16674 char *id_len_pos
= strchr (enc_md_pos
, '*');
16676 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16678 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16682 char *id_buf_pos
= strchr (id_len_pos
, '*');
16684 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16686 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16690 char *u_len_pos
= strchr (id_buf_pos
, '*');
16692 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16694 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16696 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16700 char *u_buf_pos
= strchr (u_len_pos
, '*');
16702 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16704 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16708 char *o_len_pos
= strchr (u_buf_pos
, '*');
16710 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16712 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16714 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16718 char *o_buf_pos
= strchr (o_len_pos
, '*');
16720 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16722 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16726 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;
16728 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16732 const int V
= atoi (V_pos
);
16733 const int R
= atoi (R_pos
);
16734 const int P
= atoi (P_pos
);
16738 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16739 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16741 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16743 const int id_len
= atoi (id_len_pos
);
16744 const int u_len
= atoi (u_len_pos
);
16745 const int o_len
= atoi (o_len_pos
);
16747 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16749 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16750 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16752 const int bits
= atoi (bits_pos
);
16754 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16760 enc_md
= atoi (enc_md_pos
);
16763 // copy data to esalt
16769 pdf
->enc_md
= enc_md
;
16771 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16772 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16773 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16774 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16778 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16779 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16780 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16781 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16784 pdf
->id_len
= id_len
;
16786 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16787 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16788 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16789 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16790 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16791 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16792 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16793 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16794 pdf
->u_len
= u_len
;
16796 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16797 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16798 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16799 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16800 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16801 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16802 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16803 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16804 pdf
->o_len
= o_len
;
16806 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16807 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16808 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16809 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16813 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16814 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16815 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16816 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16819 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16820 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16821 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16822 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16823 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16824 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16825 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16826 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16828 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16829 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16830 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16831 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16832 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16833 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16834 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16835 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16837 // precompute rc4 data for later use
16853 uint salt_pc_block
[32];
16855 char *salt_pc_ptr
= (char *) salt_pc_block
;
16857 memcpy (salt_pc_ptr
, padding
, 32);
16858 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16860 uint salt_pc_digest
[4];
16862 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16864 pdf
->rc4data
[0] = salt_pc_digest
[0];
16865 pdf
->rc4data
[1] = salt_pc_digest
[1];
16867 // we use ID for salt, maybe needs to change, we will see...
16869 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16870 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16871 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16872 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16873 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16874 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16875 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16876 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16877 salt
->salt_len
= pdf
->id_len
+ 16;
16879 salt
->salt_iter
= ROUNDS_PDF14
;
16881 digest
[0] = pdf
->u_buf
[0];
16882 digest
[1] = pdf
->u_buf
[1];
16886 return (PARSER_OK
);
16889 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16891 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16893 if (ret
!= PARSER_OK
)
16898 u32
*digest
= (u32
*) hash_buf
->digest
;
16900 salt_t
*salt
= hash_buf
->salt
;
16902 digest
[0] -= SHA256M_A
;
16903 digest
[1] -= SHA256M_B
;
16904 digest
[2] -= SHA256M_C
;
16905 digest
[3] -= SHA256M_D
;
16906 digest
[4] -= SHA256M_E
;
16907 digest
[5] -= SHA256M_F
;
16908 digest
[6] -= SHA256M_G
;
16909 digest
[7] -= SHA256M_H
;
16911 salt
->salt_buf
[2] = 0x80;
16913 return (PARSER_OK
);
16916 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16918 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16920 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16922 u32
*digest
= (u32
*) hash_buf
->digest
;
16924 salt_t
*salt
= hash_buf
->salt
;
16926 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16932 char *V_pos
= input_buf
+ 5;
16934 char *R_pos
= strchr (V_pos
, '*');
16936 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16938 u32 V_len
= R_pos
- V_pos
;
16942 char *bits_pos
= strchr (R_pos
, '*');
16944 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16946 u32 R_len
= bits_pos
- R_pos
;
16950 char *P_pos
= strchr (bits_pos
, '*');
16952 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16954 u32 bits_len
= P_pos
- bits_pos
;
16958 char *enc_md_pos
= strchr (P_pos
, '*');
16960 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16962 u32 P_len
= enc_md_pos
- P_pos
;
16966 char *id_len_pos
= strchr (enc_md_pos
, '*');
16968 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16970 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16974 char *id_buf_pos
= strchr (id_len_pos
, '*');
16976 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16978 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16982 char *u_len_pos
= strchr (id_buf_pos
, '*');
16984 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16986 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16990 char *u_buf_pos
= strchr (u_len_pos
, '*');
16992 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16994 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16998 char *o_len_pos
= strchr (u_buf_pos
, '*');
17000 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17002 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17006 char *o_buf_pos
= strchr (o_len_pos
, '*');
17008 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17010 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17014 char *last
= strchr (o_buf_pos
, '*');
17016 if (last
== NULL
) last
= input_buf
+ input_len
;
17018 u32 o_buf_len
= last
- o_buf_pos
;
17022 const int V
= atoi (V_pos
);
17023 const int R
= atoi (R_pos
);
17027 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17028 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17030 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17032 const int bits
= atoi (bits_pos
);
17034 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17036 int enc_md
= atoi (enc_md_pos
);
17038 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17040 const uint id_len
= atoi (id_len_pos
);
17041 const uint u_len
= atoi (u_len_pos
);
17042 const uint o_len
= atoi (o_len_pos
);
17044 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17045 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17046 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17047 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17048 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17049 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17050 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17051 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17053 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17054 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17055 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17057 // copy data to esalt
17059 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17061 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17063 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17066 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17067 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17069 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17070 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17072 salt
->salt_len
= 8;
17073 salt
->salt_iter
= ROUNDS_PDF17L8
;
17075 digest
[0] = pdf
->u_buf
[0];
17076 digest
[1] = pdf
->u_buf
[1];
17077 digest
[2] = pdf
->u_buf
[2];
17078 digest
[3] = pdf
->u_buf
[3];
17079 digest
[4] = pdf
->u_buf
[4];
17080 digest
[5] = pdf
->u_buf
[5];
17081 digest
[6] = pdf
->u_buf
[6];
17082 digest
[7] = pdf
->u_buf
[7];
17084 return (PARSER_OK
);
17087 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17089 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17091 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17093 u32
*digest
= (u32
*) hash_buf
->digest
;
17095 salt_t
*salt
= hash_buf
->salt
;
17097 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17105 char *iter_pos
= input_buf
+ 7;
17107 u32 iter
= atoi (iter_pos
);
17109 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17110 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17112 // first is *raw* salt
17114 char *salt_pos
= strchr (iter_pos
, ':');
17116 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17120 char *hash_pos
= strchr (salt_pos
, ':');
17122 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17124 u32 salt_len
= hash_pos
- salt_pos
;
17126 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17130 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17132 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17136 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17138 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17140 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17142 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17143 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17145 salt
->salt_len
= salt_len
;
17146 salt
->salt_iter
= iter
- 1;
17152 memset (tmp_buf
, 0, sizeof (tmp_buf
));
17154 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17156 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17158 memcpy (digest
, tmp_buf
, 16);
17160 digest
[0] = byte_swap_32 (digest
[0]);
17161 digest
[1] = byte_swap_32 (digest
[1]);
17162 digest
[2] = byte_swap_32 (digest
[2]);
17163 digest
[3] = byte_swap_32 (digest
[3]);
17165 // add some stuff to normal salt to make sorted happy
17167 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17168 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17169 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17170 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17171 salt
->salt_buf
[4] = salt
->salt_iter
;
17173 return (PARSER_OK
);
17176 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17178 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17180 u32
*digest
= (u32
*) hash_buf
->digest
;
17182 salt_t
*salt
= hash_buf
->salt
;
17184 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17185 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17186 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17187 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17189 digest
[0] = byte_swap_32 (digest
[0]);
17190 digest
[1] = byte_swap_32 (digest
[1]);
17191 digest
[2] = byte_swap_32 (digest
[2]);
17192 digest
[3] = byte_swap_32 (digest
[3]);
17194 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17196 uint salt_len
= input_len
- 32 - 1;
17198 char *salt_buf
= input_buf
+ 32 + 1;
17200 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17202 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17204 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17206 salt
->salt_len
= salt_len
;
17208 return (PARSER_OK
);
17211 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17213 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17215 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17217 u32
*digest
= (u32
*) hash_buf
->digest
;
17219 salt_t
*salt
= hash_buf
->salt
;
17221 char *user_pos
= input_buf
+ 10;
17223 char *salt_pos
= strchr (user_pos
, '*');
17225 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17229 char *hash_pos
= strchr (salt_pos
, '*');
17233 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17235 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17237 uint user_len
= salt_pos
- user_pos
- 1;
17239 uint salt_len
= hash_pos
- salt_pos
- 1;
17241 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17247 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17248 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17249 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17250 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17252 digest
[0] = byte_swap_32 (digest
[0]);
17253 digest
[1] = byte_swap_32 (digest
[1]);
17254 digest
[2] = byte_swap_32 (digest
[2]);
17255 digest
[3] = byte_swap_32 (digest
[3]);
17257 digest
[0] -= MD5M_A
;
17258 digest
[1] -= MD5M_B
;
17259 digest
[2] -= MD5M_C
;
17260 digest
[3] -= MD5M_D
;
17266 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17268 // first 4 bytes are the "challenge"
17270 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17271 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17272 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17273 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17275 // append the user name
17277 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17279 salt
->salt_len
= 4 + user_len
;
17281 return (PARSER_OK
);
17284 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17286 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17288 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17290 u32
*digest
= (u32
*) hash_buf
->digest
;
17292 salt_t
*salt
= hash_buf
->salt
;
17294 char *salt_pos
= input_buf
+ 9;
17296 char *hash_pos
= strchr (salt_pos
, '*');
17298 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17302 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17304 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17306 uint salt_len
= hash_pos
- salt_pos
- 1;
17308 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17314 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17315 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17316 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17317 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17318 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17324 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17326 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17328 salt
->salt_len
= salt_len
;
17330 return (PARSER_OK
);
17333 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17335 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17337 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17339 u32
*digest
= (u32
*) hash_buf
->digest
;
17341 salt_t
*salt
= hash_buf
->salt
;
17343 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17349 char *cry_master_len_pos
= input_buf
+ 9;
17351 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17353 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17355 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17357 cry_master_buf_pos
++;
17359 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17361 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17363 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17365 cry_salt_len_pos
++;
17367 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17369 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17371 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17373 cry_salt_buf_pos
++;
17375 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17377 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17379 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17383 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17385 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17387 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17391 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17393 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17395 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17399 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17401 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17403 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17405 public_key_len_pos
++;
17407 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17409 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17411 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17413 public_key_buf_pos
++;
17415 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;
17417 const uint cry_master_len
= atoi (cry_master_len_pos
);
17418 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17419 const uint ckey_len
= atoi (ckey_len_pos
);
17420 const uint public_key_len
= atoi (public_key_len_pos
);
17422 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17423 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17424 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17425 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17427 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17429 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17431 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17434 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17436 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17438 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17441 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17443 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17445 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17448 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17449 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17450 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17453 * store digest (should be unique enought, hopefully)
17456 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17457 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17458 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17459 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17465 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17467 const uint cry_rounds
= atoi (cry_rounds_pos
);
17469 salt
->salt_iter
= cry_rounds
- 1;
17471 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17473 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17475 salt
->salt_len
= salt_len
;
17477 return (PARSER_OK
);
17480 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17482 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17484 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17486 u32
*digest
= (u32
*) hash_buf
->digest
;
17488 salt_t
*salt
= hash_buf
->salt
;
17490 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17492 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17494 char temp_input_buf
[input_len
+ 1];
17496 memset (temp_input_buf
, 0, sizeof (temp_input_buf
));
17497 memcpy (temp_input_buf
, input_buf
, input_len
);
17501 char *URI_server_pos
= temp_input_buf
+ 6;
17503 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17505 if (URI_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17507 URI_client_pos
[0] = 0;
17510 uint URI_server_len
= strlen (URI_server_pos
);
17512 if (URI_server_len
> 512) return (PARSER_SALT_LENGTH
);
17516 char *user_pos
= strchr (URI_client_pos
, '*');
17518 if (user_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17523 uint URI_client_len
= strlen (URI_client_pos
);
17525 if (URI_client_len
> 512) return (PARSER_SALT_LENGTH
);
17529 char *realm_pos
= strchr (user_pos
, '*');
17531 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17536 uint user_len
= strlen (user_pos
);
17538 if (user_len
> 116) return (PARSER_SALT_LENGTH
);
17542 char *method_pos
= strchr (realm_pos
, '*');
17544 if (method_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17549 uint realm_len
= strlen (realm_pos
);
17551 if (realm_len
> 116) return (PARSER_SALT_LENGTH
);
17555 char *URI_prefix_pos
= strchr (method_pos
, '*');
17557 if (URI_prefix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17559 URI_prefix_pos
[0] = 0;
17562 uint method_len
= strlen (method_pos
);
17564 if (method_len
> 246) return (PARSER_SALT_LENGTH
);
17568 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17570 if (URI_resource_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17572 URI_resource_pos
[0] = 0;
17573 URI_resource_pos
++;
17575 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17577 if (URI_prefix_len
> 245) return (PARSER_SALT_LENGTH
);
17581 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17583 if (URI_suffix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17585 URI_suffix_pos
[0] = 0;
17588 uint URI_resource_len
= strlen (URI_resource_pos
);
17590 if (URI_resource_len
< 1) return (PARSER_SALT_LENGTH
);
17591 if (URI_resource_len
> 246) return (PARSER_SALT_LENGTH
);
17595 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17597 if (nonce_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17602 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17604 if (URI_suffix_len
> 245) return (PARSER_SALT_LENGTH
);
17608 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17610 if (nonce_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17612 nonce_client_pos
[0] = 0;
17613 nonce_client_pos
++;
17615 uint nonce_len
= strlen (nonce_pos
);
17617 if (nonce_len
< 1) return (PARSER_SALT_LENGTH
);
17618 if (nonce_len
> 50) return (PARSER_SALT_LENGTH
);
17622 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17624 if (nonce_count_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17626 nonce_count_pos
[0] = 0;
17629 uint nonce_client_len
= strlen (nonce_client_pos
);
17631 if (nonce_client_len
> 50) return (PARSER_SALT_LENGTH
);
17635 char *qop_pos
= strchr (nonce_count_pos
, '*');
17637 if (qop_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17642 uint nonce_count_len
= strlen (nonce_count_pos
);
17644 if (nonce_count_len
> 50) return (PARSER_SALT_LENGTH
);
17648 char *directive_pos
= strchr (qop_pos
, '*');
17650 if (directive_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17652 directive_pos
[0] = 0;
17655 uint qop_len
= strlen (qop_pos
);
17657 if (qop_len
> 50) return (PARSER_SALT_LENGTH
);
17661 char *digest_pos
= strchr (directive_pos
, '*');
17663 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17668 uint directive_len
= strlen (directive_pos
);
17670 if (directive_len
!= 3) return (PARSER_SALT_LENGTH
);
17672 if (memcmp (directive_pos
, "MD5", 3))
17674 log_info ("ERROR: only the MD5 directive is currently supported\n");
17676 return (PARSER_SIP_AUTH_DIRECTIVE
);
17680 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17685 uint md5_max_len
= 4 * 64;
17687 uint md5_remaining_len
= md5_max_len
;
17689 uint tmp_md5_buf
[md5_max_len
/ 4];
17691 memset (tmp_md5_buf
, 0, sizeof (tmp_md5_buf
));
17693 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17695 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17697 md5_len
+= method_len
+ 1;
17698 tmp_md5_ptr
+= method_len
+ 1;
17700 if (URI_prefix_len
> 0)
17702 md5_remaining_len
= md5_max_len
- md5_len
;
17704 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17706 md5_len
+= URI_prefix_len
+ 1;
17707 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17710 md5_remaining_len
= md5_max_len
- md5_len
;
17712 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17714 md5_len
+= URI_resource_len
;
17715 tmp_md5_ptr
+= URI_resource_len
;
17717 if (URI_suffix_len
> 0)
17719 md5_remaining_len
= md5_max_len
- md5_len
;
17721 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17723 md5_len
+= 1 + URI_suffix_len
;
17726 uint tmp_digest
[4];
17728 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17730 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17731 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17732 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17733 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17739 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17741 uint esalt_len
= 0;
17743 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17745 // there are 2 possibilities for the esalt:
17747 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17749 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17751 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17753 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17765 esalt_len
= 1 + nonce_len
+ 1 + 32;
17767 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17769 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17777 // add 0x80 to esalt
17779 esalt_buf_ptr
[esalt_len
] = 0x80;
17781 sip
->esalt_len
= esalt_len
;
17787 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17789 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17791 uint max_salt_len
= 119;
17793 if (salt_len
> max_salt_len
) return (PARSER_SALT_LENGTH
);
17795 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17797 sip
->salt_len
= salt_len
;
17800 * fake salt (for sorting)
17803 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17807 uint fake_salt_len
= salt_len
;
17809 if (fake_salt_len
> max_salt_len
)
17811 fake_salt_len
= max_salt_len
;
17814 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17816 salt
->salt_len
= fake_salt_len
;
17822 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17823 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17824 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17825 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17827 digest
[0] = byte_swap_32 (digest
[0]);
17828 digest
[1] = byte_swap_32 (digest
[1]);
17829 digest
[2] = byte_swap_32 (digest
[2]);
17830 digest
[3] = byte_swap_32 (digest
[3]);
17832 return (PARSER_OK
);
17835 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17837 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17839 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17841 u32
*digest
= (u32
*) hash_buf
->digest
;
17843 salt_t
*salt
= hash_buf
->salt
;
17847 char *digest_pos
= input_buf
;
17849 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17856 char *salt_buf
= input_buf
+ 8 + 1;
17860 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17862 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17864 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17866 salt
->salt_len
= salt_len
;
17868 return (PARSER_OK
);
17871 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17873 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17875 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17877 u32
*digest
= (u32
*) hash_buf
->digest
;
17879 salt_t
*salt
= hash_buf
->salt
;
17881 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17887 char *p_buf_pos
= input_buf
+ 4;
17889 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17891 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17893 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17895 NumCyclesPower_pos
++;
17897 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17899 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17901 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17905 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17907 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17909 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
17913 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17915 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17917 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17921 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17923 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17925 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
17929 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17931 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17933 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17937 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17939 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17941 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
17945 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17947 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17949 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
17953 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17955 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17957 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17961 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;
17963 const uint iter
= atoi (NumCyclesPower_pos
);
17964 const uint crc
= atoi (crc_buf_pos
);
17965 const uint p_buf
= atoi (p_buf_pos
);
17966 const uint salt_len
= atoi (salt_len_pos
);
17967 const uint iv_len
= atoi (iv_len_pos
);
17968 const uint unpack_size
= atoi (unpack_size_pos
);
17969 const uint data_len
= atoi (data_len_pos
);
17975 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
17976 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
17978 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
17980 if (data_len
> 384) return (PARSER_SALT_VALUE
);
17982 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
17988 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
17989 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
17990 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
17991 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
17993 seven_zip
->iv_len
= iv_len
;
17995 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
17997 seven_zip
->salt_len
= 0;
17999 seven_zip
->crc
= crc
;
18001 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18003 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18005 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18008 seven_zip
->data_len
= data_len
;
18010 seven_zip
->unpack_size
= unpack_size
;
18014 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18015 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18016 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18017 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18019 salt
->salt_len
= 16;
18021 salt
->salt_sign
[0] = iter
;
18023 salt
->salt_iter
= 1 << iter
;
18034 return (PARSER_OK
);
18037 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18039 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18041 u32
*digest
= (u32
*) hash_buf
->digest
;
18043 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18044 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18045 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18046 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18047 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18048 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18049 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18050 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18052 digest
[0] = byte_swap_32 (digest
[0]);
18053 digest
[1] = byte_swap_32 (digest
[1]);
18054 digest
[2] = byte_swap_32 (digest
[2]);
18055 digest
[3] = byte_swap_32 (digest
[3]);
18056 digest
[4] = byte_swap_32 (digest
[4]);
18057 digest
[5] = byte_swap_32 (digest
[5]);
18058 digest
[6] = byte_swap_32 (digest
[6]);
18059 digest
[7] = byte_swap_32 (digest
[7]);
18061 return (PARSER_OK
);
18064 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18066 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18068 u32
*digest
= (u32
*) hash_buf
->digest
;
18070 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18071 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18072 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18073 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18074 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18075 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18076 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18077 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18078 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18079 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18080 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18081 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18082 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18083 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18084 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18085 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18087 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18088 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18089 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18090 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18091 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18092 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18093 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18094 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18095 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18096 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18097 digest
[10] = byte_swap_32 (digest
[10]);
18098 digest
[11] = byte_swap_32 (digest
[11]);
18099 digest
[12] = byte_swap_32 (digest
[12]);
18100 digest
[13] = byte_swap_32 (digest
[13]);
18101 digest
[14] = byte_swap_32 (digest
[14]);
18102 digest
[15] = byte_swap_32 (digest
[15]);
18104 return (PARSER_OK
);
18107 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18109 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18111 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18113 u32
*digest
= (u32
*) hash_buf
->digest
;
18115 salt_t
*salt
= hash_buf
->salt
;
18117 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18125 char *iter_pos
= input_buf
+ 4;
18127 u32 iter
= atoi (iter_pos
);
18129 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18130 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18132 // first is *raw* salt
18134 char *salt_pos
= strchr (iter_pos
, ':');
18136 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18140 char *hash_pos
= strchr (salt_pos
, ':');
18142 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18144 u32 salt_len
= hash_pos
- salt_pos
;
18146 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18150 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18152 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18156 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18158 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18160 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18162 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18163 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18165 salt
->salt_len
= salt_len
;
18166 salt
->salt_iter
= iter
- 1;
18172 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18174 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18176 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18178 memcpy (digest
, tmp_buf
, 16);
18180 // add some stuff to normal salt to make sorted happy
18182 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18183 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18184 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18185 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18186 salt
->salt_buf
[4] = salt
->salt_iter
;
18188 return (PARSER_OK
);
18191 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18193 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18195 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18197 u32
*digest
= (u32
*) hash_buf
->digest
;
18199 salt_t
*salt
= hash_buf
->salt
;
18201 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18209 char *iter_pos
= input_buf
+ 5;
18211 u32 iter
= atoi (iter_pos
);
18213 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18214 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18216 // first is *raw* salt
18218 char *salt_pos
= strchr (iter_pos
, ':');
18220 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18224 char *hash_pos
= strchr (salt_pos
, ':');
18226 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18228 u32 salt_len
= hash_pos
- salt_pos
;
18230 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18234 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18236 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18240 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18242 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18244 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18246 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18247 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18249 salt
->salt_len
= salt_len
;
18250 salt
->salt_iter
= iter
- 1;
18256 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18258 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18260 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18262 memcpy (digest
, tmp_buf
, 16);
18264 digest
[0] = byte_swap_32 (digest
[0]);
18265 digest
[1] = byte_swap_32 (digest
[1]);
18266 digest
[2] = byte_swap_32 (digest
[2]);
18267 digest
[3] = byte_swap_32 (digest
[3]);
18269 // add some stuff to normal salt to make sorted happy
18271 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18272 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18273 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18274 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18275 salt
->salt_buf
[4] = salt
->salt_iter
;
18277 return (PARSER_OK
);
18280 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18282 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18284 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18286 u64
*digest
= (u64
*) hash_buf
->digest
;
18288 salt_t
*salt
= hash_buf
->salt
;
18290 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18298 char *iter_pos
= input_buf
+ 7;
18300 u32 iter
= atoi (iter_pos
);
18302 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18303 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18305 // first is *raw* salt
18307 char *salt_pos
= strchr (iter_pos
, ':');
18309 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18313 char *hash_pos
= strchr (salt_pos
, ':');
18315 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18317 u32 salt_len
= hash_pos
- salt_pos
;
18319 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18323 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18325 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18329 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18331 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18333 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18335 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18336 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18338 salt
->salt_len
= salt_len
;
18339 salt
->salt_iter
= iter
- 1;
18345 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18347 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18349 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18351 memcpy (digest
, tmp_buf
, 64);
18353 digest
[0] = byte_swap_64 (digest
[0]);
18354 digest
[1] = byte_swap_64 (digest
[1]);
18355 digest
[2] = byte_swap_64 (digest
[2]);
18356 digest
[3] = byte_swap_64 (digest
[3]);
18357 digest
[4] = byte_swap_64 (digest
[4]);
18358 digest
[5] = byte_swap_64 (digest
[5]);
18359 digest
[6] = byte_swap_64 (digest
[6]);
18360 digest
[7] = byte_swap_64 (digest
[7]);
18362 // add some stuff to normal salt to make sorted happy
18364 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18365 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18366 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18367 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18368 salt
->salt_buf
[4] = salt
->salt_iter
;
18370 return (PARSER_OK
);
18373 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18375 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18377 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18379 uint
*digest
= (uint
*) hash_buf
->digest
;
18381 salt_t
*salt
= hash_buf
->salt
;
18387 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18389 char *hash_pos
= strchr (salt_pos
, '$');
18391 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18393 u32 salt_len
= hash_pos
- salt_pos
;
18395 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18399 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18401 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18405 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18406 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18424 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18425 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18427 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18428 salt
->salt_len
= 8;
18430 return (PARSER_OK
);
18433 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18435 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18437 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18439 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18441 if (c19
& 3) return (PARSER_HASH_VALUE
);
18443 salt_t
*salt
= hash_buf
->salt
;
18445 u32
*digest
= (u32
*) hash_buf
->digest
;
18449 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18450 | itoa64_to_int (input_buf
[2]) << 6
18451 | itoa64_to_int (input_buf
[3]) << 12
18452 | itoa64_to_int (input_buf
[4]) << 18;
18456 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18457 | itoa64_to_int (input_buf
[6]) << 6
18458 | itoa64_to_int (input_buf
[7]) << 12
18459 | itoa64_to_int (input_buf
[8]) << 18;
18461 salt
->salt_len
= 4;
18465 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18467 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18469 memcpy (digest
, tmp_buf
, 8);
18473 IP (digest
[0], digest
[1], tt
);
18475 digest
[0] = rotr32 (digest
[0], 31);
18476 digest
[1] = rotr32 (digest
[1], 31);
18480 return (PARSER_OK
);
18483 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18485 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18487 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18489 u32
*digest
= (u32
*) hash_buf
->digest
;
18491 salt_t
*salt
= hash_buf
->salt
;
18497 char *type_pos
= input_buf
+ 6 + 1;
18499 char *salt_pos
= strchr (type_pos
, '*');
18501 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18503 u32 type_len
= salt_pos
- type_pos
;
18505 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18509 char *crypted_pos
= strchr (salt_pos
, '*');
18511 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18513 u32 salt_len
= crypted_pos
- salt_pos
;
18515 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18519 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18521 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18527 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18528 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18530 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18531 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18533 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18534 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18535 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18536 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18538 salt
->salt_len
= 24;
18539 salt
->salt_iter
= ROUNDS_RAR3
;
18541 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18542 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18544 digest
[0] = 0xc43d7b00;
18545 digest
[1] = 0x40070000;
18549 return (PARSER_OK
);
18552 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18554 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18556 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18558 u32
*digest
= (u32
*) hash_buf
->digest
;
18560 salt_t
*salt
= hash_buf
->salt
;
18562 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18568 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18570 char *param1_pos
= strchr (param0_pos
, '$');
18572 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18574 u32 param0_len
= param1_pos
- param0_pos
;
18578 char *param2_pos
= strchr (param1_pos
, '$');
18580 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18582 u32 param1_len
= param2_pos
- param1_pos
;
18586 char *param3_pos
= strchr (param2_pos
, '$');
18588 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18590 u32 param2_len
= param3_pos
- param2_pos
;
18594 char *param4_pos
= strchr (param3_pos
, '$');
18596 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18598 u32 param3_len
= param4_pos
- param3_pos
;
18602 char *param5_pos
= strchr (param4_pos
, '$');
18604 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18606 u32 param4_len
= param5_pos
- param4_pos
;
18610 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18612 char *salt_buf
= param1_pos
;
18613 char *iv
= param3_pos
;
18614 char *pswcheck
= param5_pos
;
18616 const uint salt_len
= atoi (param0_pos
);
18617 const uint iterations
= atoi (param2_pos
);
18618 const uint pswcheck_len
= atoi (param4_pos
);
18624 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18625 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18626 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18628 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18629 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18630 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18636 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18637 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18638 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18639 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18641 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18642 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18643 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18644 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18646 salt
->salt_len
= 16;
18648 salt
->salt_sign
[0] = iterations
;
18650 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18656 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18657 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18661 return (PARSER_OK
);
18664 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18666 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18668 u32
*digest
= (u32
*) hash_buf
->digest
;
18670 salt_t
*salt
= hash_buf
->salt
;
18672 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18673 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18674 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18675 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18676 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18677 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18678 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18679 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18681 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18683 uint salt_len
= input_len
- 64 - 1;
18685 char *salt_buf
= input_buf
+ 64 + 1;
18687 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18689 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18691 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18693 salt
->salt_len
= salt_len
;
18696 * we can precompute the first sha256 transform
18701 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18702 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18703 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18704 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18705 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18706 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18707 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18708 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18709 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18710 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18711 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18712 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18713 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18714 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18715 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18716 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18720 pc256
[0] = SHA256M_A
;
18721 pc256
[1] = SHA256M_B
;
18722 pc256
[2] = SHA256M_C
;
18723 pc256
[3] = SHA256M_D
;
18724 pc256
[4] = SHA256M_E
;
18725 pc256
[5] = SHA256M_F
;
18726 pc256
[6] = SHA256M_G
;
18727 pc256
[7] = SHA256M_H
;
18729 sha256_64 (w
, pc256
);
18731 salt
->salt_buf_pc
[0] = pc256
[0];
18732 salt
->salt_buf_pc
[1] = pc256
[1];
18733 salt
->salt_buf_pc
[2] = pc256
[2];
18734 salt
->salt_buf_pc
[3] = pc256
[3];
18735 salt
->salt_buf_pc
[4] = pc256
[4];
18736 salt
->salt_buf_pc
[5] = pc256
[5];
18737 salt
->salt_buf_pc
[6] = pc256
[6];
18738 salt
->salt_buf_pc
[7] = pc256
[7];
18740 digest
[0] -= pc256
[0];
18741 digest
[1] -= pc256
[1];
18742 digest
[2] -= pc256
[2];
18743 digest
[3] -= pc256
[3];
18744 digest
[4] -= pc256
[4];
18745 digest
[5] -= pc256
[5];
18746 digest
[6] -= pc256
[6];
18747 digest
[7] -= pc256
[7];
18749 return (PARSER_OK
);
18752 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18754 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18756 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18758 u32
*digest
= (u32
*) hash_buf
->digest
;
18760 salt_t
*salt
= hash_buf
->salt
;
18766 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18768 char *data_buf_pos
= strchr (data_len_pos
, '$');
18770 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18772 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18774 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18775 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18779 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18781 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18783 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18785 u32 data_len
= atoi (data_len_pos
);
18787 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18793 char *salt_pos
= data_buf_pos
;
18795 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18796 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18797 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
18798 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
18800 // this is actually the CT, which is also the hash later (if matched)
18802 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
18803 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
18804 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
18805 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
18807 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18809 salt
->salt_iter
= 10 - 1;
18815 digest
[0] = salt
->salt_buf
[4];
18816 digest
[1] = salt
->salt_buf
[5];
18817 digest
[2] = salt
->salt_buf
[6];
18818 digest
[3] = salt
->salt_buf
[7];
18820 return (PARSER_OK
);
18823 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18825 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18827 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18829 u32
*digest
= (u32
*) hash_buf
->digest
;
18831 salt_t
*salt
= hash_buf
->salt
;
18837 char *salt_pos
= input_buf
+ 11 + 1;
18839 char *iter_pos
= strchr (salt_pos
, ',');
18841 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18843 u32 salt_len
= iter_pos
- salt_pos
;
18845 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18849 char *hash_pos
= strchr (iter_pos
, ',');
18851 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18853 u32 iter_len
= hash_pos
- iter_pos
;
18855 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18859 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18861 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18867 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18868 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18869 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
18870 salt
->salt_buf
[3] = 0x00018000;
18872 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18873 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18874 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18875 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18877 salt
->salt_len
= salt_len
/ 2;
18879 salt
->salt_iter
= atoi (iter_pos
) - 1;
18885 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18886 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18887 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18888 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18889 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18890 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18891 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18892 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18894 return (PARSER_OK
);
18897 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18899 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
18901 u32
*digest
= (u32
*) hash_buf
->digest
;
18903 salt_t
*salt
= hash_buf
->salt
;
18909 char *hash_pos
= input_buf
+ 64;
18910 char *salt1_pos
= input_buf
+ 128;
18911 char *salt2_pos
= input_buf
;
18917 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
18918 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
18919 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
18920 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
18922 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
18923 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
18924 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
18925 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
18927 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
18928 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
18929 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
18930 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
18932 salt
->salt_len
= 48;
18934 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
18940 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18941 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18942 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18943 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18944 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18945 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18946 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18947 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18949 return (PARSER_OK
);
18953 * parallel running threads
18958 BOOL WINAPI
sigHandler_default (DWORD sig
)
18962 case CTRL_CLOSE_EVENT
:
18965 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18966 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18967 * function otherwise it is too late (e.g. after returning from this function)
18972 SetConsoleCtrlHandler (NULL
, TRUE
);
18979 case CTRL_LOGOFF_EVENT
:
18980 case CTRL_SHUTDOWN_EVENT
:
18984 SetConsoleCtrlHandler (NULL
, TRUE
);
18992 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
18996 case CTRL_CLOSE_EVENT
:
19000 SetConsoleCtrlHandler (NULL
, TRUE
);
19007 case CTRL_LOGOFF_EVENT
:
19008 case CTRL_SHUTDOWN_EVENT
:
19012 SetConsoleCtrlHandler (NULL
, TRUE
);
19020 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19022 if (callback
== NULL
)
19024 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19028 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19034 void sigHandler_default (int sig
)
19038 signal (sig
, NULL
);
19041 void sigHandler_benchmark (int sig
)
19045 signal (sig
, NULL
);
19048 void hc_signal (void (callback
) (int))
19050 if (callback
== NULL
) callback
= SIG_DFL
;
19052 signal (SIGINT
, callback
);
19053 signal (SIGTERM
, callback
);
19054 signal (SIGABRT
, callback
);
19059 void status_display ();
19061 void *thread_keypress (void *p
)
19063 int benchmark
= *((int *) p
);
19065 uint quiet
= data
.quiet
;
19069 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19071 int ch
= tty_getchar();
19073 if (ch
== -1) break;
19075 if (ch
== 0) continue;
19081 hc_thread_mutex_lock (mux_display
);
19096 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19097 if (quiet
== 0) fflush (stdout
);
19109 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19110 if (quiet
== 0) fflush (stdout
);
19122 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19123 if (quiet
== 0) fflush (stdout
);
19135 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19136 if (quiet
== 0) fflush (stdout
);
19144 if (benchmark
== 1) break;
19146 stop_at_checkpoint ();
19150 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19151 if (quiet
== 0) fflush (stdout
);
19159 if (benchmark
== 1)
19171 hc_thread_mutex_unlock (mux_display
);
19183 bool class_num (const u8 c
)
19185 return ((c
>= '0') && (c
<= '9'));
19188 bool class_lower (const u8 c
)
19190 return ((c
>= 'a') && (c
<= 'z'));
19193 bool class_upper (const u8 c
)
19195 return ((c
>= 'A') && (c
<= 'Z'));
19198 bool class_alpha (const u8 c
)
19200 return (class_lower (c
) || class_upper (c
));
19203 int conv_ctoi (const u8 c
)
19209 else if (class_upper (c
))
19211 return c
- 'A' + 10;
19217 int conv_itoc (const u8 c
)
19225 return c
+ 'A' - 10;
19235 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19236 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19237 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19238 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19239 #define MAX_KERNEL_RULES 255
19240 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19241 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19242 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19244 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19245 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19246 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19247 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19249 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19254 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19256 switch (rule_buf
[rule_pos
])
19262 case RULE_OP_MANGLE_NOOP
:
19263 SET_NAME (rule
, rule_buf
[rule_pos
]);
19266 case RULE_OP_MANGLE_LREST
:
19267 SET_NAME (rule
, rule_buf
[rule_pos
]);
19270 case RULE_OP_MANGLE_UREST
:
19271 SET_NAME (rule
, rule_buf
[rule_pos
]);
19274 case RULE_OP_MANGLE_LREST_UFIRST
:
19275 SET_NAME (rule
, rule_buf
[rule_pos
]);
19278 case RULE_OP_MANGLE_UREST_LFIRST
:
19279 SET_NAME (rule
, rule_buf
[rule_pos
]);
19282 case RULE_OP_MANGLE_TREST
:
19283 SET_NAME (rule
, rule_buf
[rule_pos
]);
19286 case RULE_OP_MANGLE_TOGGLE_AT
:
19287 SET_NAME (rule
, rule_buf
[rule_pos
]);
19288 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19291 case RULE_OP_MANGLE_REVERSE
:
19292 SET_NAME (rule
, rule_buf
[rule_pos
]);
19295 case RULE_OP_MANGLE_DUPEWORD
:
19296 SET_NAME (rule
, rule_buf
[rule_pos
]);
19299 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19300 SET_NAME (rule
, rule_buf
[rule_pos
]);
19301 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19304 case RULE_OP_MANGLE_REFLECT
:
19305 SET_NAME (rule
, rule_buf
[rule_pos
]);
19308 case RULE_OP_MANGLE_ROTATE_LEFT
:
19309 SET_NAME (rule
, rule_buf
[rule_pos
]);
19312 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19313 SET_NAME (rule
, rule_buf
[rule_pos
]);
19316 case RULE_OP_MANGLE_APPEND
:
19317 SET_NAME (rule
, rule_buf
[rule_pos
]);
19318 SET_P0 (rule
, rule_buf
[rule_pos
]);
19321 case RULE_OP_MANGLE_PREPEND
:
19322 SET_NAME (rule
, rule_buf
[rule_pos
]);
19323 SET_P0 (rule
, rule_buf
[rule_pos
]);
19326 case RULE_OP_MANGLE_DELETE_FIRST
:
19327 SET_NAME (rule
, rule_buf
[rule_pos
]);
19330 case RULE_OP_MANGLE_DELETE_LAST
:
19331 SET_NAME (rule
, rule_buf
[rule_pos
]);
19334 case RULE_OP_MANGLE_DELETE_AT
:
19335 SET_NAME (rule
, rule_buf
[rule_pos
]);
19336 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19339 case RULE_OP_MANGLE_EXTRACT
:
19340 SET_NAME (rule
, rule_buf
[rule_pos
]);
19341 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19342 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19345 case RULE_OP_MANGLE_OMIT
:
19346 SET_NAME (rule
, rule_buf
[rule_pos
]);
19347 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19348 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19351 case RULE_OP_MANGLE_INSERT
:
19352 SET_NAME (rule
, rule_buf
[rule_pos
]);
19353 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19354 SET_P1 (rule
, rule_buf
[rule_pos
]);
19357 case RULE_OP_MANGLE_OVERSTRIKE
:
19358 SET_NAME (rule
, rule_buf
[rule_pos
]);
19359 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19360 SET_P1 (rule
, rule_buf
[rule_pos
]);
19363 case RULE_OP_MANGLE_TRUNCATE_AT
:
19364 SET_NAME (rule
, rule_buf
[rule_pos
]);
19365 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19368 case RULE_OP_MANGLE_REPLACE
:
19369 SET_NAME (rule
, rule_buf
[rule_pos
]);
19370 SET_P0 (rule
, rule_buf
[rule_pos
]);
19371 SET_P1 (rule
, rule_buf
[rule_pos
]);
19374 case RULE_OP_MANGLE_PURGECHAR
:
19378 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19382 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19383 SET_NAME (rule
, rule_buf
[rule_pos
]);
19384 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19387 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19388 SET_NAME (rule
, rule_buf
[rule_pos
]);
19389 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19392 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19393 SET_NAME (rule
, rule_buf
[rule_pos
]);
19396 case RULE_OP_MANGLE_SWITCH_FIRST
:
19397 SET_NAME (rule
, rule_buf
[rule_pos
]);
19400 case RULE_OP_MANGLE_SWITCH_LAST
:
19401 SET_NAME (rule
, rule_buf
[rule_pos
]);
19404 case RULE_OP_MANGLE_SWITCH_AT
:
19405 SET_NAME (rule
, rule_buf
[rule_pos
]);
19406 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19407 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19410 case RULE_OP_MANGLE_CHR_SHIFTL
:
19411 SET_NAME (rule
, rule_buf
[rule_pos
]);
19412 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19415 case RULE_OP_MANGLE_CHR_SHIFTR
:
19416 SET_NAME (rule
, rule_buf
[rule_pos
]);
19417 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19420 case RULE_OP_MANGLE_CHR_INCR
:
19421 SET_NAME (rule
, rule_buf
[rule_pos
]);
19422 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19425 case RULE_OP_MANGLE_CHR_DECR
:
19426 SET_NAME (rule
, rule_buf
[rule_pos
]);
19427 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19430 case RULE_OP_MANGLE_REPLACE_NP1
:
19431 SET_NAME (rule
, rule_buf
[rule_pos
]);
19432 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19435 case RULE_OP_MANGLE_REPLACE_NM1
:
19436 SET_NAME (rule
, rule_buf
[rule_pos
]);
19437 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19440 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19441 SET_NAME (rule
, rule_buf
[rule_pos
]);
19442 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19445 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19446 SET_NAME (rule
, rule_buf
[rule_pos
]);
19447 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19450 case RULE_OP_MANGLE_TITLE
:
19451 SET_NAME (rule
, rule_buf
[rule_pos
]);
19460 if (rule_pos
< rule_len
) return (-1);
19465 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19469 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19473 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19477 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19481 case RULE_OP_MANGLE_NOOP
:
19482 rule_buf
[rule_pos
] = rule_cmd
;
19485 case RULE_OP_MANGLE_LREST
:
19486 rule_buf
[rule_pos
] = rule_cmd
;
19489 case RULE_OP_MANGLE_UREST
:
19490 rule_buf
[rule_pos
] = rule_cmd
;
19493 case RULE_OP_MANGLE_LREST_UFIRST
:
19494 rule_buf
[rule_pos
] = rule_cmd
;
19497 case RULE_OP_MANGLE_UREST_LFIRST
:
19498 rule_buf
[rule_pos
] = rule_cmd
;
19501 case RULE_OP_MANGLE_TREST
:
19502 rule_buf
[rule_pos
] = rule_cmd
;
19505 case RULE_OP_MANGLE_TOGGLE_AT
:
19506 rule_buf
[rule_pos
] = rule_cmd
;
19507 GET_P0_CONV (rule
);
19510 case RULE_OP_MANGLE_REVERSE
:
19511 rule_buf
[rule_pos
] = rule_cmd
;
19514 case RULE_OP_MANGLE_DUPEWORD
:
19515 rule_buf
[rule_pos
] = rule_cmd
;
19518 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19519 rule_buf
[rule_pos
] = rule_cmd
;
19520 GET_P0_CONV (rule
);
19523 case RULE_OP_MANGLE_REFLECT
:
19524 rule_buf
[rule_pos
] = rule_cmd
;
19527 case RULE_OP_MANGLE_ROTATE_LEFT
:
19528 rule_buf
[rule_pos
] = rule_cmd
;
19531 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19532 rule_buf
[rule_pos
] = rule_cmd
;
19535 case RULE_OP_MANGLE_APPEND
:
19536 rule_buf
[rule_pos
] = rule_cmd
;
19540 case RULE_OP_MANGLE_PREPEND
:
19541 rule_buf
[rule_pos
] = rule_cmd
;
19545 case RULE_OP_MANGLE_DELETE_FIRST
:
19546 rule_buf
[rule_pos
] = rule_cmd
;
19549 case RULE_OP_MANGLE_DELETE_LAST
:
19550 rule_buf
[rule_pos
] = rule_cmd
;
19553 case RULE_OP_MANGLE_DELETE_AT
:
19554 rule_buf
[rule_pos
] = rule_cmd
;
19555 GET_P0_CONV (rule
);
19558 case RULE_OP_MANGLE_EXTRACT
:
19559 rule_buf
[rule_pos
] = rule_cmd
;
19560 GET_P0_CONV (rule
);
19561 GET_P1_CONV (rule
);
19564 case RULE_OP_MANGLE_OMIT
:
19565 rule_buf
[rule_pos
] = rule_cmd
;
19566 GET_P0_CONV (rule
);
19567 GET_P1_CONV (rule
);
19570 case RULE_OP_MANGLE_INSERT
:
19571 rule_buf
[rule_pos
] = rule_cmd
;
19572 GET_P0_CONV (rule
);
19576 case RULE_OP_MANGLE_OVERSTRIKE
:
19577 rule_buf
[rule_pos
] = rule_cmd
;
19578 GET_P0_CONV (rule
);
19582 case RULE_OP_MANGLE_TRUNCATE_AT
:
19583 rule_buf
[rule_pos
] = rule_cmd
;
19584 GET_P0_CONV (rule
);
19587 case RULE_OP_MANGLE_REPLACE
:
19588 rule_buf
[rule_pos
] = rule_cmd
;
19593 case RULE_OP_MANGLE_PURGECHAR
:
19597 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19601 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19602 rule_buf
[rule_pos
] = rule_cmd
;
19603 GET_P0_CONV (rule
);
19606 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19607 rule_buf
[rule_pos
] = rule_cmd
;
19608 GET_P0_CONV (rule
);
19611 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19612 rule_buf
[rule_pos
] = rule_cmd
;
19615 case RULE_OP_MANGLE_SWITCH_FIRST
:
19616 rule_buf
[rule_pos
] = rule_cmd
;
19619 case RULE_OP_MANGLE_SWITCH_LAST
:
19620 rule_buf
[rule_pos
] = rule_cmd
;
19623 case RULE_OP_MANGLE_SWITCH_AT
:
19624 rule_buf
[rule_pos
] = rule_cmd
;
19625 GET_P0_CONV (rule
);
19626 GET_P1_CONV (rule
);
19629 case RULE_OP_MANGLE_CHR_SHIFTL
:
19630 rule_buf
[rule_pos
] = rule_cmd
;
19631 GET_P0_CONV (rule
);
19634 case RULE_OP_MANGLE_CHR_SHIFTR
:
19635 rule_buf
[rule_pos
] = rule_cmd
;
19636 GET_P0_CONV (rule
);
19639 case RULE_OP_MANGLE_CHR_INCR
:
19640 rule_buf
[rule_pos
] = rule_cmd
;
19641 GET_P0_CONV (rule
);
19644 case RULE_OP_MANGLE_CHR_DECR
:
19645 rule_buf
[rule_pos
] = rule_cmd
;
19646 GET_P0_CONV (rule
);
19649 case RULE_OP_MANGLE_REPLACE_NP1
:
19650 rule_buf
[rule_pos
] = rule_cmd
;
19651 GET_P0_CONV (rule
);
19654 case RULE_OP_MANGLE_REPLACE_NM1
:
19655 rule_buf
[rule_pos
] = rule_cmd
;
19656 GET_P0_CONV (rule
);
19659 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19660 rule_buf
[rule_pos
] = rule_cmd
;
19661 GET_P0_CONV (rule
);
19664 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19665 rule_buf
[rule_pos
] = rule_cmd
;
19666 GET_P0_CONV (rule
);
19669 case RULE_OP_MANGLE_TITLE
:
19670 rule_buf
[rule_pos
] = rule_cmd
;
19674 return rule_pos
- 1;
19692 * CPU rules : this is from hashcat sources, cpu based rules
19695 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19696 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19698 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19699 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19700 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19702 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19703 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19704 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19706 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19710 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19715 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19719 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19724 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19728 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19733 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19738 for (l
= 0; l
< arr_len
; l
++)
19740 r
= arr_len
- 1 - l
;
19744 MANGLE_SWITCH (arr
, l
, r
);
19750 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19752 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19754 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19756 return (arr_len
* 2);
19759 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19761 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19763 int orig_len
= arr_len
;
19767 for (i
= 0; i
< times
; i
++)
19769 memcpy (&arr
[arr_len
], arr
, orig_len
);
19771 arr_len
+= orig_len
;
19777 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19779 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19781 mangle_double (arr
, arr_len
);
19783 mangle_reverse (arr
+ arr_len
, arr_len
);
19785 return (arr_len
* 2);
19788 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19793 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19795 MANGLE_SWITCH (arr
, l
, r
);
19801 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19806 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19808 MANGLE_SWITCH (arr
, l
, r
);
19814 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19816 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19820 return (arr_len
+ 1);
19823 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19825 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19829 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19831 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19836 return (arr_len
+ 1);
19839 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19841 if (upos
>= arr_len
) return (arr_len
);
19845 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19847 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19850 return (arr_len
- 1);
19853 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19855 if (upos
>= arr_len
) return (arr_len
);
19857 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19861 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19863 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19869 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19871 if (upos
>= arr_len
) return (arr_len
);
19873 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19877 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19879 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19882 return (arr_len
- ulen
);
19885 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19887 if (upos
>= arr_len
) return (arr_len
);
19889 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19893 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19895 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19900 return (arr_len
+ 1);
19903 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
)
19905 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19907 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19909 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19911 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19913 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19915 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19917 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19919 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19921 return (arr_len
+ arr2_cpy
);
19924 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19926 if (upos
>= arr_len
) return (arr_len
);
19933 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19935 if (upos
>= arr_len
) return (arr_len
);
19937 memset (arr
+ upos
, 0, arr_len
- upos
);
19942 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19946 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19948 if (arr
[arr_pos
] != oldc
) continue;
19950 arr
[arr_pos
] = newc
;
19956 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19962 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19964 if (arr
[arr_pos
] == c
) continue;
19966 arr
[ret_len
] = arr
[arr_pos
];
19974 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19976 if (ulen
> arr_len
) return (arr_len
);
19978 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19982 memcpy (cs
, arr
, ulen
);
19986 for (i
= 0; i
< ulen
; i
++)
19990 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
19996 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19998 if (ulen
> arr_len
) return (arr_len
);
20000 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20002 int upos
= arr_len
- ulen
;
20006 for (i
= 0; i
< ulen
; i
++)
20008 char c
= arr
[upos
+ i
];
20010 arr_len
= mangle_append (arr
, arr_len
, c
);
20016 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20018 if ( arr_len
== 0) return (arr_len
);
20019 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20021 char c
= arr
[upos
];
20025 for (i
= 0; i
< ulen
; i
++)
20027 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20033 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20035 if ( arr_len
== 0) return (arr_len
);
20036 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20040 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20042 int new_pos
= arr_pos
* 2;
20044 arr
[new_pos
] = arr
[arr_pos
];
20046 arr
[new_pos
+ 1] = arr
[arr_pos
];
20049 return (arr_len
* 2);
20052 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20054 if (upos
>= arr_len
) return (arr_len
);
20055 if (upos2
>= arr_len
) return (arr_len
);
20057 MANGLE_SWITCH (arr
, upos
, upos2
);
20062 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20064 MANGLE_SWITCH (arr
, upos
, upos2
);
20069 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20071 if (upos
>= arr_len
) return (arr_len
);
20078 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20080 if (upos
>= arr_len
) return (arr_len
);
20087 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20089 if (upos
>= arr_len
) return (arr_len
);
20096 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20098 if (upos
>= arr_len
) return (arr_len
);
20105 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20107 int upper_next
= 1;
20111 for (pos
= 0; pos
< arr_len
; pos
++)
20113 if (arr
[pos
] == ' ')
20124 MANGLE_UPPER_AT (arr
, pos
);
20128 MANGLE_LOWER_AT (arr
, pos
);
20135 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20137 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20143 for (j
= 0; j
< rp_gen_num
; j
++)
20150 switch ((char) get_random_num (0, 9))
20153 r
= get_random_num (0, sizeof (grp_op_nop
));
20154 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20158 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20159 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20160 p1
= get_random_num (0, sizeof (grp_pos
));
20161 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20165 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20166 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20167 p1
= get_random_num (1, 6);
20168 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20172 r
= get_random_num (0, sizeof (grp_op_chr
));
20173 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20174 p1
= get_random_num (0x20, 0x7e);
20175 rule_buf
[rule_pos
++] = (char) p1
;
20179 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20180 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20181 p1
= get_random_num (0x20, 0x7e);
20182 rule_buf
[rule_pos
++] = (char) p1
;
20183 p2
= get_random_num (0x20, 0x7e);
20185 p2
= get_random_num (0x20, 0x7e);
20186 rule_buf
[rule_pos
++] = (char) p2
;
20190 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20191 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20192 p1
= get_random_num (0, sizeof (grp_pos
));
20193 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20194 p2
= get_random_num (0x20, 0x7e);
20195 rule_buf
[rule_pos
++] = (char) p2
;
20199 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20200 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20201 p1
= get_random_num (0, sizeof (grp_pos
));
20202 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20203 p2
= get_random_num (0, sizeof (grp_pos
));
20205 p2
= get_random_num (0, sizeof (grp_pos
));
20206 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20210 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20211 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20212 p1
= get_random_num (0, sizeof (grp_pos
));
20213 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20214 p2
= get_random_num (1, sizeof (grp_pos
));
20216 p2
= get_random_num (1, sizeof (grp_pos
));
20217 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20221 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20222 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20223 p1
= get_random_num (0, sizeof (grp_pos
));
20224 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20225 p2
= get_random_num (1, sizeof (grp_pos
));
20226 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20227 p3
= get_random_num (0, sizeof (grp_pos
));
20228 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20236 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20238 char mem
[BLOCK_SIZE
];
20240 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20242 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20244 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
20246 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20248 int out_len
= in_len
;
20249 int mem_len
= in_len
;
20251 memcpy (out
, in
, out_len
);
20255 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20257 int upos
; int upos2
;
20260 switch (rule
[rule_pos
])
20265 case RULE_OP_MANGLE_NOOP
:
20268 case RULE_OP_MANGLE_LREST
:
20269 out_len
= mangle_lrest (out
, out_len
);
20272 case RULE_OP_MANGLE_UREST
:
20273 out_len
= mangle_urest (out
, out_len
);
20276 case RULE_OP_MANGLE_LREST_UFIRST
:
20277 out_len
= mangle_lrest (out
, out_len
);
20278 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20281 case RULE_OP_MANGLE_UREST_LFIRST
:
20282 out_len
= mangle_urest (out
, out_len
);
20283 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20286 case RULE_OP_MANGLE_TREST
:
20287 out_len
= mangle_trest (out
, out_len
);
20290 case RULE_OP_MANGLE_TOGGLE_AT
:
20291 NEXT_RULEPOS (rule_pos
);
20292 NEXT_RPTOI (rule
, rule_pos
, upos
);
20293 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20296 case RULE_OP_MANGLE_REVERSE
:
20297 out_len
= mangle_reverse (out
, out_len
);
20300 case RULE_OP_MANGLE_DUPEWORD
:
20301 out_len
= mangle_double (out
, out_len
);
20304 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20305 NEXT_RULEPOS (rule_pos
);
20306 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20307 out_len
= mangle_double_times (out
, out_len
, ulen
);
20310 case RULE_OP_MANGLE_REFLECT
:
20311 out_len
= mangle_reflect (out
, out_len
);
20314 case RULE_OP_MANGLE_ROTATE_LEFT
:
20315 mangle_rotate_left (out
, out_len
);
20318 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20319 mangle_rotate_right (out
, out_len
);
20322 case RULE_OP_MANGLE_APPEND
:
20323 NEXT_RULEPOS (rule_pos
);
20324 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20327 case RULE_OP_MANGLE_PREPEND
:
20328 NEXT_RULEPOS (rule_pos
);
20329 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20332 case RULE_OP_MANGLE_DELETE_FIRST
:
20333 out_len
= mangle_delete_at (out
, out_len
, 0);
20336 case RULE_OP_MANGLE_DELETE_LAST
:
20337 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20340 case RULE_OP_MANGLE_DELETE_AT
:
20341 NEXT_RULEPOS (rule_pos
);
20342 NEXT_RPTOI (rule
, rule_pos
, upos
);
20343 out_len
= mangle_delete_at (out
, out_len
, upos
);
20346 case RULE_OP_MANGLE_EXTRACT
:
20347 NEXT_RULEPOS (rule_pos
);
20348 NEXT_RPTOI (rule
, rule_pos
, upos
);
20349 NEXT_RULEPOS (rule_pos
);
20350 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20351 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20354 case RULE_OP_MANGLE_OMIT
:
20355 NEXT_RULEPOS (rule_pos
);
20356 NEXT_RPTOI (rule
, rule_pos
, upos
);
20357 NEXT_RULEPOS (rule_pos
);
20358 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20359 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20362 case RULE_OP_MANGLE_INSERT
:
20363 NEXT_RULEPOS (rule_pos
);
20364 NEXT_RPTOI (rule
, rule_pos
, upos
);
20365 NEXT_RULEPOS (rule_pos
);
20366 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20369 case RULE_OP_MANGLE_OVERSTRIKE
:
20370 NEXT_RULEPOS (rule_pos
);
20371 NEXT_RPTOI (rule
, rule_pos
, upos
);
20372 NEXT_RULEPOS (rule_pos
);
20373 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20376 case RULE_OP_MANGLE_TRUNCATE_AT
:
20377 NEXT_RULEPOS (rule_pos
);
20378 NEXT_RPTOI (rule
, rule_pos
, upos
);
20379 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20382 case RULE_OP_MANGLE_REPLACE
:
20383 NEXT_RULEPOS (rule_pos
);
20384 NEXT_RULEPOS (rule_pos
);
20385 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20388 case RULE_OP_MANGLE_PURGECHAR
:
20389 NEXT_RULEPOS (rule_pos
);
20390 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20393 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20397 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20398 NEXT_RULEPOS (rule_pos
);
20399 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20400 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20403 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20404 NEXT_RULEPOS (rule_pos
);
20405 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20406 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20409 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20410 out_len
= mangle_dupechar (out
, out_len
);
20413 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20414 NEXT_RULEPOS (rule_pos
);
20415 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20416 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20419 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20420 NEXT_RULEPOS (rule_pos
);
20421 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20422 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20425 case RULE_OP_MANGLE_SWITCH_FIRST
:
20426 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20429 case RULE_OP_MANGLE_SWITCH_LAST
:
20430 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20433 case RULE_OP_MANGLE_SWITCH_AT
:
20434 NEXT_RULEPOS (rule_pos
);
20435 NEXT_RPTOI (rule
, rule_pos
, upos
);
20436 NEXT_RULEPOS (rule_pos
);
20437 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20438 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20441 case RULE_OP_MANGLE_CHR_SHIFTL
:
20442 NEXT_RULEPOS (rule_pos
);
20443 NEXT_RPTOI (rule
, rule_pos
, upos
);
20444 mangle_chr_shiftl (out
, out_len
, upos
);
20447 case RULE_OP_MANGLE_CHR_SHIFTR
:
20448 NEXT_RULEPOS (rule_pos
);
20449 NEXT_RPTOI (rule
, rule_pos
, upos
);
20450 mangle_chr_shiftr (out
, out_len
, upos
);
20453 case RULE_OP_MANGLE_CHR_INCR
:
20454 NEXT_RULEPOS (rule_pos
);
20455 NEXT_RPTOI (rule
, rule_pos
, upos
);
20456 mangle_chr_incr (out
, out_len
, upos
);
20459 case RULE_OP_MANGLE_CHR_DECR
:
20460 NEXT_RULEPOS (rule_pos
);
20461 NEXT_RPTOI (rule
, rule_pos
, upos
);
20462 mangle_chr_decr (out
, out_len
, upos
);
20465 case RULE_OP_MANGLE_REPLACE_NP1
:
20466 NEXT_RULEPOS (rule_pos
);
20467 NEXT_RPTOI (rule
, rule_pos
, upos
);
20468 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20471 case RULE_OP_MANGLE_REPLACE_NM1
:
20472 NEXT_RULEPOS (rule_pos
);
20473 NEXT_RPTOI (rule
, rule_pos
, upos
);
20474 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20477 case RULE_OP_MANGLE_TITLE
:
20478 out_len
= mangle_title (out
, out_len
);
20481 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20482 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20483 NEXT_RULEPOS (rule_pos
);
20484 NEXT_RPTOI (rule
, rule_pos
, upos
);
20485 NEXT_RULEPOS (rule_pos
);
20486 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20487 NEXT_RULEPOS (rule_pos
);
20488 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20489 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20492 case RULE_OP_MANGLE_APPEND_MEMORY
:
20493 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20494 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20495 memcpy (out
+ out_len
, mem
, mem_len
);
20496 out_len
+= mem_len
;
20499 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20500 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20501 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20502 memcpy (mem
+ mem_len
, out
, out_len
);
20503 out_len
+= mem_len
;
20504 memcpy (out
, mem
, out_len
);
20507 case RULE_OP_MEMORIZE_WORD
:
20508 memcpy (mem
, out
, out_len
);
20512 case RULE_OP_REJECT_LESS
:
20513 NEXT_RULEPOS (rule_pos
);
20514 NEXT_RPTOI (rule
, rule_pos
, upos
);
20515 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20518 case RULE_OP_REJECT_GREATER
:
20519 NEXT_RULEPOS (rule_pos
);
20520 NEXT_RPTOI (rule
, rule_pos
, upos
);
20521 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20524 case RULE_OP_REJECT_CONTAIN
:
20525 NEXT_RULEPOS (rule_pos
);
20526 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20529 case RULE_OP_REJECT_NOT_CONTAIN
:
20530 NEXT_RULEPOS (rule_pos
);
20531 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20534 case RULE_OP_REJECT_EQUAL_FIRST
:
20535 NEXT_RULEPOS (rule_pos
);
20536 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20539 case RULE_OP_REJECT_EQUAL_LAST
:
20540 NEXT_RULEPOS (rule_pos
);
20541 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20544 case RULE_OP_REJECT_EQUAL_AT
:
20545 NEXT_RULEPOS (rule_pos
);
20546 NEXT_RPTOI (rule
, rule_pos
, upos
);
20547 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20548 NEXT_RULEPOS (rule_pos
);
20549 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20552 case RULE_OP_REJECT_CONTAINS
:
20553 NEXT_RULEPOS (rule_pos
);
20554 NEXT_RPTOI (rule
, rule_pos
, upos
);
20555 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20556 NEXT_RULEPOS (rule_pos
);
20557 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20558 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20561 case RULE_OP_REJECT_MEMORY
:
20562 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20566 return (RULE_RC_SYNTAX_ERROR
);
20571 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);