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 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2615 char *logfile_generate_subid ()
2617 const int id
= logfile_generate_id ();
2619 char *subid
= (char *) mymalloc (1 + 16 + 1);
2621 snprintf (subid
, 1 + 16, "SUB%08x", id
);
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
);
4133 char tmp
[32] = { 0 };
4135 snprintf (tmp
, sizeof (tmp
) - 1, "/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 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
);
4193 char *profile_dir
= (char *) mymalloc (len
+ 1);
4195 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4200 char *get_session_dir (const char *profile_dir
)
4202 #define SESSIONS_FOLDER "sessions"
4204 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
);
4206 char *session_dir
= (char *) mymalloc (len
+ 1);
4208 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4213 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4217 FILE *fd
= fopen (filename
, "rb");
4221 log_error ("%s: %s", filename
, strerror (errno
));
4226 #define MAX_KEY_SIZE (1024 * 1024)
4228 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4230 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4236 for (int fpos
= 0; fpos
< nread
; fpos
++)
4238 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4240 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4241 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4242 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4243 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4245 if (kpos
>= 64) kpos
= 0;
4251 void set_cpu_affinity (char *cpu_affinity
)
4254 DWORD_PTR aff_mask
= 0;
4262 char *devices
= strdup (cpu_affinity
);
4264 char *next
= strtok (devices
, ",");
4268 uint cpu_id
= atoi (next
);
4283 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4289 aff_mask
|= 1 << (cpu_id
- 1);
4291 CPU_SET ((cpu_id
- 1), &cpuset
);
4294 } while ((next
= strtok (NULL
, ",")) != NULL
);
4300 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4301 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4303 pthread_t thread
= pthread_self ();
4304 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4308 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4310 char *element
, *end
;
4312 end
= (char *) base
+ nmemb
* size
;
4314 for (element
= (char *) base
; element
< end
; element
+= size
)
4315 if (!compar (element
, key
))
4321 int sort_by_salt (const void *v1
, const void *v2
)
4323 const salt_t
*s1
= (const salt_t
*) v1
;
4324 const salt_t
*s2
= (const salt_t
*) v2
;
4326 const int res1
= s1
->salt_len
- s2
->salt_len
;
4328 if (res1
!= 0) return (res1
);
4330 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4332 if (res2
!= 0) return (res2
);
4340 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4341 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4348 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4349 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4355 int sort_by_salt_buf (const void *v1
, const void *v2
)
4357 const pot_t
*p1
= (const pot_t
*) v1
;
4358 const pot_t
*p2
= (const pot_t
*) v2
;
4360 const hash_t
*h1
= &p1
->hash
;
4361 const hash_t
*h2
= &p2
->hash
;
4363 const salt_t
*s1
= h1
->salt
;
4364 const salt_t
*s2
= h2
->salt
;
4370 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4371 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4377 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4379 const hash_t
*h1
= (const hash_t
*) v1
;
4380 const hash_t
*h2
= (const hash_t
*) v2
;
4382 const salt_t
*s1
= h1
->salt
;
4383 const salt_t
*s2
= h2
->salt
;
4385 // testphase: this should work
4390 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4391 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4394 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4395 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4396 if (s1->salt_len > s2->salt_len) return ( 1);
4397 if (s1->salt_len < s2->salt_len) return (-1);
4399 uint n = s1->salt_len;
4403 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4404 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4411 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4413 const hash_t
*h1
= (const hash_t
*) v1
;
4414 const hash_t
*h2
= (const hash_t
*) v2
;
4416 const salt_t
*s1
= h1
->salt
;
4417 const salt_t
*s2
= h2
->salt
;
4419 // 12 - 2 (since last 2 uints contain the digest)
4424 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4425 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4431 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4433 const hash_t
*h1
= (const hash_t
*) v1
;
4434 const hash_t
*h2
= (const hash_t
*) v2
;
4436 const void *d1
= h1
->digest
;
4437 const void *d2
= h2
->digest
;
4439 return data
.sort_by_digest (d1
, d2
);
4442 int sort_by_hash (const void *v1
, const void *v2
)
4444 const hash_t
*h1
= (const hash_t
*) v1
;
4445 const hash_t
*h2
= (const hash_t
*) v2
;
4449 const salt_t
*s1
= h1
->salt
;
4450 const salt_t
*s2
= h2
->salt
;
4452 int res
= sort_by_salt (s1
, s2
);
4454 if (res
!= 0) return (res
);
4457 const void *d1
= h1
->digest
;
4458 const void *d2
= h2
->digest
;
4460 return data
.sort_by_digest (d1
, d2
);
4463 int sort_by_pot (const void *v1
, const void *v2
)
4465 const pot_t
*p1
= (const pot_t
*) v1
;
4466 const pot_t
*p2
= (const pot_t
*) v2
;
4468 const hash_t
*h1
= &p1
->hash
;
4469 const hash_t
*h2
= &p2
->hash
;
4471 return sort_by_hash (h1
, h2
);
4474 int sort_by_mtime (const void *p1
, const void *p2
)
4476 const char **f1
= (const char **) p1
;
4477 const char **f2
= (const char **) p2
;
4479 struct stat s1
; stat (*f1
, &s1
);
4480 struct stat s2
; stat (*f2
, &s2
);
4482 return s2
.st_mtime
- s1
.st_mtime
;
4485 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4487 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4488 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4490 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4493 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4495 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4496 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4498 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4501 int sort_by_stringptr (const void *p1
, const void *p2
)
4503 const char **s1
= (const char **) p1
;
4504 const char **s2
= (const char **) p2
;
4506 return strcmp (*s1
, *s2
);
4509 int sort_by_dictstat (const void *s1
, const void *s2
)
4511 dictstat_t
*d1
= (dictstat_t
*) s1
;
4512 dictstat_t
*d2
= (dictstat_t
*) s2
;
4515 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4517 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4520 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4523 int sort_by_bitmap (const void *p1
, const void *p2
)
4525 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4526 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4528 return b1
->collisions
- b2
->collisions
;
4531 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4533 const u32
*d1
= (const u32
*) v1
;
4534 const u32
*d2
= (const u32
*) v2
;
4540 if (d1
[n
] > d2
[n
]) return ( 1);
4541 if (d1
[n
] < d2
[n
]) return (-1);
4547 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4549 const u32
*d1
= (const u32
*) v1
;
4550 const u32
*d2
= (const u32
*) v2
;
4556 if (d1
[n
] > d2
[n
]) return ( 1);
4557 if (d1
[n
] < d2
[n
]) return (-1);
4563 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4565 const u32
*d1
= (const u32
*) v1
;
4566 const u32
*d2
= (const u32
*) v2
;
4572 if (d1
[n
] > d2
[n
]) return ( 1);
4573 if (d1
[n
] < d2
[n
]) return (-1);
4579 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4581 const u32
*d1
= (const u32
*) v1
;
4582 const u32
*d2
= (const u32
*) v2
;
4588 if (d1
[n
] > d2
[n
]) return ( 1);
4589 if (d1
[n
] < d2
[n
]) return (-1);
4595 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4597 const u32
*d1
= (const u32
*) v1
;
4598 const u32
*d2
= (const u32
*) v2
;
4604 if (d1
[n
] > d2
[n
]) return ( 1);
4605 if (d1
[n
] < d2
[n
]) return (-1);
4611 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4613 const u32
*d1
= (const u32
*) v1
;
4614 const u32
*d2
= (const u32
*) v2
;
4620 if (d1
[n
] > d2
[n
]) return ( 1);
4621 if (d1
[n
] < d2
[n
]) return (-1);
4627 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4629 const u32
*d1
= (const u32
*) v1
;
4630 const u32
*d2
= (const u32
*) v2
;
4636 if (d1
[n
] > d2
[n
]) return ( 1);
4637 if (d1
[n
] < d2
[n
]) return (-1);
4643 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4645 const u32
*d1
= (const u32
*) v1
;
4646 const u32
*d2
= (const u32
*) v2
;
4652 if (d1
[n
] > d2
[n
]) return ( 1);
4653 if (d1
[n
] < d2
[n
]) return (-1);
4659 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4661 const u64
*d1
= (const u64
*) v1
;
4662 const u64
*d2
= (const u64
*) v2
;
4668 if (d1
[n
] > d2
[n
]) return ( 1);
4669 if (d1
[n
] < d2
[n
]) return (-1);
4675 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4677 const u64
*d1
= (const u64
*) v1
;
4678 const u64
*d2
= (const u64
*) v2
;
4684 if (d1
[n
] > d2
[n
]) return ( 1);
4685 if (d1
[n
] < d2
[n
]) return (-1);
4691 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4693 const u64
*d1
= (const u64
*) v1
;
4694 const u64
*d2
= (const u64
*) v2
;
4700 if (d1
[n
] > d2
[n
]) return ( 1);
4701 if (d1
[n
] < d2
[n
]) return (-1);
4707 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4709 const u32
*d1
= (const u32
*) v1
;
4710 const u32
*d2
= (const u32
*) v2
;
4712 const uint dgst_pos0
= data
.dgst_pos0
;
4713 const uint dgst_pos1
= data
.dgst_pos1
;
4714 const uint dgst_pos2
= data
.dgst_pos2
;
4715 const uint dgst_pos3
= data
.dgst_pos3
;
4717 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4718 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4719 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4720 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4721 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4722 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4723 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4724 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4729 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
)
4731 uint outfile_autohex
= data
.outfile_autohex
;
4733 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4735 FILE *debug_fp
= NULL
;
4737 if (debug_file
!= NULL
)
4739 debug_fp
= fopen (debug_file
, "ab");
4746 if (debug_fp
== NULL
)
4748 log_info ("WARNING: Could not open debug-file for writing");
4752 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4754 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4756 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4759 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4761 if (debug_mode
== 4)
4763 fputc (':', debug_fp
);
4765 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4768 fputc ('\n', debug_fp
);
4770 if (debug_file
!= NULL
) fclose (debug_fp
);
4774 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4776 int needs_hexify
= 0;
4778 if (outfile_autohex
== 1)
4780 for (uint i
= 0; i
< plain_len
; i
++)
4782 if (plain_ptr
[i
] < 0x20)
4789 if (plain_ptr
[i
] > 0x7f)
4798 if (needs_hexify
== 1)
4800 fprintf (fp
, "$HEX[");
4802 for (uint i
= 0; i
< plain_len
; i
++)
4804 fprintf (fp
, "%02x", plain_ptr
[i
]);
4811 fwrite (plain_ptr
, plain_len
, 1, fp
);
4815 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
)
4817 uint outfile_format
= data
.outfile_format
;
4819 char separator
= data
.separator
;
4821 if (outfile_format
& OUTFILE_FMT_HASH
)
4823 fprintf (out_fp
, "%s", out_buf
);
4825 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4827 fputc (separator
, out_fp
);
4830 else if (data
.username
)
4832 if (username
!= NULL
)
4834 for (uint i
= 0; i
< user_len
; i
++)
4836 fprintf (out_fp
, "%c", username
[i
]);
4839 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4841 fputc (separator
, out_fp
);
4846 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4848 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4850 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4852 fputc (separator
, out_fp
);
4856 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4858 for (uint i
= 0; i
< plain_len
; i
++)
4860 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4863 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4865 fputc (separator
, out_fp
);
4869 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4872 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4877 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4879 fprintf (out_fp
, "%llu", crackpos
);
4884 fputc ('\n', out_fp
);
4887 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
)
4891 pot_key
.hash
.salt
= hashes_buf
->salt
;
4892 pot_key
.hash
.digest
= hashes_buf
->digest
;
4894 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4900 input_buf
[input_len
] = 0;
4903 unsigned char *username
= NULL
;
4908 user_t
*user
= hashes_buf
->hash_info
->user
;
4912 username
= (unsigned char *) (user
->user_name
);
4914 user_len
= user
->user_len
;
4918 // do output the line
4919 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4923 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4924 #define LM_MASKED_PLAIN "[notfound]"
4926 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
)
4932 pot_left_key
.hash
.salt
= hash_left
->salt
;
4933 pot_left_key
.hash
.digest
= hash_left
->digest
;
4935 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4939 uint weak_hash_found
= 0;
4941 pot_t pot_right_key
;
4943 pot_right_key
.hash
.salt
= hash_right
->salt
;
4944 pot_right_key
.hash
.digest
= hash_right
->digest
;
4946 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4948 if (pot_right_ptr
== NULL
)
4950 // special case, if "weak hash"
4952 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4954 weak_hash_found
= 1;
4956 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4958 // in theory this is not needed, but we are paranoia:
4960 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4961 pot_right_ptr
->plain_len
= 0;
4965 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4967 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
4972 // at least one half was found:
4976 input_buf
[input_len
] = 0;
4980 unsigned char *username
= NULL
;
4985 user_t
*user
= hash_left
->hash_info
->user
;
4989 username
= (unsigned char *) (user
->user_name
);
4991 user_len
= user
->user_len
;
4995 // mask the part which was not found
4997 uint left_part_masked
= 0;
4998 uint right_part_masked
= 0;
5000 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5002 if (pot_left_ptr
== NULL
)
5004 left_part_masked
= 1;
5006 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5008 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5010 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5011 pot_left_ptr
->plain_len
= mask_plain_len
;
5014 if (pot_right_ptr
== NULL
)
5016 right_part_masked
= 1;
5018 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5020 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5022 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5023 pot_right_ptr
->plain_len
= mask_plain_len
;
5026 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5030 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5032 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5034 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5036 // do output the line
5038 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5040 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5042 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5043 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5046 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
)
5050 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5052 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5054 if (pot_ptr
== NULL
)
5058 input_buf
[input_len
] = 0;
5060 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5064 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
)
5070 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5072 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5076 pot_t pot_right_key
;
5078 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5080 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5082 uint weak_hash_found
= 0;
5084 if (pot_right_ptr
== NULL
)
5086 // special case, if "weak hash"
5088 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5090 weak_hash_found
= 1;
5092 // we just need that pot_right_ptr is not a NULL pointer
5094 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5098 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5100 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5105 // ... at least one part was not cracked
5109 input_buf
[input_len
] = 0;
5111 // only show the hash part which is still not cracked
5113 uint user_len
= input_len
- 32;
5115 char *hash_output
= (char *) mymalloc (33);
5117 memcpy (hash_output
, input_buf
, input_len
);
5119 if (pot_left_ptr
!= NULL
)
5121 // only show right part (because left part was already found)
5123 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5125 hash_output
[user_len
+ 16] = 0;
5128 if (pot_right_ptr
!= NULL
)
5130 // only show left part (because right part was already found)
5132 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5134 hash_output
[user_len
+ 16] = 0;
5137 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5139 myfree (hash_output
);
5141 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5144 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5146 uint opencl_platforms_filter
= 0;
5148 if (opencl_platforms
)
5150 char *platforms
= strdup (opencl_platforms
);
5152 char *next
= strtok (platforms
, ",");
5156 int platform
= atoi (next
);
5158 if (platform
< 1 || platform
> 32)
5160 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5165 opencl_platforms_filter
|= 1 << (platform
- 1);
5167 } while ((next
= strtok (NULL
, ",")) != NULL
);
5173 opencl_platforms_filter
= -1;
5176 return opencl_platforms_filter
;
5179 u32
setup_devices_filter (char *opencl_devices
)
5181 u32 devices_filter
= 0;
5185 char *devices
= strdup (opencl_devices
);
5187 char *next
= strtok (devices
, ",");
5191 int device_id
= atoi (next
);
5193 if (device_id
< 1 || device_id
> 32)
5195 log_error ("ERROR: invalid device_id %u specified", device_id
);
5200 devices_filter
|= 1 << (device_id
- 1);
5202 } while ((next
= strtok (NULL
, ",")) != NULL
);
5208 devices_filter
= -1;
5211 return devices_filter
;
5214 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5216 cl_device_type device_types_filter
= 0;
5218 if (opencl_device_types
)
5220 char *device_types
= strdup (opencl_device_types
);
5222 char *next
= strtok (device_types
, ",");
5226 int device_type
= atoi (next
);
5228 if (device_type
< 1 || device_type
> 3)
5230 log_error ("ERROR: invalid device_type %u specified", device_type
);
5235 device_types_filter
|= 1 << device_type
;
5237 } while ((next
= strtok (NULL
, ",")) != NULL
);
5239 free (device_types
);
5243 // Do not use CPU by default, this often reduces GPU performance because
5244 // the CPU is too busy to handle GPU synchronization
5246 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5249 return device_types_filter
;
5252 u32
get_random_num (const u32 min
, const u32 max
)
5254 if (min
== max
) return (min
);
5256 return ((rand () % (max
- min
)) + min
);
5259 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5261 u32 quotient
= dividend
/ divisor
;
5263 if (dividend
% divisor
) quotient
++;
5268 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5270 u64 quotient
= dividend
/ divisor
;
5272 if (dividend
% divisor
) quotient
++;
5277 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5279 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5280 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5282 if (tm
->tm_year
- 70)
5284 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5285 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5287 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5289 else if (tm
->tm_yday
)
5291 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5292 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5294 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5296 else if (tm
->tm_hour
)
5298 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5299 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5301 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5303 else if (tm
->tm_min
)
5305 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5306 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5308 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5312 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5314 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5318 void format_speed_display (float val
, char *buf
, size_t len
)
5329 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5340 /* generate output */
5344 snprintf (buf
, len
- 1, "%.0f ", val
);
5348 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5352 void lowercase (u8
*buf
, int len
)
5354 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5357 void uppercase (u8
*buf
, int len
)
5359 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5362 int fgetl (FILE *fp
, char *line_buf
)
5368 const int c
= fgetc (fp
);
5370 if (c
== EOF
) break;
5372 line_buf
[line_len
] = (char) c
;
5376 if (line_len
== BUFSIZ
) line_len
--;
5378 if (c
== '\n') break;
5381 if (line_len
== 0) return 0;
5383 if (line_buf
[line_len
- 1] == '\n')
5387 line_buf
[line_len
] = 0;
5390 if (line_len
== 0) return 0;
5392 if (line_buf
[line_len
- 1] == '\r')
5396 line_buf
[line_len
] = 0;
5402 int in_superchop (char *buf
)
5404 int len
= strlen (buf
);
5408 if (buf
[len
- 1] == '\n')
5415 if (buf
[len
- 1] == '\r')
5430 char **scan_directory (const char *path
)
5432 char *tmp_path
= mystrdup (path
);
5434 size_t tmp_path_len
= strlen (tmp_path
);
5436 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5438 tmp_path
[tmp_path_len
- 1] = 0;
5440 tmp_path_len
= strlen (tmp_path
);
5443 char **files
= NULL
;
5449 if ((d
= opendir (tmp_path
)) != NULL
)
5455 memset (&e
, 0, sizeof (e
));
5456 struct dirent
*de
= NULL
;
5458 if (readdir_r (d
, &e
, &de
) != 0)
5460 log_error ("ERROR: readdir_r() failed");
5465 if (de
== NULL
) break;
5469 while ((de
= readdir (d
)) != NULL
)
5472 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5474 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5476 char *path_file
= (char *) mymalloc (path_size
+ 1);
5478 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5480 path_file
[path_size
] = 0;
5484 if ((d_test
= opendir (path_file
)) != NULL
)
5492 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5496 files
[num_files
- 1] = path_file
;
5502 else if (errno
== ENOTDIR
)
5504 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5508 files
[num_files
- 1] = mystrdup (path
);
5511 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5515 files
[num_files
- 1] = NULL
;
5522 int count_dictionaries (char **dictionary_files
)
5524 if (dictionary_files
== NULL
) return 0;
5528 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5536 char *stroptitype (const uint opti_type
)
5540 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5541 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5542 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5543 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5544 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5545 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5546 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5547 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5548 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5549 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5550 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5551 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5552 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5553 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5559 char *strparser (const uint parser_status
)
5561 switch (parser_status
)
5563 case PARSER_OK
: return ((char *) PA_000
); break;
5564 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5565 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5566 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5567 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5568 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5569 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5570 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5571 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5572 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5573 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5574 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5575 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5576 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5577 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5578 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5579 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5582 return ((char *) PA_255
);
5585 char *strhashtype (const uint hash_mode
)
5589 case 0: return ((char *) HT_00000
); break;
5590 case 10: return ((char *) HT_00010
); break;
5591 case 11: return ((char *) HT_00011
); break;
5592 case 12: return ((char *) HT_00012
); break;
5593 case 20: return ((char *) HT_00020
); break;
5594 case 21: return ((char *) HT_00021
); break;
5595 case 22: return ((char *) HT_00022
); break;
5596 case 23: return ((char *) HT_00023
); break;
5597 case 30: return ((char *) HT_00030
); break;
5598 case 40: return ((char *) HT_00040
); break;
5599 case 50: return ((char *) HT_00050
); break;
5600 case 60: return ((char *) HT_00060
); break;
5601 case 100: return ((char *) HT_00100
); break;
5602 case 101: return ((char *) HT_00101
); break;
5603 case 110: return ((char *) HT_00110
); break;
5604 case 111: return ((char *) HT_00111
); break;
5605 case 112: return ((char *) HT_00112
); break;
5606 case 120: return ((char *) HT_00120
); break;
5607 case 121: return ((char *) HT_00121
); break;
5608 case 122: return ((char *) HT_00122
); break;
5609 case 124: return ((char *) HT_00124
); break;
5610 case 130: return ((char *) HT_00130
); break;
5611 case 131: return ((char *) HT_00131
); break;
5612 case 132: return ((char *) HT_00132
); break;
5613 case 133: return ((char *) HT_00133
); break;
5614 case 140: return ((char *) HT_00140
); break;
5615 case 141: return ((char *) HT_00141
); break;
5616 case 150: return ((char *) HT_00150
); break;
5617 case 160: return ((char *) HT_00160
); break;
5618 case 190: return ((char *) HT_00190
); break;
5619 case 200: return ((char *) HT_00200
); break;
5620 case 300: return ((char *) HT_00300
); break;
5621 case 400: return ((char *) HT_00400
); break;
5622 case 500: return ((char *) HT_00500
); break;
5623 case 501: return ((char *) HT_00501
); break;
5624 case 900: return ((char *) HT_00900
); break;
5625 case 910: return ((char *) HT_00910
); break;
5626 case 1000: return ((char *) HT_01000
); break;
5627 case 1100: return ((char *) HT_01100
); break;
5628 case 1400: return ((char *) HT_01400
); break;
5629 case 1410: return ((char *) HT_01410
); break;
5630 case 1420: return ((char *) HT_01420
); break;
5631 case 1421: return ((char *) HT_01421
); break;
5632 case 1430: return ((char *) HT_01430
); break;
5633 case 1440: return ((char *) HT_01440
); break;
5634 case 1441: return ((char *) HT_01441
); break;
5635 case 1450: return ((char *) HT_01450
); break;
5636 case 1460: return ((char *) HT_01460
); break;
5637 case 1500: return ((char *) HT_01500
); break;
5638 case 1600: return ((char *) HT_01600
); break;
5639 case 1700: return ((char *) HT_01700
); break;
5640 case 1710: return ((char *) HT_01710
); break;
5641 case 1711: return ((char *) HT_01711
); break;
5642 case 1720: return ((char *) HT_01720
); break;
5643 case 1722: return ((char *) HT_01722
); break;
5644 case 1730: return ((char *) HT_01730
); break;
5645 case 1731: return ((char *) HT_01731
); break;
5646 case 1740: return ((char *) HT_01740
); break;
5647 case 1750: return ((char *) HT_01750
); break;
5648 case 1760: return ((char *) HT_01760
); break;
5649 case 1800: return ((char *) HT_01800
); break;
5650 case 2100: return ((char *) HT_02100
); break;
5651 case 2400: return ((char *) HT_02400
); break;
5652 case 2410: return ((char *) HT_02410
); break;
5653 case 2500: return ((char *) HT_02500
); break;
5654 case 2600: return ((char *) HT_02600
); break;
5655 case 2611: return ((char *) HT_02611
); break;
5656 case 2612: return ((char *) HT_02612
); break;
5657 case 2711: return ((char *) HT_02711
); break;
5658 case 2811: return ((char *) HT_02811
); break;
5659 case 3000: return ((char *) HT_03000
); break;
5660 case 3100: return ((char *) HT_03100
); break;
5661 case 3200: return ((char *) HT_03200
); break;
5662 case 3710: return ((char *) HT_03710
); break;
5663 case 3711: return ((char *) HT_03711
); break;
5664 case 3800: return ((char *) HT_03800
); break;
5665 case 4300: return ((char *) HT_04300
); break;
5666 case 4400: return ((char *) HT_04400
); break;
5667 case 4500: return ((char *) HT_04500
); break;
5668 case 4700: return ((char *) HT_04700
); break;
5669 case 4800: return ((char *) HT_04800
); break;
5670 case 4900: return ((char *) HT_04900
); break;
5671 case 5000: return ((char *) HT_05000
); break;
5672 case 5100: return ((char *) HT_05100
); break;
5673 case 5200: return ((char *) HT_05200
); break;
5674 case 5300: return ((char *) HT_05300
); break;
5675 case 5400: return ((char *) HT_05400
); break;
5676 case 5500: return ((char *) HT_05500
); break;
5677 case 5600: return ((char *) HT_05600
); break;
5678 case 5700: return ((char *) HT_05700
); break;
5679 case 5800: return ((char *) HT_05800
); break;
5680 case 6000: return ((char *) HT_06000
); break;
5681 case 6100: return ((char *) HT_06100
); break;
5682 case 6211: return ((char *) HT_06211
); break;
5683 case 6212: return ((char *) HT_06212
); break;
5684 case 6213: return ((char *) HT_06213
); break;
5685 case 6221: return ((char *) HT_06221
); break;
5686 case 6222: return ((char *) HT_06222
); break;
5687 case 6223: return ((char *) HT_06223
); break;
5688 case 6231: return ((char *) HT_06231
); break;
5689 case 6232: return ((char *) HT_06232
); break;
5690 case 6233: return ((char *) HT_06233
); break;
5691 case 6241: return ((char *) HT_06241
); break;
5692 case 6242: return ((char *) HT_06242
); break;
5693 case 6243: return ((char *) HT_06243
); break;
5694 case 6300: return ((char *) HT_06300
); break;
5695 case 6400: return ((char *) HT_06400
); break;
5696 case 6500: return ((char *) HT_06500
); break;
5697 case 6600: return ((char *) HT_06600
); break;
5698 case 6700: return ((char *) HT_06700
); break;
5699 case 6800: return ((char *) HT_06800
); break;
5700 case 6900: return ((char *) HT_06900
); break;
5701 case 7100: return ((char *) HT_07100
); break;
5702 case 7200: return ((char *) HT_07200
); break;
5703 case 7300: return ((char *) HT_07300
); break;
5704 case 7400: return ((char *) HT_07400
); break;
5705 case 7500: return ((char *) HT_07500
); break;
5706 case 7600: return ((char *) HT_07600
); break;
5707 case 7700: return ((char *) HT_07700
); break;
5708 case 7800: return ((char *) HT_07800
); break;
5709 case 7900: return ((char *) HT_07900
); break;
5710 case 8000: return ((char *) HT_08000
); break;
5711 case 8100: return ((char *) HT_08100
); break;
5712 case 8200: return ((char *) HT_08200
); break;
5713 case 8300: return ((char *) HT_08300
); break;
5714 case 8400: return ((char *) HT_08400
); break;
5715 case 8500: return ((char *) HT_08500
); break;
5716 case 8600: return ((char *) HT_08600
); break;
5717 case 8700: return ((char *) HT_08700
); break;
5718 case 8800: return ((char *) HT_08800
); break;
5719 case 8900: return ((char *) HT_08900
); break;
5720 case 9000: return ((char *) HT_09000
); break;
5721 case 9100: return ((char *) HT_09100
); break;
5722 case 9200: return ((char *) HT_09200
); break;
5723 case 9300: return ((char *) HT_09300
); break;
5724 case 9400: return ((char *) HT_09400
); break;
5725 case 9500: return ((char *) HT_09500
); break;
5726 case 9600: return ((char *) HT_09600
); break;
5727 case 9700: return ((char *) HT_09700
); break;
5728 case 9710: return ((char *) HT_09710
); break;
5729 case 9720: return ((char *) HT_09720
); break;
5730 case 9800: return ((char *) HT_09800
); break;
5731 case 9810: return ((char *) HT_09810
); break;
5732 case 9820: return ((char *) HT_09820
); break;
5733 case 9900: return ((char *) HT_09900
); break;
5734 case 10000: return ((char *) HT_10000
); break;
5735 case 10100: return ((char *) HT_10100
); break;
5736 case 10200: return ((char *) HT_10200
); break;
5737 case 10300: return ((char *) HT_10300
); break;
5738 case 10400: return ((char *) HT_10400
); break;
5739 case 10410: return ((char *) HT_10410
); break;
5740 case 10420: return ((char *) HT_10420
); break;
5741 case 10500: return ((char *) HT_10500
); break;
5742 case 10600: return ((char *) HT_10600
); break;
5743 case 10700: return ((char *) HT_10700
); break;
5744 case 10800: return ((char *) HT_10800
); break;
5745 case 10900: return ((char *) HT_10900
); break;
5746 case 11000: return ((char *) HT_11000
); break;
5747 case 11100: return ((char *) HT_11100
); break;
5748 case 11200: return ((char *) HT_11200
); break;
5749 case 11300: return ((char *) HT_11300
); break;
5750 case 11400: return ((char *) HT_11400
); break;
5751 case 11500: return ((char *) HT_11500
); break;
5752 case 11600: return ((char *) HT_11600
); break;
5753 case 11700: return ((char *) HT_11700
); break;
5754 case 11800: return ((char *) HT_11800
); break;
5755 case 11900: return ((char *) HT_11900
); break;
5756 case 12000: return ((char *) HT_12000
); break;
5757 case 12100: return ((char *) HT_12100
); break;
5758 case 12200: return ((char *) HT_12200
); break;
5759 case 12300: return ((char *) HT_12300
); break;
5760 case 12400: return ((char *) HT_12400
); break;
5761 case 12500: return ((char *) HT_12500
); break;
5762 case 12600: return ((char *) HT_12600
); break;
5763 case 12700: return ((char *) HT_12700
); break;
5764 case 12800: return ((char *) HT_12800
); break;
5765 case 12900: return ((char *) HT_12900
); break;
5766 case 13000: return ((char *) HT_13000
); break;
5769 return ((char *) "Unknown");
5772 char *strstatus (const uint devices_status
)
5774 switch (devices_status
)
5776 case STATUS_INIT
: return ((char *) ST_0000
); break;
5777 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5778 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5779 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5780 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5781 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5782 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5783 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5784 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5785 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5788 return ((char *) "Unknown");
5791 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5793 uint hash_type
= data
.hash_type
;
5794 uint hash_mode
= data
.hash_mode
;
5795 uint salt_type
= data
.salt_type
;
5796 uint opts_type
= data
.opts_type
;
5797 uint opti_type
= data
.opti_type
;
5798 uint dgst_size
= data
.dgst_size
;
5800 char *hashfile
= data
.hashfile
;
5804 uint digest_buf
[64];
5806 u64
*digest_buf64
= (u64
*) digest_buf
;
5808 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5810 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5812 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5818 case HASH_TYPE_DESCRYPT
:
5819 FP (digest_buf
[1], digest_buf
[0], tt
);
5822 case HASH_TYPE_DESRACF
:
5823 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5824 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5826 FP (digest_buf
[1], digest_buf
[0], tt
);
5830 FP (digest_buf
[1], digest_buf
[0], tt
);
5833 case HASH_TYPE_NETNTLM
:
5834 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5835 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5836 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5837 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5839 FP (digest_buf
[1], digest_buf
[0], tt
);
5840 FP (digest_buf
[3], digest_buf
[2], tt
);
5843 case HASH_TYPE_BSDICRYPT
:
5844 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5845 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5847 FP (digest_buf
[1], digest_buf
[0], tt
);
5852 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5857 digest_buf
[0] += MD4M_A
;
5858 digest_buf
[1] += MD4M_B
;
5859 digest_buf
[2] += MD4M_C
;
5860 digest_buf
[3] += MD4M_D
;
5864 digest_buf
[0] += MD5M_A
;
5865 digest_buf
[1] += MD5M_B
;
5866 digest_buf
[2] += MD5M_C
;
5867 digest_buf
[3] += MD5M_D
;
5870 case HASH_TYPE_SHA1
:
5871 digest_buf
[0] += SHA1M_A
;
5872 digest_buf
[1] += SHA1M_B
;
5873 digest_buf
[2] += SHA1M_C
;
5874 digest_buf
[3] += SHA1M_D
;
5875 digest_buf
[4] += SHA1M_E
;
5878 case HASH_TYPE_SHA256
:
5879 digest_buf
[0] += SHA256M_A
;
5880 digest_buf
[1] += SHA256M_B
;
5881 digest_buf
[2] += SHA256M_C
;
5882 digest_buf
[3] += SHA256M_D
;
5883 digest_buf
[4] += SHA256M_E
;
5884 digest_buf
[5] += SHA256M_F
;
5885 digest_buf
[6] += SHA256M_G
;
5886 digest_buf
[7] += SHA256M_H
;
5889 case HASH_TYPE_SHA384
:
5890 digest_buf64
[0] += SHA384M_A
;
5891 digest_buf64
[1] += SHA384M_B
;
5892 digest_buf64
[2] += SHA384M_C
;
5893 digest_buf64
[3] += SHA384M_D
;
5894 digest_buf64
[4] += SHA384M_E
;
5895 digest_buf64
[5] += SHA384M_F
;
5896 digest_buf64
[6] += 0;
5897 digest_buf64
[7] += 0;
5900 case HASH_TYPE_SHA512
:
5901 digest_buf64
[0] += SHA512M_A
;
5902 digest_buf64
[1] += SHA512M_B
;
5903 digest_buf64
[2] += SHA512M_C
;
5904 digest_buf64
[3] += SHA512M_D
;
5905 digest_buf64
[4] += SHA512M_E
;
5906 digest_buf64
[5] += SHA512M_F
;
5907 digest_buf64
[6] += SHA512M_G
;
5908 digest_buf64
[7] += SHA512M_H
;
5913 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5915 if (dgst_size
== DGST_SIZE_4_2
)
5917 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5919 else if (dgst_size
== DGST_SIZE_4_4
)
5921 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5923 else if (dgst_size
== DGST_SIZE_4_5
)
5925 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5927 else if (dgst_size
== DGST_SIZE_4_6
)
5929 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5931 else if (dgst_size
== DGST_SIZE_4_8
)
5933 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5935 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5937 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5939 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5941 else if (hash_type
== HASH_TYPE_SHA384
)
5943 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5945 else if (hash_type
== HASH_TYPE_SHA512
)
5947 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5949 else if (hash_type
== HASH_TYPE_GOST
)
5951 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5954 else if (dgst_size
== DGST_SIZE_4_64
)
5956 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5958 else if (dgst_size
== DGST_SIZE_8_25
)
5960 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5964 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5965 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5966 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5972 memset (&salt
, 0, sizeof (salt_t
));
5974 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5976 char *ptr
= (char *) salt
.salt_buf
;
5978 uint len
= salt
.salt_len
;
5980 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5986 case HASH_TYPE_NETNTLM
:
5988 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
5989 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
5991 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5997 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5999 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6007 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6009 uint max
= salt
.salt_len
/ 4;
6013 for (uint i
= 0; i
< max
; i
++)
6015 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6019 if (opts_type
& OPTS_TYPE_ST_HEX
)
6023 memset (tmp
, 0, sizeof (tmp
));
6025 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6027 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6032 memcpy (ptr
, tmp
, len
);
6035 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6037 memset (ptr
+ len
, 0, memset_size
);
6039 salt
.salt_len
= len
;
6043 // some modes require special encoding
6046 uint out_buf_plain
[256];
6047 uint out_buf_salt
[256];
6051 memset (out_buf_plain
, 0, sizeof (out_buf_plain
));
6052 memset (out_buf_salt
, 0, sizeof (out_buf_salt
));
6054 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6056 char *ptr_plain
= (char *) out_buf_plain
;
6057 char *ptr_salt
= (char *) out_buf_salt
;
6059 if (hash_mode
== 22)
6063 memset (username
, 0, sizeof (username
));
6065 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6067 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6069 u16
*ptr
= (u16
*) digest_buf
;
6071 tmp_buf
[ 0] = sig
[0];
6072 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6073 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6074 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6075 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6076 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6077 tmp_buf
[ 6] = sig
[1];
6078 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6079 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6080 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6081 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6082 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6083 tmp_buf
[12] = sig
[2];
6084 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6085 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6086 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6087 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6088 tmp_buf
[17] = sig
[3];
6089 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6090 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6091 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6092 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6093 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6094 tmp_buf
[23] = sig
[4];
6095 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6096 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6097 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6098 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6099 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6100 tmp_buf
[29] = sig
[5];
6102 snprintf (out_buf
, len
-1, "%s:%s",
6106 else if (hash_mode
== 23)
6108 // do not show the \nskyper\n part in output
6110 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6112 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6114 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6121 else if (hash_mode
== 101)
6123 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6125 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6126 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6127 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6128 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6129 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6131 memcpy (tmp_buf
, digest_buf
, 20);
6133 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6135 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6137 else if (hash_mode
== 111)
6139 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6141 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6142 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6143 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6144 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6145 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6147 memcpy (tmp_buf
, digest_buf
, 20);
6148 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6150 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6152 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6154 else if (hash_mode
== 122)
6156 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6157 (char *) salt
.salt_buf
,
6164 else if (hash_mode
== 124)
6166 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6167 (char *) salt
.salt_buf
,
6174 else if (hash_mode
== 131)
6176 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6177 (char *) salt
.salt_buf
,
6185 else if (hash_mode
== 132)
6187 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6188 (char *) salt
.salt_buf
,
6195 else if (hash_mode
== 133)
6197 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6199 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6200 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6201 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6202 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6203 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6205 memcpy (tmp_buf
, digest_buf
, 20);
6207 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6209 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6211 else if (hash_mode
== 141)
6213 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6215 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6217 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6219 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6221 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6222 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6223 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6224 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6225 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6227 memcpy (tmp_buf
, digest_buf
, 20);
6229 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6233 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6235 else if (hash_mode
== 400)
6237 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6239 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6240 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6241 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6242 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6244 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6246 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6248 else if (hash_mode
== 500)
6250 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6252 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6253 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6254 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6255 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6257 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6259 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6261 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6265 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6268 else if (hash_mode
== 501)
6270 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6272 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6273 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6275 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6277 else if (hash_mode
== 1421)
6279 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6281 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6297 else if (hash_mode
== 1441)
6299 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6301 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6303 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6305 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6307 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6308 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6309 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6310 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6311 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6312 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6313 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6314 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6316 memcpy (tmp_buf
, digest_buf
, 32);
6318 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6322 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6324 else if (hash_mode
== 1500)
6326 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6327 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6328 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6329 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6330 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6332 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6334 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6336 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6337 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6339 memcpy (tmp_buf
, digest_buf
, 8);
6341 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6343 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6347 else if (hash_mode
== 1600)
6349 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6351 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6352 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6353 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6354 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6356 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6358 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6360 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6364 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6367 else if (hash_mode
== 1711)
6369 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6371 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6372 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6373 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6374 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6375 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6376 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6377 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6378 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6380 memcpy (tmp_buf
, digest_buf
, 64);
6381 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6383 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6385 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6387 else if (hash_mode
== 1722)
6389 uint
*ptr
= digest_buf
;
6391 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6392 (unsigned char *) salt
.salt_buf
,
6402 else if (hash_mode
== 1731)
6404 uint
*ptr
= digest_buf
;
6406 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6407 (unsigned char *) salt
.salt_buf
,
6417 else if (hash_mode
== 1800)
6421 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6422 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6423 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6424 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6425 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6426 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6427 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6428 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6430 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6432 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6434 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6438 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6441 else if (hash_mode
== 2100)
6445 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6447 salt
.salt_iter
+ 1);
6449 uint signature_len
= strlen (out_buf
);
6451 pos
+= signature_len
;
6452 len
-= signature_len
;
6454 char *salt_ptr
= (char *) salt
.salt_buf
;
6456 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6458 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6459 byte_swap_32 (digest_buf
[0]),
6460 byte_swap_32 (digest_buf
[1]),
6461 byte_swap_32 (digest_buf
[2]),
6462 byte_swap_32 (digest_buf
[3]));
6464 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6466 memcpy (tmp_buf
, digest_buf
, 16);
6468 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6470 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6471 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6472 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6473 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6475 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6476 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6477 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6478 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6480 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6481 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6482 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6483 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6485 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6486 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6487 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6488 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6490 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6491 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6492 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6493 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6497 else if (hash_mode
== 2500)
6499 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6501 wpa_t
*wpa
= &wpas
[salt_pos
];
6505 char *pke_ptr
= (char *) pke
;
6507 for (uint i
= 0; i
< 25; i
++)
6509 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6512 unsigned char mac1
[6];
6513 unsigned char mac2
[6];
6515 memcpy (mac1
, pke_ptr
+ 23, 6);
6516 memcpy (mac2
, pke_ptr
+ 29, 6);
6518 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6519 (char *) salt
.salt_buf
,
6533 else if (hash_mode
== 4400)
6535 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6536 byte_swap_32 (digest_buf
[0]),
6537 byte_swap_32 (digest_buf
[1]),
6538 byte_swap_32 (digest_buf
[2]),
6539 byte_swap_32 (digest_buf
[3]));
6541 else if (hash_mode
== 4700)
6543 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6544 byte_swap_32 (digest_buf
[0]),
6545 byte_swap_32 (digest_buf
[1]),
6546 byte_swap_32 (digest_buf
[2]),
6547 byte_swap_32 (digest_buf
[3]),
6548 byte_swap_32 (digest_buf
[4]));
6550 else if (hash_mode
== 4800)
6552 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6554 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6559 byte_swap_32 (salt
.salt_buf
[0]),
6560 byte_swap_32 (salt
.salt_buf
[1]),
6561 byte_swap_32 (salt
.salt_buf
[2]),
6562 byte_swap_32 (salt
.salt_buf
[3]),
6565 else if (hash_mode
== 4900)
6567 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6568 byte_swap_32 (digest_buf
[0]),
6569 byte_swap_32 (digest_buf
[1]),
6570 byte_swap_32 (digest_buf
[2]),
6571 byte_swap_32 (digest_buf
[3]),
6572 byte_swap_32 (digest_buf
[4]));
6574 else if (hash_mode
== 5100)
6576 snprintf (out_buf
, len
-1, "%08x%08x",
6580 else if (hash_mode
== 5200)
6582 snprintf (out_buf
, len
-1, "%s", hashfile
);
6584 else if (hash_mode
== 5300)
6586 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6588 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6590 int buf_len
= len
-1;
6594 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6596 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6598 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6600 snprintf (out_buf
, buf_len
, ":");
6606 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6614 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6616 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6618 if ((i
== 0) || (i
== 5))
6620 snprintf (out_buf
, buf_len
, ":");
6626 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6634 for (uint i
= 0; i
< 4; i
++)
6638 snprintf (out_buf
, buf_len
, ":");
6644 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6650 else if (hash_mode
== 5400)
6652 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6654 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6656 int buf_len
= len
-1;
6660 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6662 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6664 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6666 snprintf (out_buf
, buf_len
, ":");
6672 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6680 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6682 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6684 if ((i
== 0) || (i
== 5))
6686 snprintf (out_buf
, buf_len
, ":");
6692 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6700 for (uint i
= 0; i
< 5; i
++)
6704 snprintf (out_buf
, buf_len
, ":");
6710 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6716 else if (hash_mode
== 5500)
6718 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6720 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6723 char domain_buf
[64];
6724 char srvchall_buf
[1024];
6725 char clichall_buf
[1024];
6727 memset (user_buf
, 0, sizeof (user_buf
));
6728 memset (domain_buf
, 0, sizeof (domain_buf
));
6729 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6730 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6732 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6734 char *ptr
= (char *) netntlm
->userdomain_buf
;
6736 user_buf
[i
] = ptr
[j
];
6739 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6741 char *ptr
= (char *) netntlm
->userdomain_buf
;
6743 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6746 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6748 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6750 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6753 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6755 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6757 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6760 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6768 byte_swap_32 (salt
.salt_buf_pc
[0]),
6769 byte_swap_32 (salt
.salt_buf_pc
[1]),
6772 else if (hash_mode
== 5600)
6774 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6776 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6779 char domain_buf
[64];
6780 char srvchall_buf
[1024];
6781 char clichall_buf
[1024];
6783 memset (user_buf
, 0, sizeof (user_buf
));
6784 memset (domain_buf
, 0, sizeof (domain_buf
));
6785 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6786 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6788 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6790 char *ptr
= (char *) netntlm
->userdomain_buf
;
6792 user_buf
[i
] = ptr
[j
];
6795 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6797 char *ptr
= (char *) netntlm
->userdomain_buf
;
6799 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6802 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6804 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6806 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6809 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6811 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6813 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6816 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6826 else if (hash_mode
== 5700)
6828 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6830 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6831 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6832 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6833 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6834 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6835 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6836 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6837 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6839 memcpy (tmp_buf
, digest_buf
, 32);
6841 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6845 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6847 else if (hash_mode
== 5800)
6849 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6850 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6851 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6852 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6853 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6855 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6862 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6864 snprintf (out_buf
, len
-1, "%s", hashfile
);
6866 else if (hash_mode
== 6300)
6868 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6870 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6871 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6872 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6873 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6875 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6877 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6879 else if (hash_mode
== 6400)
6881 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6883 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6885 else if (hash_mode
== 6500)
6887 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6889 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6891 else if (hash_mode
== 6600)
6893 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6895 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6897 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6898 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6900 uint buf_len
= len
- 1;
6902 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6905 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6907 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6912 else if (hash_mode
== 6700)
6914 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6916 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6918 else if (hash_mode
== 6800)
6920 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6922 else if (hash_mode
== 7100)
6924 uint
*ptr
= digest_buf
;
6926 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6928 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6932 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6933 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6934 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6935 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6936 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6937 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6938 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6939 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6941 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",
6942 SIGNATURE_SHA512OSX
,
6944 esalt
[ 0], esalt
[ 1],
6945 esalt
[ 2], esalt
[ 3],
6946 esalt
[ 4], esalt
[ 5],
6947 esalt
[ 6], esalt
[ 7],
6955 ptr
[15], ptr
[14]);
6957 else if (hash_mode
== 7200)
6959 uint
*ptr
= digest_buf
;
6961 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6963 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6967 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6969 len_used
= strlen (out_buf
);
6971 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6973 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6975 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6978 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",
6986 ptr
[15], ptr
[14]);
6988 else if (hash_mode
== 7300)
6990 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6992 rakp_t
*rakp
= &rakps
[salt_pos
];
6994 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6996 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6999 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7006 else if (hash_mode
== 7400)
7008 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7010 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7011 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7012 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7013 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7014 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7015 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7016 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7017 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7019 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7021 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7023 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7027 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7030 else if (hash_mode
== 7500)
7032 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7034 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7036 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7037 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7041 char *ptr_data
= data
;
7043 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7045 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7048 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7050 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7055 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7057 (char *) krb5pa
->user
,
7058 (char *) krb5pa
->realm
,
7059 (char *) krb5pa
->salt
,
7062 else if (hash_mode
== 7700)
7064 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7065 (char *) salt
.salt_buf
,
7069 else if (hash_mode
== 7800)
7071 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7072 (char *) salt
.salt_buf
,
7079 else if (hash_mode
== 7900)
7081 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7085 char *tmp
= (char *) salt
.salt_buf_pc
;
7087 ptr_plain
[42] = tmp
[0];
7093 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7095 else if (hash_mode
== 8000)
7097 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7098 (unsigned char *) salt
.salt_buf
,
7108 else if (hash_mode
== 8100)
7110 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7111 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7113 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7114 (unsigned char *) salt
.salt_buf
,
7121 else if (hash_mode
== 8200)
7123 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7125 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7127 char data_buf
[4096];
7129 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7131 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7134 data_buf
[cloudkey
->data_len
* 2] = 0;
7136 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7137 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7138 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7139 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7140 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7141 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7142 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7143 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7145 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7146 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7147 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7148 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7150 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7166 else if (hash_mode
== 8300)
7168 char digest_buf_c
[34] = { 0 };
7170 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7172 digest_buf_c
[32] = 0;
7176 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7178 char domain_buf_c
[33] = { 0 };
7180 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7182 for (uint i
= 0; i
< salt_pc_len
; i
++)
7184 const char next
= domain_buf_c
[i
];
7186 domain_buf_c
[i
] = '.';
7191 domain_buf_c
[salt_pc_len
] = 0;
7195 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7197 else if (hash_mode
== 8500)
7199 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7201 else if (hash_mode
== 2612)
7203 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7205 (char *) salt
.salt_buf
,
7211 else if (hash_mode
== 3711)
7213 char *salt_ptr
= (char *) salt
.salt_buf
;
7215 salt_ptr
[salt
.salt_len
- 1] = 0;
7217 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7218 SIGNATURE_MEDIAWIKI_B
,
7225 else if (hash_mode
== 8800)
7227 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7229 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7233 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7235 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7240 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7241 SIGNATURE_ANDROIDFDE
,
7242 byte_swap_32 (salt
.salt_buf
[0]),
7243 byte_swap_32 (salt
.salt_buf
[1]),
7244 byte_swap_32 (salt
.salt_buf
[2]),
7245 byte_swap_32 (salt
.salt_buf
[3]),
7246 byte_swap_32 (digest_buf
[0]),
7247 byte_swap_32 (digest_buf
[1]),
7248 byte_swap_32 (digest_buf
[2]),
7249 byte_swap_32 (digest_buf
[3]),
7252 else if (hash_mode
== 8900)
7254 uint N
= salt
.scrypt_N
;
7255 uint r
= salt
.scrypt_r
;
7256 uint p
= salt
.scrypt_p
;
7258 char base64_salt
[32];
7260 memset (base64_salt
, 0, 32);
7262 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7264 memset (tmp_buf
, 0, 46);
7266 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7267 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7268 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7269 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7270 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7271 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7272 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7273 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7274 digest_buf
[8] = 0; // needed for base64_encode ()
7276 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7278 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7286 else if (hash_mode
== 9000)
7288 snprintf (out_buf
, len
-1, "%s", hashfile
);
7290 else if (hash_mode
== 9200)
7294 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7296 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7298 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7302 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7303 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7304 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7305 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7306 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7307 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7308 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7309 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7310 digest_buf
[8] = 0; // needed for base64_encode ()
7313 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7315 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7316 tmp_buf
[43] = 0; // cut it here
7320 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7322 else if (hash_mode
== 9300)
7324 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7325 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7326 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7327 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7328 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7329 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7330 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7331 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7332 digest_buf
[8] = 0; // needed for base64_encode ()
7335 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7337 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7338 tmp_buf
[43] = 0; // cut it here
7340 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7342 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7344 else if (hash_mode
== 9400)
7346 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7348 office2007_t
*office2007
= &office2007s
[salt_pos
];
7350 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7351 SIGNATURE_OFFICE2007
,
7354 office2007
->keySize
,
7360 office2007
->encryptedVerifier
[0],
7361 office2007
->encryptedVerifier
[1],
7362 office2007
->encryptedVerifier
[2],
7363 office2007
->encryptedVerifier
[3],
7364 office2007
->encryptedVerifierHash
[0],
7365 office2007
->encryptedVerifierHash
[1],
7366 office2007
->encryptedVerifierHash
[2],
7367 office2007
->encryptedVerifierHash
[3],
7368 office2007
->encryptedVerifierHash
[4]);
7370 else if (hash_mode
== 9500)
7372 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7374 office2010_t
*office2010
= &office2010s
[salt_pos
];
7376 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,
7382 office2010
->encryptedVerifier
[0],
7383 office2010
->encryptedVerifier
[1],
7384 office2010
->encryptedVerifier
[2],
7385 office2010
->encryptedVerifier
[3],
7386 office2010
->encryptedVerifierHash
[0],
7387 office2010
->encryptedVerifierHash
[1],
7388 office2010
->encryptedVerifierHash
[2],
7389 office2010
->encryptedVerifierHash
[3],
7390 office2010
->encryptedVerifierHash
[4],
7391 office2010
->encryptedVerifierHash
[5],
7392 office2010
->encryptedVerifierHash
[6],
7393 office2010
->encryptedVerifierHash
[7]);
7395 else if (hash_mode
== 9600)
7397 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7399 office2013_t
*office2013
= &office2013s
[salt_pos
];
7401 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,
7407 office2013
->encryptedVerifier
[0],
7408 office2013
->encryptedVerifier
[1],
7409 office2013
->encryptedVerifier
[2],
7410 office2013
->encryptedVerifier
[3],
7411 office2013
->encryptedVerifierHash
[0],
7412 office2013
->encryptedVerifierHash
[1],
7413 office2013
->encryptedVerifierHash
[2],
7414 office2013
->encryptedVerifierHash
[3],
7415 office2013
->encryptedVerifierHash
[4],
7416 office2013
->encryptedVerifierHash
[5],
7417 office2013
->encryptedVerifierHash
[6],
7418 office2013
->encryptedVerifierHash
[7]);
7420 else if (hash_mode
== 9700)
7422 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7424 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7426 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7427 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7428 byte_swap_32 (salt
.salt_buf
[0]),
7429 byte_swap_32 (salt
.salt_buf
[1]),
7430 byte_swap_32 (salt
.salt_buf
[2]),
7431 byte_swap_32 (salt
.salt_buf
[3]),
7432 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7433 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7434 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7435 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7436 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7437 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7438 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7439 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7441 else if (hash_mode
== 9710)
7443 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7445 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7447 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7448 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7449 byte_swap_32 (salt
.salt_buf
[0]),
7450 byte_swap_32 (salt
.salt_buf
[1]),
7451 byte_swap_32 (salt
.salt_buf
[2]),
7452 byte_swap_32 (salt
.salt_buf
[3]),
7453 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7454 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7455 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7456 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7457 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7458 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7459 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7460 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7462 else if (hash_mode
== 9720)
7464 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7466 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7468 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7470 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7471 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7472 byte_swap_32 (salt
.salt_buf
[0]),
7473 byte_swap_32 (salt
.salt_buf
[1]),
7474 byte_swap_32 (salt
.salt_buf
[2]),
7475 byte_swap_32 (salt
.salt_buf
[3]),
7476 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7477 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7478 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7479 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7480 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7481 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7482 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7483 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7490 else if (hash_mode
== 9800)
7492 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7494 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7496 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7497 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7502 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7503 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7504 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7505 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7506 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7507 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7508 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7509 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7510 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7512 else if (hash_mode
== 9810)
7514 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7516 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7518 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7519 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7524 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7525 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7526 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7527 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7528 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7529 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7530 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7531 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7532 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7534 else if (hash_mode
== 9820)
7536 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7538 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7540 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7542 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7543 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7548 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7549 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7550 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7551 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7552 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7553 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7554 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7555 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7556 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7563 else if (hash_mode
== 10000)
7567 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7569 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7571 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7575 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7576 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7577 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7578 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7579 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7580 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7581 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7582 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7583 digest_buf
[8] = 0; // needed for base64_encode ()
7586 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7588 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7592 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7594 else if (hash_mode
== 10100)
7596 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7601 byte_swap_32 (salt
.salt_buf
[0]),
7602 byte_swap_32 (salt
.salt_buf
[1]),
7603 byte_swap_32 (salt
.salt_buf
[2]),
7604 byte_swap_32 (salt
.salt_buf
[3]));
7606 else if (hash_mode
== 10200)
7608 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7610 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7614 char challenge
[100];
7616 memset (challenge
, 0, sizeof (challenge
));
7618 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7624 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7625 (char *) cram_md5
->user
,
7633 memset (response
, 0, sizeof (response
));
7635 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7637 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7639 else if (hash_mode
== 10300)
7643 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7645 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7646 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7648 uint tmp_len
= 20 + salt
.salt_len
;
7652 char base64_encoded
[100];
7654 memset (base64_encoded
, 0, sizeof (base64_encoded
));
7656 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7658 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7660 else if (hash_mode
== 10400)
7662 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7664 pdf_t
*pdf
= &pdfs
[salt_pos
];
7666 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",
7674 byte_swap_32 (pdf
->id_buf
[0]),
7675 byte_swap_32 (pdf
->id_buf
[1]),
7676 byte_swap_32 (pdf
->id_buf
[2]),
7677 byte_swap_32 (pdf
->id_buf
[3]),
7679 byte_swap_32 (pdf
->u_buf
[0]),
7680 byte_swap_32 (pdf
->u_buf
[1]),
7681 byte_swap_32 (pdf
->u_buf
[2]),
7682 byte_swap_32 (pdf
->u_buf
[3]),
7683 byte_swap_32 (pdf
->u_buf
[4]),
7684 byte_swap_32 (pdf
->u_buf
[5]),
7685 byte_swap_32 (pdf
->u_buf
[6]),
7686 byte_swap_32 (pdf
->u_buf
[7]),
7688 byte_swap_32 (pdf
->o_buf
[0]),
7689 byte_swap_32 (pdf
->o_buf
[1]),
7690 byte_swap_32 (pdf
->o_buf
[2]),
7691 byte_swap_32 (pdf
->o_buf
[3]),
7692 byte_swap_32 (pdf
->o_buf
[4]),
7693 byte_swap_32 (pdf
->o_buf
[5]),
7694 byte_swap_32 (pdf
->o_buf
[6]),
7695 byte_swap_32 (pdf
->o_buf
[7])
7698 else if (hash_mode
== 10410)
7700 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7702 pdf_t
*pdf
= &pdfs
[salt_pos
];
7704 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",
7712 byte_swap_32 (pdf
->id_buf
[0]),
7713 byte_swap_32 (pdf
->id_buf
[1]),
7714 byte_swap_32 (pdf
->id_buf
[2]),
7715 byte_swap_32 (pdf
->id_buf
[3]),
7717 byte_swap_32 (pdf
->u_buf
[0]),
7718 byte_swap_32 (pdf
->u_buf
[1]),
7719 byte_swap_32 (pdf
->u_buf
[2]),
7720 byte_swap_32 (pdf
->u_buf
[3]),
7721 byte_swap_32 (pdf
->u_buf
[4]),
7722 byte_swap_32 (pdf
->u_buf
[5]),
7723 byte_swap_32 (pdf
->u_buf
[6]),
7724 byte_swap_32 (pdf
->u_buf
[7]),
7726 byte_swap_32 (pdf
->o_buf
[0]),
7727 byte_swap_32 (pdf
->o_buf
[1]),
7728 byte_swap_32 (pdf
->o_buf
[2]),
7729 byte_swap_32 (pdf
->o_buf
[3]),
7730 byte_swap_32 (pdf
->o_buf
[4]),
7731 byte_swap_32 (pdf
->o_buf
[5]),
7732 byte_swap_32 (pdf
->o_buf
[6]),
7733 byte_swap_32 (pdf
->o_buf
[7])
7736 else if (hash_mode
== 10420)
7738 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7740 pdf_t
*pdf
= &pdfs
[salt_pos
];
7742 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7744 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",
7752 byte_swap_32 (pdf
->id_buf
[0]),
7753 byte_swap_32 (pdf
->id_buf
[1]),
7754 byte_swap_32 (pdf
->id_buf
[2]),
7755 byte_swap_32 (pdf
->id_buf
[3]),
7757 byte_swap_32 (pdf
->u_buf
[0]),
7758 byte_swap_32 (pdf
->u_buf
[1]),
7759 byte_swap_32 (pdf
->u_buf
[2]),
7760 byte_swap_32 (pdf
->u_buf
[3]),
7761 byte_swap_32 (pdf
->u_buf
[4]),
7762 byte_swap_32 (pdf
->u_buf
[5]),
7763 byte_swap_32 (pdf
->u_buf
[6]),
7764 byte_swap_32 (pdf
->u_buf
[7]),
7766 byte_swap_32 (pdf
->o_buf
[0]),
7767 byte_swap_32 (pdf
->o_buf
[1]),
7768 byte_swap_32 (pdf
->o_buf
[2]),
7769 byte_swap_32 (pdf
->o_buf
[3]),
7770 byte_swap_32 (pdf
->o_buf
[4]),
7771 byte_swap_32 (pdf
->o_buf
[5]),
7772 byte_swap_32 (pdf
->o_buf
[6]),
7773 byte_swap_32 (pdf
->o_buf
[7]),
7781 else if (hash_mode
== 10500)
7783 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7785 pdf_t
*pdf
= &pdfs
[salt_pos
];
7787 if (pdf
->id_len
== 32)
7789 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",
7797 byte_swap_32 (pdf
->id_buf
[0]),
7798 byte_swap_32 (pdf
->id_buf
[1]),
7799 byte_swap_32 (pdf
->id_buf
[2]),
7800 byte_swap_32 (pdf
->id_buf
[3]),
7801 byte_swap_32 (pdf
->id_buf
[4]),
7802 byte_swap_32 (pdf
->id_buf
[5]),
7803 byte_swap_32 (pdf
->id_buf
[6]),
7804 byte_swap_32 (pdf
->id_buf
[7]),
7806 byte_swap_32 (pdf
->u_buf
[0]),
7807 byte_swap_32 (pdf
->u_buf
[1]),
7808 byte_swap_32 (pdf
->u_buf
[2]),
7809 byte_swap_32 (pdf
->u_buf
[3]),
7810 byte_swap_32 (pdf
->u_buf
[4]),
7811 byte_swap_32 (pdf
->u_buf
[5]),
7812 byte_swap_32 (pdf
->u_buf
[6]),
7813 byte_swap_32 (pdf
->u_buf
[7]),
7815 byte_swap_32 (pdf
->o_buf
[0]),
7816 byte_swap_32 (pdf
->o_buf
[1]),
7817 byte_swap_32 (pdf
->o_buf
[2]),
7818 byte_swap_32 (pdf
->o_buf
[3]),
7819 byte_swap_32 (pdf
->o_buf
[4]),
7820 byte_swap_32 (pdf
->o_buf
[5]),
7821 byte_swap_32 (pdf
->o_buf
[6]),
7822 byte_swap_32 (pdf
->o_buf
[7])
7827 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",
7835 byte_swap_32 (pdf
->id_buf
[0]),
7836 byte_swap_32 (pdf
->id_buf
[1]),
7837 byte_swap_32 (pdf
->id_buf
[2]),
7838 byte_swap_32 (pdf
->id_buf
[3]),
7840 byte_swap_32 (pdf
->u_buf
[0]),
7841 byte_swap_32 (pdf
->u_buf
[1]),
7842 byte_swap_32 (pdf
->u_buf
[2]),
7843 byte_swap_32 (pdf
->u_buf
[3]),
7844 byte_swap_32 (pdf
->u_buf
[4]),
7845 byte_swap_32 (pdf
->u_buf
[5]),
7846 byte_swap_32 (pdf
->u_buf
[6]),
7847 byte_swap_32 (pdf
->u_buf
[7]),
7849 byte_swap_32 (pdf
->o_buf
[0]),
7850 byte_swap_32 (pdf
->o_buf
[1]),
7851 byte_swap_32 (pdf
->o_buf
[2]),
7852 byte_swap_32 (pdf
->o_buf
[3]),
7853 byte_swap_32 (pdf
->o_buf
[4]),
7854 byte_swap_32 (pdf
->o_buf
[5]),
7855 byte_swap_32 (pdf
->o_buf
[6]),
7856 byte_swap_32 (pdf
->o_buf
[7])
7860 else if (hash_mode
== 10600)
7862 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7864 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7865 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7867 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7869 else if (hash_mode
== 10700)
7871 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7873 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7874 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7876 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7878 else if (hash_mode
== 10900)
7880 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7882 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7883 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7885 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7887 else if (hash_mode
== 11100)
7889 u32 salt_challenge
= salt
.salt_buf
[0];
7891 salt_challenge
= byte_swap_32 (salt_challenge
);
7893 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7895 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7896 SIGNATURE_POSTGRESQL_AUTH
,
7904 else if (hash_mode
== 11200)
7906 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7907 SIGNATURE_MYSQL_AUTH
,
7908 (unsigned char *) salt
.salt_buf
,
7915 else if (hash_mode
== 11300)
7917 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7919 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7921 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7922 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7923 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7925 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7926 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7927 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7929 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7931 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7933 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7936 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7938 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7940 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7943 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7945 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7947 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7950 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7951 SIGNATURE_BITCOIN_WALLET
,
7955 (unsigned char *) salt
.salt_buf
,
7963 free (cry_master_buf
);
7965 free (public_key_buf
);
7967 else if (hash_mode
== 11400)
7969 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7971 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7972 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7974 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7976 else if (hash_mode
== 11600)
7978 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7980 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7982 const uint data_len
= seven_zip
->data_len
;
7984 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7986 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7988 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
7990 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7993 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7994 SIGNATURE_SEVEN_ZIP
,
7998 (char *) seven_zip
->salt_buf
,
8000 seven_zip
->iv_buf
[0],
8001 seven_zip
->iv_buf
[1],
8002 seven_zip
->iv_buf
[2],
8003 seven_zip
->iv_buf
[3],
8005 seven_zip
->data_len
,
8006 seven_zip
->unpack_size
,
8011 else if (hash_mode
== 11700)
8013 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8023 else if (hash_mode
== 11800)
8025 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8043 else if (hash_mode
== 11900)
8045 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8047 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8048 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8050 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8052 else if (hash_mode
== 12000)
8054 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8056 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8057 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8059 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8061 else if (hash_mode
== 12100)
8063 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8065 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8066 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8068 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8070 else if (hash_mode
== 12200)
8072 uint
*ptr_digest
= digest_buf
;
8073 uint
*ptr_salt
= salt
.salt_buf
;
8075 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8082 else if (hash_mode
== 12300)
8084 uint
*ptr_digest
= digest_buf
;
8085 uint
*ptr_salt
= salt
.salt_buf
;
8087 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",
8088 ptr_digest
[ 0], ptr_digest
[ 1],
8089 ptr_digest
[ 2], ptr_digest
[ 3],
8090 ptr_digest
[ 4], ptr_digest
[ 5],
8091 ptr_digest
[ 6], ptr_digest
[ 7],
8092 ptr_digest
[ 8], ptr_digest
[ 9],
8093 ptr_digest
[10], ptr_digest
[11],
8094 ptr_digest
[12], ptr_digest
[13],
8095 ptr_digest
[14], ptr_digest
[15],
8101 else if (hash_mode
== 12400)
8103 // encode iteration count
8107 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8108 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8109 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8110 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8115 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8116 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8117 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8118 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8123 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8125 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8126 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8128 memcpy (tmp_buf
, digest_buf
, 8);
8130 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8134 // fill the resulting buffer
8136 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8138 else if (hash_mode
== 12500)
8140 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8142 byte_swap_32 (salt
.salt_buf
[0]),
8143 byte_swap_32 (salt
.salt_buf
[1]),
8149 else if (hash_mode
== 12600)
8151 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8152 digest_buf
[0] + salt
.salt_buf_pc
[0],
8153 digest_buf
[1] + salt
.salt_buf_pc
[1],
8154 digest_buf
[2] + salt
.salt_buf_pc
[2],
8155 digest_buf
[3] + salt
.salt_buf_pc
[3],
8156 digest_buf
[4] + salt
.salt_buf_pc
[4],
8157 digest_buf
[5] + salt
.salt_buf_pc
[5],
8158 digest_buf
[6] + salt
.salt_buf_pc
[6],
8159 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8161 else if (hash_mode
== 12700)
8163 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8165 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8166 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8168 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8170 else if (hash_mode
== 12800)
8172 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8174 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",
8187 byte_swap_32 (digest_buf
[0]),
8188 byte_swap_32 (digest_buf
[1]),
8189 byte_swap_32 (digest_buf
[2]),
8190 byte_swap_32 (digest_buf
[3]),
8191 byte_swap_32 (digest_buf
[4]),
8192 byte_swap_32 (digest_buf
[5]),
8193 byte_swap_32 (digest_buf
[6]),
8194 byte_swap_32 (digest_buf
[7])
8197 else if (hash_mode
== 12900)
8199 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",
8208 byte_swap_32 (digest_buf
[0]),
8209 byte_swap_32 (digest_buf
[1]),
8210 byte_swap_32 (digest_buf
[2]),
8211 byte_swap_32 (digest_buf
[3]),
8212 byte_swap_32 (digest_buf
[4]),
8213 byte_swap_32 (digest_buf
[5]),
8214 byte_swap_32 (digest_buf
[6]),
8215 byte_swap_32 (digest_buf
[7]),
8222 else if (hash_mode
== 13000)
8224 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8226 rar5_t
*rar5
= &rar5s
[salt_pos
];
8228 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8238 byte_swap_32 (digest_buf
[0]),
8239 byte_swap_32 (digest_buf
[1])
8244 if (hash_type
== HASH_TYPE_MD4
)
8246 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8252 else if (hash_type
== HASH_TYPE_MD5
)
8254 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8260 else if (hash_type
== HASH_TYPE_SHA1
)
8262 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8269 else if (hash_type
== HASH_TYPE_SHA256
)
8271 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8281 else if (hash_type
== HASH_TYPE_SHA384
)
8283 uint
*ptr
= digest_buf
;
8285 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8293 else if (hash_type
== HASH_TYPE_SHA512
)
8295 uint
*ptr
= digest_buf
;
8297 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8307 else if (hash_type
== HASH_TYPE_LM
)
8309 snprintf (out_buf
, len
-1, "%08x%08x",
8313 else if (hash_type
== HASH_TYPE_ORACLEH
)
8315 snprintf (out_buf
, len
-1, "%08X%08X",
8319 else if (hash_type
== HASH_TYPE_BCRYPT
)
8321 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8322 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8324 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8326 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8328 else if (hash_type
== HASH_TYPE_KECCAK
)
8330 uint
*ptr
= digest_buf
;
8332 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",
8360 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8362 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8364 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8371 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8373 digest_buf
[ 0] = digest_buf
[ 0];
8374 digest_buf
[ 1] = digest_buf
[ 1];
8375 digest_buf
[ 2] = digest_buf
[ 2];
8376 digest_buf
[ 3] = digest_buf
[ 3];
8377 digest_buf
[ 4] = digest_buf
[ 4];
8378 digest_buf
[ 5] = digest_buf
[ 5];
8379 digest_buf
[ 6] = digest_buf
[ 6];
8380 digest_buf
[ 7] = digest_buf
[ 7];
8381 digest_buf
[ 8] = digest_buf
[ 8];
8382 digest_buf
[ 9] = digest_buf
[ 9];
8383 digest_buf
[10] = digest_buf
[10];
8384 digest_buf
[11] = digest_buf
[11];
8385 digest_buf
[12] = digest_buf
[12];
8386 digest_buf
[13] = digest_buf
[13];
8387 digest_buf
[14] = digest_buf
[14];
8388 digest_buf
[15] = digest_buf
[15];
8390 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8408 else if (hash_type
== HASH_TYPE_GOST
)
8410 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8420 else if (hash_type
== HASH_TYPE_MYSQL
)
8422 snprintf (out_buf
, len
-1, "%08x%08x",
8426 else if (hash_type
== HASH_TYPE_LOTUS5
)
8428 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8434 else if (hash_type
== HASH_TYPE_LOTUS6
)
8436 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8437 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8438 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8439 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8443 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8444 memcpy (buf
+ 5, digest_buf
, 9);
8448 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8450 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8453 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8455 else if (hash_type
== HASH_TYPE_LOTUS8
)
8459 memset (buf
, 0, sizeof (buf
));
8463 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8469 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8473 buf
[26] = salt
.salt_buf_pc
[0];
8474 buf
[27] = salt
.salt_buf_pc
[1];
8478 memcpy (buf
+ 28, digest_buf
, 8);
8480 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8484 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8486 else if (hash_type
== HASH_TYPE_CRC32
)
8488 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8492 if (salt_type
== SALT_TYPE_INTERN
)
8494 size_t pos
= strlen (out_buf
);
8496 out_buf
[pos
] = data
.separator
;
8498 char *ptr
= (char *) salt
.salt_buf
;
8500 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8502 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8506 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8508 memset (hccap
, 0, sizeof (hccap_t
));
8510 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8512 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8514 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8515 wpa_t
*wpa
= &wpas
[salt_pos
];
8517 hccap
->keyver
= wpa
->keyver
;
8519 hccap
->eapol_size
= wpa
->eapol_size
;
8521 if (wpa
->keyver
!= 1)
8525 for (uint i
= 0; i
< 64; i
++)
8527 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8530 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8534 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8539 for (int i
= 5; i
< 25; i
++)
8541 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8544 char *pke_ptr
= (char *) pke_tmp
;
8546 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8547 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8548 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8549 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8551 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8553 uint dgst_size
= data
.dgst_size
;
8555 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8557 if (wpa
->keyver
!= 1)
8561 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8562 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8563 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8564 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8566 memcpy (hccap
->keymic
, digest_tmp
, 16);
8570 memcpy (hccap
->keymic
, digest_ptr
, 16);
8574 void SuspendThreads ()
8576 if (data
.devices_status
== STATUS_RUNNING
)
8578 hc_timer_set (&data
.timer_paused
);
8580 data
.devices_status
= STATUS_PAUSED
;
8582 log_info ("Paused");
8586 void ResumeThreads ()
8588 if (data
.devices_status
== STATUS_PAUSED
)
8592 hc_timer_get (data
.timer_paused
, ms_paused
);
8594 data
.ms_paused
+= ms_paused
;
8596 data
.devices_status
= STATUS_RUNNING
;
8598 log_info ("Resumed");
8604 if (data
.devices_status
!= STATUS_RUNNING
) return;
8606 data
.devices_status
= STATUS_BYPASS
;
8608 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8611 void stop_at_checkpoint ()
8613 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8615 if (data
.devices_status
!= STATUS_RUNNING
) return;
8618 // this feature only makes sense if --restore-disable was not specified
8620 if (data
.restore_disable
== 1)
8622 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8627 // check if monitoring of Restore Point updates should be enabled or disabled
8629 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8631 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8633 // save the current restore point value
8635 data
.checkpoint_cur_words
= get_lowest_words_done ();
8637 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8641 data
.devices_status
= STATUS_RUNNING
;
8643 // reset the global value for checkpoint checks
8645 data
.checkpoint_cur_words
= 0;
8647 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8653 if (data
.devices_status
== STATUS_INIT
) return;
8654 if (data
.devices_status
== STATUS_STARTING
) return;
8656 data
.devices_status
= STATUS_ABORTED
;
8661 if (data
.devices_status
== STATUS_INIT
) return;
8662 if (data
.devices_status
== STATUS_STARTING
) return;
8664 data
.devices_status
= STATUS_QUIT
;
8667 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8671 if ((fp
= fopen (kernel_file
, "rb")) != NULL
)
8675 memset (&st
, 0, sizeof (st
));
8677 stat (kernel_file
, &st
);
8679 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8681 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8683 if (num_read
!= (size_t) st
.st_size
)
8685 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8692 buf
[st
.st_size
] = 0;
8694 for (int i
= 0; i
< num_devices
; i
++)
8696 kernel_lengths
[i
] = (size_t) st
.st_size
;
8698 kernel_sources
[i
] = buf
;
8703 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8711 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8713 FILE *fp
= fopen (dst
, "wb");
8715 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8725 restore_data_t
*init_restore (int argc
, char **argv
)
8727 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8729 if (data
.restore_disable
== 0)
8731 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8735 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8739 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8748 char pidbin
[BUFSIZ
];
8753 memset (pidbin
, 0, sizeof (pidbin
));
8755 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8757 FILE *fd
= fopen (pidbin
, "rb");
8761 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8763 pidbin
[pidbin_len
] = 0;
8767 char *argv0_r
= strrchr (argv
[0], '/');
8769 char *pidbin_r
= strrchr (pidbin
, '/');
8771 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8773 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8775 if (strcmp (argv0_r
, pidbin_r
) == 0)
8777 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8784 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8786 char pidbin2
[BUFSIZ
];
8790 memset (pidbin2
, 0, sizeof (pidbin2
));
8792 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8793 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8795 pidbin
[pidbin_len
] = 0;
8796 pidbin2
[pidbin2_len
] = 0;
8800 if (strcmp (pidbin
, pidbin2
) == 0)
8802 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8810 if (rd
->version_bin
< RESTORE_MIN
)
8812 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8819 memset (rd
, 0, sizeof (restore_data_t
));
8821 rd
->version_bin
= VERSION_BIN
;
8824 rd
->pid
= getpid ();
8826 rd
->pid
= GetCurrentProcessId ();
8829 if (getcwd (rd
->cwd
, 255) == NULL
)
8842 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8844 FILE *fp
= fopen (eff_restore_file
, "rb");
8848 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8853 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8855 log_error ("ERROR: cannot read %s", eff_restore_file
);
8860 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8862 for (uint i
= 0; i
< rd
->argc
; i
++)
8866 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8868 log_error ("ERROR: cannot read %s", eff_restore_file
);
8873 size_t len
= strlen (buf
);
8875 if (len
) buf
[len
- 1] = 0;
8877 rd
->argv
[i
] = mystrdup (buf
);
8884 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8888 log_error ("Restore file is corrupted");
8891 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8893 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8895 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8900 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8904 if (chdir (rd
->cwd
))
8906 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8912 u64
get_lowest_words_done ()
8916 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8918 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8920 if (device_param
->skipped
) continue;
8922 const u64 words_done
= device_param
->words_done
;
8924 if (words_done
< words_cur
) words_cur
= words_done
;
8927 // It's possible that a device's workload isn't finished right after a restore-case.
8928 // In that case, this function would return 0 and overwrite the real restore point
8929 // There's also data.words_cur which is set to rd->words_cur but it changes while
8930 // the attack is running therefore we should stick to rd->words_cur.
8931 // Note that -s influences rd->words_cur we should keep a close look on that.
8933 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8938 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8940 u64 words_cur
= get_lowest_words_done ();
8942 rd
->words_cur
= words_cur
;
8944 FILE *fp
= fopen (new_restore_file
, "wb");
8948 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8953 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8955 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8960 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8962 for (uint i
= 0; i
< rd
->argc
; i
++)
8964 fprintf (fp
, "%s", rd
->argv
[i
]);
8970 fsync (fileno (fp
));
8975 void cycle_restore ()
8977 const char *eff_restore_file
= data
.eff_restore_file
;
8978 const char *new_restore_file
= data
.new_restore_file
;
8980 restore_data_t
*rd
= data
.rd
;
8982 write_restore (new_restore_file
, rd
);
8986 memset (&st
, 0, sizeof(st
));
8988 if (stat (eff_restore_file
, &st
) == 0)
8990 if (unlink (eff_restore_file
))
8992 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8996 if (rename (new_restore_file
, eff_restore_file
))
8998 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9002 void check_checkpoint ()
9004 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9006 u64 words_cur
= get_lowest_words_done ();
9008 if (words_cur
!= data
.checkpoint_cur_words
)
9018 uint
set_kernel_accel (uint hash_mode
)
9022 case 0: return GET_ACCEL (0);
9023 case 10: return GET_ACCEL (10);
9024 case 11: return GET_ACCEL (11);
9025 case 12: return GET_ACCEL (12);
9026 case 20: return GET_ACCEL (20);
9027 case 21: return GET_ACCEL (21);
9028 case 22: return GET_ACCEL (22);
9029 case 23: return GET_ACCEL (23);
9030 case 30: return GET_ACCEL (30);
9031 case 40: return GET_ACCEL (40);
9032 case 50: return GET_ACCEL (50);
9033 case 60: return GET_ACCEL (60);
9034 case 100: return GET_ACCEL (100);
9035 case 101: return GET_ACCEL (101);
9036 case 110: return GET_ACCEL (110);
9037 case 111: return GET_ACCEL (111);
9038 case 112: return GET_ACCEL (112);
9039 case 120: return GET_ACCEL (120);
9040 case 121: return GET_ACCEL (121);
9041 case 122: return GET_ACCEL (122);
9042 case 124: return GET_ACCEL (124);
9043 case 130: return GET_ACCEL (130);
9044 case 131: return GET_ACCEL (131);
9045 case 132: return GET_ACCEL (132);
9046 case 133: return GET_ACCEL (133);
9047 case 140: return GET_ACCEL (140);
9048 case 141: return GET_ACCEL (141);
9049 case 150: return GET_ACCEL (150);
9050 case 160: return GET_ACCEL (160);
9051 case 190: return GET_ACCEL (190);
9052 case 200: return GET_ACCEL (200);
9053 case 300: return GET_ACCEL (300);
9054 case 400: return GET_ACCEL (400);
9055 case 500: return GET_ACCEL (500);
9056 case 501: return GET_ACCEL (501);
9057 case 900: return GET_ACCEL (900);
9058 case 910: return GET_ACCEL (910);
9059 case 1000: return GET_ACCEL (1000);
9060 case 1100: return GET_ACCEL (1100);
9061 case 1400: return GET_ACCEL (1400);
9062 case 1410: return GET_ACCEL (1410);
9063 case 1420: return GET_ACCEL (1420);
9064 case 1421: return GET_ACCEL (1421);
9065 case 1430: return GET_ACCEL (1430);
9066 case 1440: return GET_ACCEL (1440);
9067 case 1441: return GET_ACCEL (1441);
9068 case 1450: return GET_ACCEL (1450);
9069 case 1460: return GET_ACCEL (1460);
9070 case 1500: return GET_ACCEL (1500);
9071 case 1600: return GET_ACCEL (1600);
9072 case 1700: return GET_ACCEL (1700);
9073 case 1710: return GET_ACCEL (1710);
9074 case 1711: return GET_ACCEL (1711);
9075 case 1720: return GET_ACCEL (1720);
9076 case 1722: return GET_ACCEL (1722);
9077 case 1730: return GET_ACCEL (1730);
9078 case 1731: return GET_ACCEL (1731);
9079 case 1740: return GET_ACCEL (1740);
9080 case 1750: return GET_ACCEL (1750);
9081 case 1760: return GET_ACCEL (1760);
9082 case 1800: return GET_ACCEL (1800);
9083 case 2100: return GET_ACCEL (2100);
9084 case 2400: return GET_ACCEL (2400);
9085 case 2410: return GET_ACCEL (2410);
9086 case 2500: return GET_ACCEL (2500);
9087 case 2600: return GET_ACCEL (2600);
9088 case 2611: return GET_ACCEL (2611);
9089 case 2612: return GET_ACCEL (2612);
9090 case 2711: return GET_ACCEL (2711);
9091 case 2811: return GET_ACCEL (2811);
9092 case 3000: return GET_ACCEL (3000);
9093 case 3100: return GET_ACCEL (3100);
9094 case 3200: return GET_ACCEL (3200);
9095 case 3710: return GET_ACCEL (3710);
9096 case 3711: return GET_ACCEL (3711);
9097 case 3800: return GET_ACCEL (3800);
9098 case 4300: return GET_ACCEL (4300);
9099 case 4400: return GET_ACCEL (4400);
9100 case 4500: return GET_ACCEL (4500);
9101 case 4700: return GET_ACCEL (4700);
9102 case 4800: return GET_ACCEL (4800);
9103 case 4900: return GET_ACCEL (4900);
9104 case 5000: return GET_ACCEL (5000);
9105 case 5100: return GET_ACCEL (5100);
9106 case 5200: return GET_ACCEL (5200);
9107 case 5300: return GET_ACCEL (5300);
9108 case 5400: return GET_ACCEL (5400);
9109 case 5500: return GET_ACCEL (5500);
9110 case 5600: return GET_ACCEL (5600);
9111 case 5700: return GET_ACCEL (5700);
9112 case 5800: return GET_ACCEL (5800);
9113 case 6000: return GET_ACCEL (6000);
9114 case 6100: return GET_ACCEL (6100);
9115 case 6211: return GET_ACCEL (6211);
9116 case 6212: return GET_ACCEL (6212);
9117 case 6213: return GET_ACCEL (6213);
9118 case 6221: return GET_ACCEL (6221);
9119 case 6222: return GET_ACCEL (6222);
9120 case 6223: return GET_ACCEL (6223);
9121 case 6231: return GET_ACCEL (6231);
9122 case 6232: return GET_ACCEL (6232);
9123 case 6233: return GET_ACCEL (6233);
9124 case 6241: return GET_ACCEL (6241);
9125 case 6242: return GET_ACCEL (6242);
9126 case 6243: return GET_ACCEL (6243);
9127 case 6300: return GET_ACCEL (6300);
9128 case 6400: return GET_ACCEL (6400);
9129 case 6500: return GET_ACCEL (6500);
9130 case 6600: return GET_ACCEL (6600);
9131 case 6700: return GET_ACCEL (6700);
9132 case 6800: return GET_ACCEL (6800);
9133 case 6900: return GET_ACCEL (6900);
9134 case 7100: return GET_ACCEL (7100);
9135 case 7200: return GET_ACCEL (7200);
9136 case 7300: return GET_ACCEL (7300);
9137 case 7400: return GET_ACCEL (7400);
9138 case 7500: return GET_ACCEL (7500);
9139 case 7600: return GET_ACCEL (7600);
9140 case 7700: return GET_ACCEL (7700);
9141 case 7800: return GET_ACCEL (7800);
9142 case 7900: return GET_ACCEL (7900);
9143 case 8000: return GET_ACCEL (8000);
9144 case 8100: return GET_ACCEL (8100);
9145 case 8200: return GET_ACCEL (8200);
9146 case 8300: return GET_ACCEL (8300);
9147 case 8400: return GET_ACCEL (8400);
9148 case 8500: return GET_ACCEL (8500);
9149 case 8600: return GET_ACCEL (8600);
9150 case 8700: return GET_ACCEL (8700);
9151 case 8800: return GET_ACCEL (8800);
9152 case 8900: return GET_ACCEL (8900);
9153 case 9000: return GET_ACCEL (9000);
9154 case 9100: return GET_ACCEL (9100);
9155 case 9200: return GET_ACCEL (9200);
9156 case 9300: return GET_ACCEL (9300);
9157 case 9400: return GET_ACCEL (9400);
9158 case 9500: return GET_ACCEL (9500);
9159 case 9600: return GET_ACCEL (9600);
9160 case 9700: return GET_ACCEL (9700);
9161 case 9710: return GET_ACCEL (9710);
9162 case 9720: return GET_ACCEL (9720);
9163 case 9800: return GET_ACCEL (9800);
9164 case 9810: return GET_ACCEL (9810);
9165 case 9820: return GET_ACCEL (9820);
9166 case 9900: return GET_ACCEL (9900);
9167 case 10000: return GET_ACCEL (10000);
9168 case 10100: return GET_ACCEL (10100);
9169 case 10200: return GET_ACCEL (10200);
9170 case 10300: return GET_ACCEL (10300);
9171 case 10400: return GET_ACCEL (10400);
9172 case 10410: return GET_ACCEL (10410);
9173 case 10420: return GET_ACCEL (10420);
9174 case 10500: return GET_ACCEL (10500);
9175 case 10600: return GET_ACCEL (10600);
9176 case 10700: return GET_ACCEL (10700);
9177 case 10800: return GET_ACCEL (10800);
9178 case 10900: return GET_ACCEL (10900);
9179 case 11000: return GET_ACCEL (11000);
9180 case 11100: return GET_ACCEL (11100);
9181 case 11200: return GET_ACCEL (11200);
9182 case 11300: return GET_ACCEL (11300);
9183 case 11400: return GET_ACCEL (11400);
9184 case 11500: return GET_ACCEL (11500);
9185 case 11600: return GET_ACCEL (11600);
9186 case 11700: return GET_ACCEL (11700);
9187 case 11800: return GET_ACCEL (11800);
9188 case 11900: return GET_ACCEL (11900);
9189 case 12000: return GET_ACCEL (12000);
9190 case 12100: return GET_ACCEL (12100);
9191 case 12200: return GET_ACCEL (12200);
9192 case 12300: return GET_ACCEL (12300);
9193 case 12400: return GET_ACCEL (12400);
9194 case 12500: return GET_ACCEL (12500);
9195 case 12600: return GET_ACCEL (12600);
9196 case 12700: return GET_ACCEL (12700);
9197 case 12800: return GET_ACCEL (12800);
9198 case 12900: return GET_ACCEL (12900);
9199 case 13000: return GET_ACCEL (13000);
9205 uint
set_kernel_loops (uint hash_mode
)
9209 case 0: return GET_LOOPS (0);
9210 case 10: return GET_LOOPS (10);
9211 case 11: return GET_LOOPS (11);
9212 case 12: return GET_LOOPS (12);
9213 case 20: return GET_LOOPS (20);
9214 case 21: return GET_LOOPS (21);
9215 case 22: return GET_LOOPS (22);
9216 case 23: return GET_LOOPS (23);
9217 case 30: return GET_LOOPS (30);
9218 case 40: return GET_LOOPS (40);
9219 case 50: return GET_LOOPS (50);
9220 case 60: return GET_LOOPS (60);
9221 case 100: return GET_LOOPS (100);
9222 case 101: return GET_LOOPS (101);
9223 case 110: return GET_LOOPS (110);
9224 case 111: return GET_LOOPS (111);
9225 case 112: return GET_LOOPS (112);
9226 case 120: return GET_LOOPS (120);
9227 case 121: return GET_LOOPS (121);
9228 case 122: return GET_LOOPS (122);
9229 case 124: return GET_LOOPS (124);
9230 case 130: return GET_LOOPS (130);
9231 case 131: return GET_LOOPS (131);
9232 case 132: return GET_LOOPS (132);
9233 case 133: return GET_LOOPS (133);
9234 case 140: return GET_LOOPS (140);
9235 case 141: return GET_LOOPS (141);
9236 case 150: return GET_LOOPS (150);
9237 case 160: return GET_LOOPS (160);
9238 case 190: return GET_LOOPS (190);
9239 case 200: return GET_LOOPS (200);
9240 case 300: return GET_LOOPS (300);
9241 case 400: return GET_LOOPS (400);
9242 case 500: return GET_LOOPS (500);
9243 case 501: return GET_LOOPS (501);
9244 case 900: return GET_LOOPS (900);
9245 case 910: return GET_LOOPS (910);
9246 case 1000: return GET_LOOPS (1000);
9247 case 1100: return GET_LOOPS (1100);
9248 case 1400: return GET_LOOPS (1400);
9249 case 1410: return GET_LOOPS (1410);
9250 case 1420: return GET_LOOPS (1420);
9251 case 1421: return GET_LOOPS (1421);
9252 case 1430: return GET_LOOPS (1430);
9253 case 1440: return GET_LOOPS (1440);
9254 case 1441: return GET_LOOPS (1441);
9255 case 1450: return GET_LOOPS (1450);
9256 case 1460: return GET_LOOPS (1460);
9257 case 1500: return GET_LOOPS (1500);
9258 case 1600: return GET_LOOPS (1600);
9259 case 1700: return GET_LOOPS (1700);
9260 case 1710: return GET_LOOPS (1710);
9261 case 1711: return GET_LOOPS (1711);
9262 case 1720: return GET_LOOPS (1720);
9263 case 1722: return GET_LOOPS (1722);
9264 case 1730: return GET_LOOPS (1730);
9265 case 1731: return GET_LOOPS (1731);
9266 case 1740: return GET_LOOPS (1740);
9267 case 1750: return GET_LOOPS (1750);
9268 case 1760: return GET_LOOPS (1760);
9269 case 1800: return GET_LOOPS (1800);
9270 case 2100: return GET_LOOPS (2100);
9271 case 2400: return GET_LOOPS (2400);
9272 case 2410: return GET_LOOPS (2410);
9273 case 2500: return GET_LOOPS (2500);
9274 case 2600: return GET_LOOPS (2600);
9275 case 2611: return GET_LOOPS (2611);
9276 case 2612: return GET_LOOPS (2612);
9277 case 2711: return GET_LOOPS (2711);
9278 case 2811: return GET_LOOPS (2811);
9279 case 3000: return GET_LOOPS (3000);
9280 case 3100: return GET_LOOPS (3100);
9281 case 3200: return GET_LOOPS (3200);
9282 case 3710: return GET_LOOPS (3710);
9283 case 3711: return GET_LOOPS (3711);
9284 case 3800: return GET_LOOPS (3800);
9285 case 4300: return GET_LOOPS (4300);
9286 case 4400: return GET_LOOPS (4400);
9287 case 4500: return GET_LOOPS (4500);
9288 case 4700: return GET_LOOPS (4700);
9289 case 4800: return GET_LOOPS (4800);
9290 case 4900: return GET_LOOPS (4900);
9291 case 5000: return GET_LOOPS (5000);
9292 case 5100: return GET_LOOPS (5100);
9293 case 5200: return GET_LOOPS (5200);
9294 case 5300: return GET_LOOPS (5300);
9295 case 5400: return GET_LOOPS (5400);
9296 case 5500: return GET_LOOPS (5500);
9297 case 5600: return GET_LOOPS (5600);
9298 case 5700: return GET_LOOPS (5700);
9299 case 5800: return GET_LOOPS (5800);
9300 case 6000: return GET_LOOPS (6000);
9301 case 6100: return GET_LOOPS (6100);
9302 case 6211: return GET_LOOPS (6211);
9303 case 6212: return GET_LOOPS (6212);
9304 case 6213: return GET_LOOPS (6213);
9305 case 6221: return GET_LOOPS (6221);
9306 case 6222: return GET_LOOPS (6222);
9307 case 6223: return GET_LOOPS (6223);
9308 case 6231: return GET_LOOPS (6231);
9309 case 6232: return GET_LOOPS (6232);
9310 case 6233: return GET_LOOPS (6233);
9311 case 6241: return GET_LOOPS (6241);
9312 case 6242: return GET_LOOPS (6242);
9313 case 6243: return GET_LOOPS (6243);
9314 case 6300: return GET_LOOPS (6300);
9315 case 6400: return GET_LOOPS (6400);
9316 case 6500: return GET_LOOPS (6500);
9317 case 6600: return GET_LOOPS (6600);
9318 case 6700: return GET_LOOPS (6700);
9319 case 6800: return GET_LOOPS (6800);
9320 case 6900: return GET_LOOPS (6900);
9321 case 7100: return GET_LOOPS (7100);
9322 case 7200: return GET_LOOPS (7200);
9323 case 7300: return GET_LOOPS (7300);
9324 case 7400: return GET_LOOPS (7400);
9325 case 7500: return GET_LOOPS (7500);
9326 case 7600: return GET_LOOPS (7600);
9327 case 7700: return GET_LOOPS (7700);
9328 case 7800: return GET_LOOPS (7800);
9329 case 7900: return GET_LOOPS (7900);
9330 case 8000: return GET_LOOPS (8000);
9331 case 8100: return GET_LOOPS (8100);
9332 case 8200: return GET_LOOPS (8200);
9333 case 8300: return GET_LOOPS (8300);
9334 case 8400: return GET_LOOPS (8400);
9335 case 8500: return GET_LOOPS (8500);
9336 case 8600: return GET_LOOPS (8600);
9337 case 8700: return GET_LOOPS (8700);
9338 case 8800: return GET_LOOPS (8800);
9339 case 8900: return GET_LOOPS (8900);
9340 case 9000: return GET_LOOPS (9000);
9341 case 9100: return GET_LOOPS (9100);
9342 case 9200: return GET_LOOPS (9200);
9343 case 9300: return GET_LOOPS (9300);
9344 case 9400: return GET_LOOPS (9400);
9345 case 9500: return GET_LOOPS (9500);
9346 case 9600: return GET_LOOPS (9600);
9347 case 9700: return GET_LOOPS (9700);
9348 case 9710: return GET_LOOPS (9710);
9349 case 9720: return GET_LOOPS (9720);
9350 case 9800: return GET_LOOPS (9800);
9351 case 9810: return GET_LOOPS (9810);
9352 case 9820: return GET_LOOPS (9820);
9353 case 9900: return GET_LOOPS (9900);
9354 case 10000: return GET_LOOPS (10000);
9355 case 10100: return GET_LOOPS (10100);
9356 case 10200: return GET_LOOPS (10200);
9357 case 10300: return GET_LOOPS (10300);
9358 case 10400: return GET_LOOPS (10400);
9359 case 10410: return GET_LOOPS (10410);
9360 case 10420: return GET_LOOPS (10420);
9361 case 10500: return GET_LOOPS (10500);
9362 case 10600: return GET_LOOPS (10600);
9363 case 10700: return GET_LOOPS (10700);
9364 case 10800: return GET_LOOPS (10800);
9365 case 10900: return GET_LOOPS (10900);
9366 case 11000: return GET_LOOPS (11000);
9367 case 11100: return GET_LOOPS (11100);
9368 case 11200: return GET_LOOPS (11200);
9369 case 11300: return GET_LOOPS (11300);
9370 case 11400: return GET_LOOPS (11400);
9371 case 11500: return GET_LOOPS (11500);
9372 case 11600: return GET_LOOPS (11600);
9373 case 11700: return GET_LOOPS (11700);
9374 case 11800: return GET_LOOPS (11800);
9375 case 11900: return GET_LOOPS (11900);
9376 case 12000: return GET_LOOPS (12000);
9377 case 12100: return GET_LOOPS (12100);
9378 case 12200: return GET_LOOPS (12200);
9379 case 12300: return GET_LOOPS (12300);
9380 case 12400: return GET_LOOPS (12400);
9381 case 12500: return GET_LOOPS (12500);
9382 case 12600: return GET_LOOPS (12600);
9383 case 12700: return GET_LOOPS (12700);
9384 case 12800: return GET_LOOPS (12800);
9385 case 12900: return GET_LOOPS (12900);
9386 case 13000: return GET_LOOPS (13000);
9396 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9400 if (salt_len
> sizeof (tmp
))
9405 memset (tmp
, 0, sizeof (tmp
));
9406 memcpy (tmp
, in
, salt_len
);
9408 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9410 if ((salt_len
% 2) == 0)
9412 u32 new_salt_len
= salt_len
/ 2;
9414 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9419 tmp
[i
] = hex_convert (p1
) << 0;
9420 tmp
[i
] |= hex_convert (p0
) << 4;
9423 salt_len
= new_salt_len
;
9430 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9432 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9435 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9437 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9441 u32
*tmp_uint
= (u32
*) tmp
;
9443 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9444 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9445 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9446 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9447 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9448 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9449 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9450 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9451 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9452 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9454 salt_len
= salt_len
* 2;
9462 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9464 lowercase (tmp
, salt_len
);
9467 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9469 uppercase (tmp
, salt_len
);
9474 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9479 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9484 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9486 u32
*tmp_uint
= (uint
*) tmp
;
9492 for (u32 i
= 0; i
< max
; i
++)
9494 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9497 // Important: we may need to increase the length of memcpy since
9498 // we don't want to "loose" some swapped bytes (could happen if
9499 // they do not perfectly fit in the 4-byte blocks)
9500 // Memcpy does always copy the bytes in the BE order, but since
9501 // we swapped them, some important bytes could be in positions
9502 // we normally skip with the original len
9504 if (len
% 4) len
+= 4 - (len
% 4);
9507 memcpy (out
, tmp
, len
);
9512 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9514 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9516 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9518 u32
*digest
= (u32
*) hash_buf
->digest
;
9520 salt_t
*salt
= hash_buf
->salt
;
9522 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9524 char *iter_pos
= input_buf
+ 4;
9526 salt
->salt_iter
= 1 << atoi (iter_pos
);
9528 char *salt_pos
= strchr (iter_pos
, '$');
9530 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9536 salt
->salt_len
= salt_len
;
9540 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9542 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9544 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9546 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9548 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9549 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9550 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9551 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9553 char *hash_pos
= salt_pos
+ 22;
9555 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9557 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9559 memcpy (digest
, tmp_buf
, 24);
9561 digest
[0] = byte_swap_32 (digest
[0]);
9562 digest
[1] = byte_swap_32 (digest
[1]);
9563 digest
[2] = byte_swap_32 (digest
[2]);
9564 digest
[3] = byte_swap_32 (digest
[3]);
9565 digest
[4] = byte_swap_32 (digest
[4]);
9566 digest
[5] = byte_swap_32 (digest
[5]);
9568 digest
[5] &= ~0xff; // its just 23 not 24 !
9573 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9575 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9577 u32
*digest
= (u32
*) hash_buf
->digest
;
9581 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9583 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9585 memcpy (digest
, tmp_buf
, 32);
9587 digest
[0] = byte_swap_32 (digest
[0]);
9588 digest
[1] = byte_swap_32 (digest
[1]);
9589 digest
[2] = byte_swap_32 (digest
[2]);
9590 digest
[3] = byte_swap_32 (digest
[3]);
9591 digest
[4] = byte_swap_32 (digest
[4]);
9592 digest
[5] = byte_swap_32 (digest
[5]);
9593 digest
[6] = byte_swap_32 (digest
[6]);
9594 digest
[7] = byte_swap_32 (digest
[7]);
9596 digest
[0] -= SHA256M_A
;
9597 digest
[1] -= SHA256M_B
;
9598 digest
[2] -= SHA256M_C
;
9599 digest
[3] -= SHA256M_D
;
9600 digest
[4] -= SHA256M_E
;
9601 digest
[5] -= SHA256M_F
;
9602 digest
[6] -= SHA256M_G
;
9603 digest
[7] -= SHA256M_H
;
9608 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9610 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9612 u32
*digest
= (u32
*) hash_buf
->digest
;
9614 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9615 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9617 digest
[0] = byte_swap_32 (digest
[0]);
9618 digest
[1] = byte_swap_32 (digest
[1]);
9622 IP (digest
[0], digest
[1], tt
);
9624 digest
[0] = digest
[0];
9625 digest
[1] = digest
[1];
9632 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9634 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9636 u32
*digest
= (u32
*) hash_buf
->digest
;
9638 salt_t
*salt
= hash_buf
->salt
;
9640 char *hash_pos
= input_buf
+ 8;
9642 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9643 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9644 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9645 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9646 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9648 digest
[0] -= SHA1M_A
;
9649 digest
[1] -= SHA1M_B
;
9650 digest
[2] -= SHA1M_C
;
9651 digest
[3] -= SHA1M_D
;
9652 digest
[4] -= SHA1M_E
;
9656 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9658 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9660 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9662 salt
->salt_len
= salt_len
;
9667 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9669 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9671 u64
*digest
= (u64
*) hash_buf
->digest
;
9673 salt_t
*salt
= hash_buf
->salt
;
9675 char *hash_pos
= input_buf
+ 8;
9677 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9678 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9679 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9680 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9681 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9682 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9683 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9684 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9686 digest
[0] -= SHA512M_A
;
9687 digest
[1] -= SHA512M_B
;
9688 digest
[2] -= SHA512M_C
;
9689 digest
[3] -= SHA512M_D
;
9690 digest
[4] -= SHA512M_E
;
9691 digest
[5] -= SHA512M_F
;
9692 digest
[6] -= SHA512M_G
;
9693 digest
[7] -= SHA512M_H
;
9697 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9699 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9701 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9703 salt
->salt_len
= salt_len
;
9708 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9710 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9712 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9716 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9719 u32
*digest
= (u32
*) hash_buf
->digest
;
9721 salt_t
*salt
= hash_buf
->salt
;
9723 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9724 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9725 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9726 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9728 digest
[0] = byte_swap_32 (digest
[0]);
9729 digest
[1] = byte_swap_32 (digest
[1]);
9730 digest
[2] = byte_swap_32 (digest
[2]);
9731 digest
[3] = byte_swap_32 (digest
[3]);
9733 digest
[0] -= MD5M_A
;
9734 digest
[1] -= MD5M_B
;
9735 digest
[2] -= MD5M_C
;
9736 digest
[3] -= MD5M_D
;
9738 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9740 uint salt_len
= input_len
- 32 - 1;
9742 char *salt_buf
= input_buf
+ 32 + 1;
9744 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9746 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9748 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9750 salt
->salt_len
= salt_len
;
9755 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9757 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9759 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9763 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9768 char clean_input_buf
[32];
9770 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9771 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9773 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9777 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9783 clean_input_buf
[k
] = input_buf
[i
];
9791 u32
*digest
= (u32
*) hash_buf
->digest
;
9793 salt_t
*salt
= hash_buf
->salt
;
9795 u32 a
, b
, c
, d
, e
, f
;
9797 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9798 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9799 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9800 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9801 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9802 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9804 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9805 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9807 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9808 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9809 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9810 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9811 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9812 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9814 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9815 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9817 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9818 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9819 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9820 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9821 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9822 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9824 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9825 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9827 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9828 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9829 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9830 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9831 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9832 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9834 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9835 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9837 digest
[0] = byte_swap_32 (digest
[0]);
9838 digest
[1] = byte_swap_32 (digest
[1]);
9839 digest
[2] = byte_swap_32 (digest
[2]);
9840 digest
[3] = byte_swap_32 (digest
[3]);
9842 digest
[0] -= MD5M_A
;
9843 digest
[1] -= MD5M_B
;
9844 digest
[2] -= MD5M_C
;
9845 digest
[3] -= MD5M_D
;
9847 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9849 uint salt_len
= input_len
- 30 - 1;
9851 char *salt_buf
= input_buf
+ 30 + 1;
9853 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9855 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9857 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9858 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9860 salt
->salt_len
= salt_len
;
9862 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9864 salt
->salt_len
+= 22;
9869 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9871 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9873 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9877 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9880 u32
*digest
= (u32
*) hash_buf
->digest
;
9882 salt_t
*salt
= hash_buf
->salt
;
9884 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9885 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9886 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9887 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9888 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9890 digest
[0] -= SHA1M_A
;
9891 digest
[1] -= SHA1M_B
;
9892 digest
[2] -= SHA1M_C
;
9893 digest
[3] -= SHA1M_D
;
9894 digest
[4] -= SHA1M_E
;
9896 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9898 uint salt_len
= input_len
- 40 - 1;
9900 char *salt_buf
= input_buf
+ 40 + 1;
9902 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9904 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9906 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9908 salt
->salt_len
= salt_len
;
9913 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9915 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9917 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9921 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9924 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9926 char *iter_pos
= input_buf
+ 6;
9928 salt_t
*salt
= hash_buf
->salt
;
9930 uint iter
= atoi (iter_pos
);
9937 salt
->salt_iter
= iter
- 1;
9939 char *salt_pos
= strchr (iter_pos
, '#');
9941 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9945 char *digest_pos
= strchr (salt_pos
, '#');
9947 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9951 uint salt_len
= digest_pos
- salt_pos
- 1;
9953 u32
*digest
= (u32
*) hash_buf
->digest
;
9955 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9956 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9957 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9958 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9960 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9962 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9964 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9966 salt
->salt_len
= salt_len
;
9971 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9973 u32
*digest
= (u32
*) hash_buf
->digest
;
9975 salt_t
*salt
= hash_buf
->salt
;
9977 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9981 memcpy (&in
, input_buf
, input_len
);
9983 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9985 memcpy (digest
, in
.keymic
, 16);
9988 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9989 The phrase "Pairwise key expansion"
9990 Access Point Address (referred to as Authenticator Address AA)
9991 Supplicant Address (referred to as Supplicant Address SA)
9992 Access Point Nonce (referred to as Authenticator Anonce)
9993 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9996 uint salt_len
= strlen (in
.essid
);
9998 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10000 salt
->salt_len
= salt_len
;
10002 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10004 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10006 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10008 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10010 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10011 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10015 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10016 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10019 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10021 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10022 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10026 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10027 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10030 for (int i
= 0; i
< 25; i
++)
10032 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10035 wpa
->keyver
= in
.keyver
;
10037 if (wpa
->keyver
> 255)
10039 log_info ("ATTENTION!");
10040 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10041 log_info (" This could be due to a recent aircrack-ng bug.");
10042 log_info (" The key version was automatically reset to a reasonable value.");
10045 wpa
->keyver
&= 0xff;
10048 wpa
->eapol_size
= in
.eapol_size
;
10050 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10052 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10054 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10056 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10058 if (wpa
->keyver
== 1)
10064 digest
[0] = byte_swap_32 (digest
[0]);
10065 digest
[1] = byte_swap_32 (digest
[1]);
10066 digest
[2] = byte_swap_32 (digest
[2]);
10067 digest
[3] = byte_swap_32 (digest
[3]);
10069 for (int i
= 0; i
< 64; i
++)
10071 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10075 salt
->salt_buf
[10] = digest
[1];
10076 salt
->salt_buf
[11] = digest
[2];
10078 return (PARSER_OK
);
10081 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10083 u32
*digest
= (u32
*) hash_buf
->digest
;
10085 salt_t
*salt
= hash_buf
->salt
;
10087 if (input_len
== 0)
10089 log_error ("Password Safe v2 container not specified");
10094 FILE *fp
= fopen (input_buf
, "rb");
10098 log_error ("%s: %s", input_buf
, strerror (errno
));
10105 memset (&buf
, 0, sizeof (psafe2_hdr
));
10107 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10111 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10113 salt
->salt_buf
[0] = buf
.random
[0];
10114 salt
->salt_buf
[1] = buf
.random
[1];
10116 salt
->salt_len
= 8;
10117 salt
->salt_iter
= 1000;
10119 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10120 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10121 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10122 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10123 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10125 return (PARSER_OK
);
10128 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10130 u32
*digest
= (u32
*) hash_buf
->digest
;
10132 salt_t
*salt
= hash_buf
->salt
;
10134 if (input_len
== 0)
10136 log_error (".psafe3 not specified");
10141 FILE *fp
= fopen (input_buf
, "rb");
10145 log_error ("%s: %s", input_buf
, strerror (errno
));
10152 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10156 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10158 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10160 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10162 salt
->salt_iter
= in
.iterations
+ 1;
10164 salt
->salt_buf
[0] = in
.salt_buf
[0];
10165 salt
->salt_buf
[1] = in
.salt_buf
[1];
10166 salt
->salt_buf
[2] = in
.salt_buf
[2];
10167 salt
->salt_buf
[3] = in
.salt_buf
[3];
10168 salt
->salt_buf
[4] = in
.salt_buf
[4];
10169 salt
->salt_buf
[5] = in
.salt_buf
[5];
10170 salt
->salt_buf
[6] = in
.salt_buf
[6];
10171 salt
->salt_buf
[7] = in
.salt_buf
[7];
10173 salt
->salt_len
= 32;
10175 digest
[0] = in
.hash_buf
[0];
10176 digest
[1] = in
.hash_buf
[1];
10177 digest
[2] = in
.hash_buf
[2];
10178 digest
[3] = in
.hash_buf
[3];
10179 digest
[4] = in
.hash_buf
[4];
10180 digest
[5] = in
.hash_buf
[5];
10181 digest
[6] = in
.hash_buf
[6];
10182 digest
[7] = in
.hash_buf
[7];
10184 digest
[0] = byte_swap_32 (digest
[0]);
10185 digest
[1] = byte_swap_32 (digest
[1]);
10186 digest
[2] = byte_swap_32 (digest
[2]);
10187 digest
[3] = byte_swap_32 (digest
[3]);
10188 digest
[4] = byte_swap_32 (digest
[4]);
10189 digest
[5] = byte_swap_32 (digest
[5]);
10190 digest
[6] = byte_swap_32 (digest
[6]);
10191 digest
[7] = byte_swap_32 (digest
[7]);
10193 return (PARSER_OK
);
10196 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10198 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10200 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10202 u32
*digest
= (u32
*) hash_buf
->digest
;
10204 salt_t
*salt
= hash_buf
->salt
;
10206 char *iter_pos
= input_buf
+ 3;
10208 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10210 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10212 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10214 salt
->salt_iter
= salt_iter
;
10216 char *salt_pos
= iter_pos
+ 1;
10220 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10222 salt
->salt_len
= salt_len
;
10224 char *hash_pos
= salt_pos
+ salt_len
;
10226 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10228 return (PARSER_OK
);
10231 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10233 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10235 u32
*digest
= (u32
*) hash_buf
->digest
;
10237 salt_t
*salt
= hash_buf
->salt
;
10239 char *salt_pos
= input_buf
+ 3;
10241 uint iterations_len
= 0;
10243 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10247 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10249 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10250 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10254 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10258 iterations_len
+= 8;
10262 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10265 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10267 char *hash_pos
= strchr (salt_pos
, '$');
10269 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10271 uint salt_len
= hash_pos
- salt_pos
;
10273 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10275 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10277 salt
->salt_len
= salt_len
;
10281 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10283 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10285 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10287 return (PARSER_OK
);
10290 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10292 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10294 u32
*digest
= (u32
*) hash_buf
->digest
;
10296 salt_t
*salt
= hash_buf
->salt
;
10298 char *salt_pos
= input_buf
+ 6;
10300 uint iterations_len
= 0;
10302 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10306 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10308 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10309 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10313 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10317 iterations_len
+= 8;
10321 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10324 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10326 char *hash_pos
= strchr (salt_pos
, '$');
10328 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10330 uint salt_len
= hash_pos
- salt_pos
;
10332 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10334 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10336 salt
->salt_len
= salt_len
;
10340 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10342 return (PARSER_OK
);
10345 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10347 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10349 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10351 u32
*digest
= (u32
*) hash_buf
->digest
;
10353 salt_t
*salt
= hash_buf
->salt
;
10355 char *salt_pos
= input_buf
+ 14;
10357 char *hash_pos
= strchr (salt_pos
, '*');
10359 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10363 uint salt_len
= hash_pos
- salt_pos
- 1;
10365 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10367 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10369 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10371 salt
->salt_len
= salt_len
;
10375 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10377 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10379 memcpy (digest
, tmp_buf
, 20);
10381 digest
[0] = byte_swap_32 (digest
[0]);
10382 digest
[1] = byte_swap_32 (digest
[1]);
10383 digest
[2] = byte_swap_32 (digest
[2]);
10384 digest
[3] = byte_swap_32 (digest
[3]);
10385 digest
[4] = byte_swap_32 (digest
[4]);
10387 digest
[0] -= SHA1M_A
;
10388 digest
[1] -= SHA1M_B
;
10389 digest
[2] -= SHA1M_C
;
10390 digest
[3] -= SHA1M_D
;
10391 digest
[4] -= SHA1M_E
;
10393 return (PARSER_OK
);
10396 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10398 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10400 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10402 if (c12
& 3) return (PARSER_HASH_VALUE
);
10404 u32
*digest
= (u32
*) hash_buf
->digest
;
10406 salt_t
*salt
= hash_buf
->salt
;
10408 // for ascii_digest
10409 salt
->salt_sign
[0] = input_buf
[0];
10410 salt
->salt_sign
[1] = input_buf
[1];
10412 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10413 | itoa64_to_int (input_buf
[1]) << 6;
10415 salt
->salt_len
= 2;
10419 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10421 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10423 memcpy (digest
, tmp_buf
, 8);
10427 IP (digest
[0], digest
[1], tt
);
10432 return (PARSER_OK
);
10435 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10437 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10439 u32
*digest
= (u32
*) hash_buf
->digest
;
10441 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10442 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10443 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10444 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10446 digest
[0] = byte_swap_32 (digest
[0]);
10447 digest
[1] = byte_swap_32 (digest
[1]);
10448 digest
[2] = byte_swap_32 (digest
[2]);
10449 digest
[3] = byte_swap_32 (digest
[3]);
10451 digest
[0] -= MD4M_A
;
10452 digest
[1] -= MD4M_B
;
10453 digest
[2] -= MD4M_C
;
10454 digest
[3] -= MD4M_D
;
10456 return (PARSER_OK
);
10459 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10461 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10463 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10467 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10470 u32
*digest
= (u32
*) hash_buf
->digest
;
10472 salt_t
*salt
= hash_buf
->salt
;
10474 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10475 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10476 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10477 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10479 digest
[0] = byte_swap_32 (digest
[0]);
10480 digest
[1] = byte_swap_32 (digest
[1]);
10481 digest
[2] = byte_swap_32 (digest
[2]);
10482 digest
[3] = byte_swap_32 (digest
[3]);
10484 digest
[0] -= MD4M_A
;
10485 digest
[1] -= MD4M_B
;
10486 digest
[2] -= MD4M_C
;
10487 digest
[3] -= MD4M_D
;
10489 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10491 uint salt_len
= input_len
- 32 - 1;
10493 char *salt_buf
= input_buf
+ 32 + 1;
10495 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10497 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10499 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10501 salt
->salt_len
= salt_len
;
10503 return (PARSER_OK
);
10506 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10508 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10510 u32
*digest
= (u32
*) hash_buf
->digest
;
10512 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10513 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10514 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10515 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10517 digest
[0] = byte_swap_32 (digest
[0]);
10518 digest
[1] = byte_swap_32 (digest
[1]);
10519 digest
[2] = byte_swap_32 (digest
[2]);
10520 digest
[3] = byte_swap_32 (digest
[3]);
10522 digest
[0] -= MD5M_A
;
10523 digest
[1] -= MD5M_B
;
10524 digest
[2] -= MD5M_C
;
10525 digest
[3] -= MD5M_D
;
10527 return (PARSER_OK
);
10530 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10532 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10534 u32
*digest
= (u32
*) hash_buf
->digest
;
10536 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10537 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10541 digest
[0] = byte_swap_32 (digest
[0]);
10542 digest
[1] = byte_swap_32 (digest
[1]);
10544 return (PARSER_OK
);
10547 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10549 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10551 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10555 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10558 u32
*digest
= (u32
*) hash_buf
->digest
;
10560 salt_t
*salt
= hash_buf
->salt
;
10562 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10563 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10564 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10565 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10567 digest
[0] = byte_swap_32 (digest
[0]);
10568 digest
[1] = byte_swap_32 (digest
[1]);
10569 digest
[2] = byte_swap_32 (digest
[2]);
10570 digest
[3] = byte_swap_32 (digest
[3]);
10572 digest
[0] -= MD5M_A
;
10573 digest
[1] -= MD5M_B
;
10574 digest
[2] -= MD5M_C
;
10575 digest
[3] -= MD5M_D
;
10577 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10579 uint salt_len
= input_len
- 32 - 1;
10581 char *salt_buf
= input_buf
+ 32 + 1;
10583 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10585 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10587 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10589 salt
->salt_len
= salt_len
;
10591 return (PARSER_OK
);
10594 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10596 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10598 u32
*digest
= (u32
*) hash_buf
->digest
;
10600 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10601 | itoa64_to_int (input_buf
[ 1]) << 6
10602 | itoa64_to_int (input_buf
[ 2]) << 12
10603 | itoa64_to_int (input_buf
[ 3]) << 18;
10604 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10605 | itoa64_to_int (input_buf
[ 5]) << 6
10606 | itoa64_to_int (input_buf
[ 6]) << 12
10607 | itoa64_to_int (input_buf
[ 7]) << 18;
10608 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10609 | itoa64_to_int (input_buf
[ 9]) << 6
10610 | itoa64_to_int (input_buf
[10]) << 12
10611 | itoa64_to_int (input_buf
[11]) << 18;
10612 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10613 | itoa64_to_int (input_buf
[13]) << 6
10614 | itoa64_to_int (input_buf
[14]) << 12
10615 | itoa64_to_int (input_buf
[15]) << 18;
10617 digest
[0] -= MD5M_A
;
10618 digest
[1] -= MD5M_B
;
10619 digest
[2] -= MD5M_C
;
10620 digest
[3] -= MD5M_D
;
10622 digest
[0] &= 0x00ffffff;
10623 digest
[1] &= 0x00ffffff;
10624 digest
[2] &= 0x00ffffff;
10625 digest
[3] &= 0x00ffffff;
10627 return (PARSER_OK
);
10630 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10632 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10634 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10638 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10641 u32
*digest
= (u32
*) hash_buf
->digest
;
10643 salt_t
*salt
= hash_buf
->salt
;
10645 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10646 | itoa64_to_int (input_buf
[ 1]) << 6
10647 | itoa64_to_int (input_buf
[ 2]) << 12
10648 | itoa64_to_int (input_buf
[ 3]) << 18;
10649 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10650 | itoa64_to_int (input_buf
[ 5]) << 6
10651 | itoa64_to_int (input_buf
[ 6]) << 12
10652 | itoa64_to_int (input_buf
[ 7]) << 18;
10653 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10654 | itoa64_to_int (input_buf
[ 9]) << 6
10655 | itoa64_to_int (input_buf
[10]) << 12
10656 | itoa64_to_int (input_buf
[11]) << 18;
10657 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10658 | itoa64_to_int (input_buf
[13]) << 6
10659 | itoa64_to_int (input_buf
[14]) << 12
10660 | itoa64_to_int (input_buf
[15]) << 18;
10662 digest
[0] -= MD5M_A
;
10663 digest
[1] -= MD5M_B
;
10664 digest
[2] -= MD5M_C
;
10665 digest
[3] -= MD5M_D
;
10667 digest
[0] &= 0x00ffffff;
10668 digest
[1] &= 0x00ffffff;
10669 digest
[2] &= 0x00ffffff;
10670 digest
[3] &= 0x00ffffff;
10672 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10674 uint salt_len
= input_len
- 16 - 1;
10676 char *salt_buf
= input_buf
+ 16 + 1;
10678 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10680 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10682 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10684 salt
->salt_len
= salt_len
;
10686 return (PARSER_OK
);
10689 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10691 key
[0] = (nthash
[0] >> 0);
10692 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10693 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10694 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10695 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10696 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10697 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10698 key
[7] = (nthash
[6] << 1);
10710 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10712 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10714 u32
*digest
= (u32
*) hash_buf
->digest
;
10716 salt_t
*salt
= hash_buf
->salt
;
10718 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10724 char *user_pos
= input_buf
;
10726 char *unused_pos
= strchr (user_pos
, ':');
10728 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10730 uint user_len
= unused_pos
- user_pos
;
10732 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10736 char *domain_pos
= strchr (unused_pos
, ':');
10738 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10740 uint unused_len
= domain_pos
- unused_pos
;
10742 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10746 char *srvchall_pos
= strchr (domain_pos
, ':');
10748 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10750 uint domain_len
= srvchall_pos
- domain_pos
;
10752 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10756 char *hash_pos
= strchr (srvchall_pos
, ':');
10758 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10760 uint srvchall_len
= hash_pos
- srvchall_pos
;
10762 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10766 char *clichall_pos
= strchr (hash_pos
, ':');
10768 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10770 uint hash_len
= clichall_pos
- hash_pos
;
10772 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10776 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10778 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10781 * store some data for later use
10784 netntlm
->user_len
= user_len
* 2;
10785 netntlm
->domain_len
= domain_len
* 2;
10786 netntlm
->srvchall_len
= srvchall_len
/ 2;
10787 netntlm
->clichall_len
= clichall_len
/ 2;
10789 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10790 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10793 * handle username and domainname
10796 for (uint i
= 0; i
< user_len
; i
++)
10798 *userdomain_ptr
++ = user_pos
[i
];
10799 *userdomain_ptr
++ = 0;
10802 for (uint i
= 0; i
< domain_len
; i
++)
10804 *userdomain_ptr
++ = domain_pos
[i
];
10805 *userdomain_ptr
++ = 0;
10809 * handle server challenge encoding
10812 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10814 const char p0
= srvchall_pos
[i
+ 0];
10815 const char p1
= srvchall_pos
[i
+ 1];
10817 *chall_ptr
++ = hex_convert (p1
) << 0
10818 | hex_convert (p0
) << 4;
10822 * handle client challenge encoding
10825 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10827 const char p0
= clichall_pos
[i
+ 0];
10828 const char p1
= clichall_pos
[i
+ 1];
10830 *chall_ptr
++ = hex_convert (p1
) << 0
10831 | hex_convert (p0
) << 4;
10838 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10840 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10842 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10844 salt
->salt_len
= salt_len
;
10846 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10847 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10848 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10849 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10851 digest
[0] = byte_swap_32 (digest
[0]);
10852 digest
[1] = byte_swap_32 (digest
[1]);
10853 digest
[2] = byte_swap_32 (digest
[2]);
10854 digest
[3] = byte_swap_32 (digest
[3]);
10856 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10858 uint digest_tmp
[2];
10860 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10861 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10863 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10864 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10866 /* special case 2: ESS */
10868 if (srvchall_len
== 48)
10870 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10874 w
[ 0] = netntlm
->chall_buf
[6];
10875 w
[ 1] = netntlm
->chall_buf
[7];
10876 w
[ 2] = netntlm
->chall_buf
[0];
10877 w
[ 3] = netntlm
->chall_buf
[1];
10900 salt
->salt_buf
[0] = dgst
[0];
10901 salt
->salt_buf
[1] = dgst
[1];
10905 /* precompute netntlmv1 exploit start */
10907 for (uint i
= 0; i
< 0x10000; i
++)
10909 uint key_md4
[2] = { i
, 0 };
10910 uint key_des
[2] = { 0, 0 };
10912 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10917 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10919 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10921 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10923 if (data3
[0] != digest_tmp
[0]) continue;
10924 if (data3
[1] != digest_tmp
[1]) continue;
10926 salt
->salt_buf
[2] = i
;
10928 salt
->salt_len
= 24;
10933 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10934 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10936 /* precompute netntlmv1 exploit stop */
10940 IP (digest
[0], digest
[1], tt
);
10941 IP (digest
[2], digest
[3], tt
);
10943 digest
[0] = rotr32 (digest
[0], 29);
10944 digest
[1] = rotr32 (digest
[1], 29);
10945 digest
[2] = rotr32 (digest
[2], 29);
10946 digest
[3] = rotr32 (digest
[3], 29);
10948 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10950 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10951 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10953 return (PARSER_OK
);
10956 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10958 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10960 u32
*digest
= (u32
*) hash_buf
->digest
;
10962 salt_t
*salt
= hash_buf
->salt
;
10964 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10970 char *user_pos
= input_buf
;
10972 char *unused_pos
= strchr (user_pos
, ':');
10974 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10976 uint user_len
= unused_pos
- user_pos
;
10978 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10982 char *domain_pos
= strchr (unused_pos
, ':');
10984 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10986 uint unused_len
= domain_pos
- unused_pos
;
10988 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10992 char *srvchall_pos
= strchr (domain_pos
, ':');
10994 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10996 uint domain_len
= srvchall_pos
- domain_pos
;
10998 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11002 char *hash_pos
= strchr (srvchall_pos
, ':');
11004 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11006 uint srvchall_len
= hash_pos
- srvchall_pos
;
11008 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11012 char *clichall_pos
= strchr (hash_pos
, ':');
11014 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11016 uint hash_len
= clichall_pos
- hash_pos
;
11018 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11022 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11024 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11026 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11029 * store some data for later use
11032 netntlm
->user_len
= user_len
* 2;
11033 netntlm
->domain_len
= domain_len
* 2;
11034 netntlm
->srvchall_len
= srvchall_len
/ 2;
11035 netntlm
->clichall_len
= clichall_len
/ 2;
11037 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11038 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11041 * handle username and domainname
11044 for (uint i
= 0; i
< user_len
; i
++)
11046 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11047 *userdomain_ptr
++ = 0;
11050 for (uint i
= 0; i
< domain_len
; i
++)
11052 *userdomain_ptr
++ = domain_pos
[i
];
11053 *userdomain_ptr
++ = 0;
11056 *userdomain_ptr
++ = 0x80;
11059 * handle server challenge encoding
11062 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11064 const char p0
= srvchall_pos
[i
+ 0];
11065 const char p1
= srvchall_pos
[i
+ 1];
11067 *chall_ptr
++ = hex_convert (p1
) << 0
11068 | hex_convert (p0
) << 4;
11072 * handle client challenge encoding
11075 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11077 const char p0
= clichall_pos
[i
+ 0];
11078 const char p1
= clichall_pos
[i
+ 1];
11080 *chall_ptr
++ = hex_convert (p1
) << 0
11081 | hex_convert (p0
) << 4;
11084 *chall_ptr
++ = 0x80;
11087 * handle hash itself
11090 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11091 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11092 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11093 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11095 digest
[0] = byte_swap_32 (digest
[0]);
11096 digest
[1] = byte_swap_32 (digest
[1]);
11097 digest
[2] = byte_swap_32 (digest
[2]);
11098 digest
[3] = byte_swap_32 (digest
[3]);
11101 * reuse challange data as salt_buf, its the buffer that is most likely unique
11104 salt
->salt_buf
[0] = 0;
11105 salt
->salt_buf
[1] = 0;
11106 salt
->salt_buf
[2] = 0;
11107 salt
->salt_buf
[3] = 0;
11108 salt
->salt_buf
[4] = 0;
11109 salt
->salt_buf
[5] = 0;
11110 salt
->salt_buf
[6] = 0;
11111 salt
->salt_buf
[7] = 0;
11115 uptr
= (uint
*) netntlm
->userdomain_buf
;
11117 for (uint i
= 0; i
< 16; i
+= 16)
11119 md5_64 (uptr
, salt
->salt_buf
);
11122 uptr
= (uint
*) netntlm
->chall_buf
;
11124 for (uint i
= 0; i
< 256; i
+= 16)
11126 md5_64 (uptr
, salt
->salt_buf
);
11129 salt
->salt_len
= 16;
11131 return (PARSER_OK
);
11134 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11136 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11138 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11142 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11145 u32
*digest
= (u32
*) hash_buf
->digest
;
11147 salt_t
*salt
= hash_buf
->salt
;
11149 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11150 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11151 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11152 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11154 digest
[0] = byte_swap_32 (digest
[0]);
11155 digest
[1] = byte_swap_32 (digest
[1]);
11156 digest
[2] = byte_swap_32 (digest
[2]);
11157 digest
[3] = byte_swap_32 (digest
[3]);
11159 digest
[0] -= MD5M_A
;
11160 digest
[1] -= MD5M_B
;
11161 digest
[2] -= MD5M_C
;
11162 digest
[3] -= MD5M_D
;
11164 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11166 uint salt_len
= input_len
- 32 - 1;
11168 char *salt_buf
= input_buf
+ 32 + 1;
11170 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11172 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11174 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11176 salt
->salt_len
= salt_len
;
11178 return (PARSER_OK
);
11181 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11183 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11185 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11189 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11192 u32
*digest
= (u32
*) hash_buf
->digest
;
11194 salt_t
*salt
= hash_buf
->salt
;
11196 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11197 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11198 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11199 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11201 digest
[0] = byte_swap_32 (digest
[0]);
11202 digest
[1] = byte_swap_32 (digest
[1]);
11203 digest
[2] = byte_swap_32 (digest
[2]);
11204 digest
[3] = byte_swap_32 (digest
[3]);
11206 digest
[0] -= MD5M_A
;
11207 digest
[1] -= MD5M_B
;
11208 digest
[2] -= MD5M_C
;
11209 digest
[3] -= MD5M_D
;
11211 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11213 uint salt_len
= input_len
- 32 - 1;
11215 char *salt_buf
= input_buf
+ 32 + 1;
11217 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11219 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11221 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11223 salt
->salt_len
= salt_len
;
11225 return (PARSER_OK
);
11228 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11230 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11232 u32
*digest
= (u32
*) hash_buf
->digest
;
11234 salt_t
*salt
= hash_buf
->salt
;
11236 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11237 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11238 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11239 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11241 digest
[0] = byte_swap_32 (digest
[0]);
11242 digest
[1] = byte_swap_32 (digest
[1]);
11243 digest
[2] = byte_swap_32 (digest
[2]);
11244 digest
[3] = byte_swap_32 (digest
[3]);
11246 digest
[0] -= MD5M_A
;
11247 digest
[1] -= MD5M_B
;
11248 digest
[2] -= MD5M_C
;
11249 digest
[3] -= MD5M_D
;
11252 * This is a virtual salt. While the algorithm is basically not salted
11253 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11254 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11257 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11259 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11261 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11263 salt
->salt_len
= salt_len
;
11265 return (PARSER_OK
);
11268 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11270 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11272 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11276 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11279 u32
*digest
= (u32
*) hash_buf
->digest
;
11281 salt_t
*salt
= hash_buf
->salt
;
11283 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11284 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11285 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11286 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11288 digest
[0] = byte_swap_32 (digest
[0]);
11289 digest
[1] = byte_swap_32 (digest
[1]);
11290 digest
[2] = byte_swap_32 (digest
[2]);
11291 digest
[3] = byte_swap_32 (digest
[3]);
11293 digest
[0] -= MD5M_A
;
11294 digest
[1] -= MD5M_B
;
11295 digest
[2] -= MD5M_C
;
11296 digest
[3] -= MD5M_D
;
11298 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11300 uint salt_len
= input_len
- 32 - 1;
11302 char *salt_buf
= input_buf
+ 32 + 1;
11304 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11306 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11308 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11310 salt
->salt_len
= salt_len
;
11312 return (PARSER_OK
);
11315 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11317 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11319 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11323 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11326 u32
*digest
= (u32
*) hash_buf
->digest
;
11328 salt_t
*salt
= hash_buf
->salt
;
11330 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11331 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11332 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11333 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11335 digest
[0] = byte_swap_32 (digest
[0]);
11336 digest
[1] = byte_swap_32 (digest
[1]);
11337 digest
[2] = byte_swap_32 (digest
[2]);
11338 digest
[3] = byte_swap_32 (digest
[3]);
11340 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11342 uint salt_len
= input_len
- 32 - 1;
11344 char *salt_buf
= input_buf
+ 32 + 1;
11346 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11348 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11350 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11352 salt
->salt_len
= salt_len
;
11354 return (PARSER_OK
);
11357 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11359 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11361 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11365 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11368 u32
*digest
= (u32
*) hash_buf
->digest
;
11370 salt_t
*salt
= hash_buf
->salt
;
11372 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11373 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11374 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11375 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11377 digest
[0] = byte_swap_32 (digest
[0]);
11378 digest
[1] = byte_swap_32 (digest
[1]);
11379 digest
[2] = byte_swap_32 (digest
[2]);
11380 digest
[3] = byte_swap_32 (digest
[3]);
11382 digest
[0] -= MD4M_A
;
11383 digest
[1] -= MD4M_B
;
11384 digest
[2] -= MD4M_C
;
11385 digest
[3] -= MD4M_D
;
11387 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11389 uint salt_len
= input_len
- 32 - 1;
11391 char *salt_buf
= input_buf
+ 32 + 1;
11393 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11395 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11397 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11399 salt
->salt_len
= salt_len
;
11401 return (PARSER_OK
);
11404 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11406 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11408 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11412 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11415 u32
*digest
= (u32
*) hash_buf
->digest
;
11417 salt_t
*salt
= hash_buf
->salt
;
11419 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11420 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11421 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11422 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11424 digest
[0] = byte_swap_32 (digest
[0]);
11425 digest
[1] = byte_swap_32 (digest
[1]);
11426 digest
[2] = byte_swap_32 (digest
[2]);
11427 digest
[3] = byte_swap_32 (digest
[3]);
11429 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11431 uint salt_len
= input_len
- 32 - 1;
11433 char *salt_buf
= input_buf
+ 32 + 1;
11435 uint salt_pc_block
[16];
11437 memset (salt_pc_block
, 0, sizeof (salt_pc_block
));
11439 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11441 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11443 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11445 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11447 salt_pc_block
[14] = salt_len
* 8;
11449 uint salt_pc_digest
[4];
11451 salt_pc_digest
[0] = MAGIC_A
;
11452 salt_pc_digest
[1] = MAGIC_B
;
11453 salt_pc_digest
[2] = MAGIC_C
;
11454 salt_pc_digest
[3] = MAGIC_D
;
11456 md5_64 (salt_pc_block
, salt_pc_digest
);
11458 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11459 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11460 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11461 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11463 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11465 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11467 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11469 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11470 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11471 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11472 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11474 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11476 return (PARSER_OK
);
11479 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11481 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11483 u32
*digest
= (u32
*) hash_buf
->digest
;
11485 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11486 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11487 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11488 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11489 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11491 digest
[0] -= SHA1M_A
;
11492 digest
[1] -= SHA1M_B
;
11493 digest
[2] -= SHA1M_C
;
11494 digest
[3] -= SHA1M_D
;
11495 digest
[4] -= SHA1M_E
;
11497 return (PARSER_OK
);
11500 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11502 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11504 u32
*digest
= (u32
*) hash_buf
->digest
;
11506 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11507 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11508 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11509 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11510 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11512 return (PARSER_OK
);
11515 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11517 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11519 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11523 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11526 u32
*digest
= (u32
*) hash_buf
->digest
;
11528 salt_t
*salt
= hash_buf
->salt
;
11530 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11531 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11532 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11533 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11534 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11536 digest
[0] -= SHA1M_A
;
11537 digest
[1] -= SHA1M_B
;
11538 digest
[2] -= SHA1M_C
;
11539 digest
[3] -= SHA1M_D
;
11540 digest
[4] -= SHA1M_E
;
11542 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11544 uint salt_len
= input_len
- 40 - 1;
11546 char *salt_buf
= input_buf
+ 40 + 1;
11548 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11550 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11552 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11554 salt
->salt_len
= salt_len
;
11556 return (PARSER_OK
);
11559 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11561 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11563 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11565 u32
*digest
= (u32
*) hash_buf
->digest
;
11569 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11571 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11573 memcpy (digest
, tmp_buf
, 20);
11575 digest
[0] = byte_swap_32 (digest
[0]);
11576 digest
[1] = byte_swap_32 (digest
[1]);
11577 digest
[2] = byte_swap_32 (digest
[2]);
11578 digest
[3] = byte_swap_32 (digest
[3]);
11579 digest
[4] = byte_swap_32 (digest
[4]);
11581 digest
[0] -= SHA1M_A
;
11582 digest
[1] -= SHA1M_B
;
11583 digest
[2] -= SHA1M_C
;
11584 digest
[3] -= SHA1M_D
;
11585 digest
[4] -= SHA1M_E
;
11587 return (PARSER_OK
);
11590 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11592 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11594 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11596 u32
*digest
= (u32
*) hash_buf
->digest
;
11598 salt_t
*salt
= hash_buf
->salt
;
11602 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11604 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11606 memcpy (digest
, tmp_buf
, 20);
11608 salt
->salt_len
= tmp_len
- 20;
11610 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11612 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11614 char *ptr
= (char *) salt
->salt_buf
;
11616 ptr
[salt
->salt_len
] = 0x80;
11619 digest
[0] = byte_swap_32 (digest
[0]);
11620 digest
[1] = byte_swap_32 (digest
[1]);
11621 digest
[2] = byte_swap_32 (digest
[2]);
11622 digest
[3] = byte_swap_32 (digest
[3]);
11623 digest
[4] = byte_swap_32 (digest
[4]);
11625 digest
[0] -= SHA1M_A
;
11626 digest
[1] -= SHA1M_B
;
11627 digest
[2] -= SHA1M_C
;
11628 digest
[3] -= SHA1M_D
;
11629 digest
[4] -= SHA1M_E
;
11631 return (PARSER_OK
);
11634 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11636 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11638 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11640 u32
*digest
= (u32
*) hash_buf
->digest
;
11642 salt_t
*salt
= hash_buf
->salt
;
11644 char *salt_buf
= input_buf
+ 6;
11648 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11650 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11652 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11654 salt
->salt_len
= salt_len
;
11656 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11658 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11659 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11660 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11661 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11662 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11664 digest
[0] -= SHA1M_A
;
11665 digest
[1] -= SHA1M_B
;
11666 digest
[2] -= SHA1M_C
;
11667 digest
[3] -= SHA1M_D
;
11668 digest
[4] -= SHA1M_E
;
11670 return (PARSER_OK
);
11673 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11675 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11677 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11679 u32
*digest
= (u32
*) hash_buf
->digest
;
11681 salt_t
*salt
= hash_buf
->salt
;
11683 char *salt_buf
= input_buf
+ 6;
11687 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11689 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11691 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11693 salt
->salt_len
= salt_len
;
11695 char *hash_pos
= input_buf
+ 6 + 8;
11697 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11698 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11699 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11700 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11701 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11703 digest
[0] -= SHA1M_A
;
11704 digest
[1] -= SHA1M_B
;
11705 digest
[2] -= SHA1M_C
;
11706 digest
[3] -= SHA1M_D
;
11707 digest
[4] -= SHA1M_E
;
11709 return (PARSER_OK
);
11712 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11714 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11716 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11718 u64
*digest
= (u64
*) hash_buf
->digest
;
11720 salt_t
*salt
= hash_buf
->salt
;
11722 char *salt_buf
= input_buf
+ 6;
11726 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11728 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11730 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11732 salt
->salt_len
= salt_len
;
11734 char *hash_pos
= input_buf
+ 6 + 8;
11736 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11737 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11738 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11739 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11740 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11741 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11742 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11743 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11745 digest
[0] -= SHA512M_A
;
11746 digest
[1] -= SHA512M_B
;
11747 digest
[2] -= SHA512M_C
;
11748 digest
[3] -= SHA512M_D
;
11749 digest
[4] -= SHA512M_E
;
11750 digest
[5] -= SHA512M_F
;
11751 digest
[6] -= SHA512M_G
;
11752 digest
[7] -= SHA512M_H
;
11754 return (PARSER_OK
);
11757 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11759 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11761 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11765 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11768 u32
*digest
= (u32
*) hash_buf
->digest
;
11770 salt_t
*salt
= hash_buf
->salt
;
11772 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11773 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11777 digest
[0] = byte_swap_32 (digest
[0]);
11778 digest
[1] = byte_swap_32 (digest
[1]);
11780 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11782 uint salt_len
= input_len
- 16 - 1;
11784 char *salt_buf
= input_buf
+ 16 + 1;
11786 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11788 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11790 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11792 salt
->salt_len
= salt_len
;
11794 return (PARSER_OK
);
11797 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11799 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11801 u32
*digest
= (u32
*) hash_buf
->digest
;
11803 salt_t
*salt
= hash_buf
->salt
;
11805 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11806 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11807 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11808 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11809 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11811 digest
[0] -= SHA1M_A
;
11812 digest
[1] -= SHA1M_B
;
11813 digest
[2] -= SHA1M_C
;
11814 digest
[3] -= SHA1M_D
;
11815 digest
[4] -= SHA1M_E
;
11817 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11819 uint salt_len
= input_len
- 40 - 1;
11821 char *salt_buf
= input_buf
+ 40 + 1;
11823 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11825 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11827 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11829 salt
->salt_len
= salt_len
;
11831 return (PARSER_OK
);
11834 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11836 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11838 u32
*digest
= (u32
*) hash_buf
->digest
;
11840 salt_t
*salt
= hash_buf
->salt
;
11842 char *hash_pos
= input_buf
;
11844 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11845 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11846 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11847 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11848 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11849 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11850 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11851 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11852 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11853 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11854 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11855 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11856 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11857 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11858 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11859 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11861 char *salt_pos
= input_buf
+ 128;
11863 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11864 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11865 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11866 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11868 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11869 salt
->salt_len
= 16;
11871 return (PARSER_OK
);
11874 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11876 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11878 u32
*digest
= (u32
*) hash_buf
->digest
;
11880 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11881 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11882 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11883 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11884 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11885 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11886 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11887 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11889 digest
[0] -= SHA256M_A
;
11890 digest
[1] -= SHA256M_B
;
11891 digest
[2] -= SHA256M_C
;
11892 digest
[3] -= SHA256M_D
;
11893 digest
[4] -= SHA256M_E
;
11894 digest
[5] -= SHA256M_F
;
11895 digest
[6] -= SHA256M_G
;
11896 digest
[7] -= SHA256M_H
;
11898 return (PARSER_OK
);
11901 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11903 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11905 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11909 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11912 u32
*digest
= (u32
*) hash_buf
->digest
;
11914 salt_t
*salt
= hash_buf
->salt
;
11916 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11917 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11918 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11919 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11920 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11921 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11922 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11923 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11925 digest
[0] -= SHA256M_A
;
11926 digest
[1] -= SHA256M_B
;
11927 digest
[2] -= SHA256M_C
;
11928 digest
[3] -= SHA256M_D
;
11929 digest
[4] -= SHA256M_E
;
11930 digest
[5] -= SHA256M_F
;
11931 digest
[6] -= SHA256M_G
;
11932 digest
[7] -= SHA256M_H
;
11934 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11936 uint salt_len
= input_len
- 64 - 1;
11938 char *salt_buf
= input_buf
+ 64 + 1;
11940 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11942 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11944 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11946 salt
->salt_len
= salt_len
;
11948 return (PARSER_OK
);
11951 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11953 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11955 u64
*digest
= (u64
*) hash_buf
->digest
;
11957 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11958 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11959 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11960 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11961 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11962 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11966 digest
[0] -= SHA384M_A
;
11967 digest
[1] -= SHA384M_B
;
11968 digest
[2] -= SHA384M_C
;
11969 digest
[3] -= SHA384M_D
;
11970 digest
[4] -= SHA384M_E
;
11971 digest
[5] -= SHA384M_F
;
11975 return (PARSER_OK
);
11978 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11980 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11982 u64
*digest
= (u64
*) hash_buf
->digest
;
11984 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11985 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11986 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11987 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11988 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11989 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11990 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11991 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11993 digest
[0] -= SHA512M_A
;
11994 digest
[1] -= SHA512M_B
;
11995 digest
[2] -= SHA512M_C
;
11996 digest
[3] -= SHA512M_D
;
11997 digest
[4] -= SHA512M_E
;
11998 digest
[5] -= SHA512M_F
;
11999 digest
[6] -= SHA512M_G
;
12000 digest
[7] -= SHA512M_H
;
12002 return (PARSER_OK
);
12005 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12007 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12009 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12013 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12016 u64
*digest
= (u64
*) hash_buf
->digest
;
12018 salt_t
*salt
= hash_buf
->salt
;
12020 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12021 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12022 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12023 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12024 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12025 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12026 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12027 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12029 digest
[0] -= SHA512M_A
;
12030 digest
[1] -= SHA512M_B
;
12031 digest
[2] -= SHA512M_C
;
12032 digest
[3] -= SHA512M_D
;
12033 digest
[4] -= SHA512M_E
;
12034 digest
[5] -= SHA512M_F
;
12035 digest
[6] -= SHA512M_G
;
12036 digest
[7] -= SHA512M_H
;
12038 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12040 uint salt_len
= input_len
- 128 - 1;
12042 char *salt_buf
= input_buf
+ 128 + 1;
12044 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12046 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12048 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12050 salt
->salt_len
= salt_len
;
12052 return (PARSER_OK
);
12055 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12057 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12059 u64
*digest
= (u64
*) hash_buf
->digest
;
12061 salt_t
*salt
= hash_buf
->salt
;
12063 char *salt_pos
= input_buf
+ 3;
12065 uint iterations_len
= 0;
12067 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12071 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12073 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12074 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12078 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12082 iterations_len
+= 8;
12086 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12089 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12091 char *hash_pos
= strchr (salt_pos
, '$');
12093 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12095 uint salt_len
= hash_pos
- salt_pos
;
12097 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12099 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12101 salt
->salt_len
= salt_len
;
12105 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12107 return (PARSER_OK
);
12110 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12112 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12114 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12116 u64
*digest
= (u64
*) hash_buf
->digest
;
12118 salt_t
*salt
= hash_buf
->salt
;
12120 uint keccak_mdlen
= input_len
/ 2;
12122 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12124 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12126 digest
[i
] = byte_swap_64 (digest
[i
]);
12129 salt
->keccak_mdlen
= keccak_mdlen
;
12131 return (PARSER_OK
);
12134 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12136 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12138 u32
*digest
= (u32
*) hash_buf
->digest
;
12140 salt_t
*salt
= hash_buf
->salt
;
12142 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12145 * Parse that strange long line
12152 in_off
[0] = strtok (input_buf
, ":");
12154 in_len
[0] = strlen (in_off
[0]);
12158 for (i
= 1; i
< 9; i
++)
12160 in_off
[i
] = strtok (NULL
, ":");
12162 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12164 in_len
[i
] = strlen (in_off
[i
]);
12169 ptr
= (char *) ikepsk
->msg_buf
;
12171 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12172 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12173 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12174 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12175 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12176 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12180 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12182 ptr
= (char *) ikepsk
->nr_buf
;
12184 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12185 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12189 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12192 * Store to database
12197 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12198 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12199 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12200 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12202 digest
[0] = byte_swap_32 (digest
[0]);
12203 digest
[1] = byte_swap_32 (digest
[1]);
12204 digest
[2] = byte_swap_32 (digest
[2]);
12205 digest
[3] = byte_swap_32 (digest
[3]);
12207 salt
->salt_len
= 32;
12209 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12210 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12211 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12212 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12213 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12214 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12215 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12216 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12218 return (PARSER_OK
);
12221 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12223 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12225 u32
*digest
= (u32
*) hash_buf
->digest
;
12227 salt_t
*salt
= hash_buf
->salt
;
12229 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12232 * Parse that strange long line
12239 in_off
[0] = strtok (input_buf
, ":");
12241 in_len
[0] = strlen (in_off
[0]);
12245 for (i
= 1; i
< 9; i
++)
12247 in_off
[i
] = strtok (NULL
, ":");
12249 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12251 in_len
[i
] = strlen (in_off
[i
]);
12256 ptr
= (char *) ikepsk
->msg_buf
;
12258 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12259 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12260 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12261 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12262 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12263 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12267 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12269 ptr
= (char *) ikepsk
->nr_buf
;
12271 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12272 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12276 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12279 * Store to database
12284 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12285 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12286 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12287 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12288 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12290 salt
->salt_len
= 32;
12292 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12293 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12294 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12295 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12296 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12297 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12298 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12299 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12301 return (PARSER_OK
);
12304 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12306 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12308 u32
*digest
= (u32
*) hash_buf
->digest
;
12310 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12311 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12312 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12313 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12314 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12316 digest
[0] = byte_swap_32 (digest
[0]);
12317 digest
[1] = byte_swap_32 (digest
[1]);
12318 digest
[2] = byte_swap_32 (digest
[2]);
12319 digest
[3] = byte_swap_32 (digest
[3]);
12320 digest
[4] = byte_swap_32 (digest
[4]);
12322 return (PARSER_OK
);
12325 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12327 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12329 u32
*digest
= (u32
*) hash_buf
->digest
;
12331 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12332 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12333 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12334 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12335 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12336 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12337 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12338 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12339 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12340 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12341 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12342 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12343 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12344 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12345 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12346 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12348 return (PARSER_OK
);
12351 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12353 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12355 u32
*digest
= (u32
*) hash_buf
->digest
;
12357 salt_t
*salt
= hash_buf
->salt
;
12359 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12360 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12361 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12362 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12363 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12365 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12367 uint salt_len
= input_len
- 40 - 1;
12369 char *salt_buf
= input_buf
+ 40 + 1;
12371 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12373 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12375 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12377 salt
->salt_len
= salt_len
;
12379 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12381 return (PARSER_OK
);
12384 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12386 u32
*digest
= (u32
*) hash_buf
->digest
;
12388 salt_t
*salt
= hash_buf
->salt
;
12390 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12392 if (input_len
== 0)
12394 log_error ("TrueCrypt container not specified");
12399 FILE *fp
= fopen (input_buf
, "rb");
12403 log_error ("%s: %s", input_buf
, strerror (errno
));
12410 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12414 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12416 memcpy (tc
->salt_buf
, buf
, 64);
12418 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12420 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12422 salt
->salt_len
= 4;
12424 salt
->salt_iter
= 1000 - 1;
12426 digest
[0] = tc
->data_buf
[0];
12428 return (PARSER_OK
);
12431 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12433 u32
*digest
= (u32
*) hash_buf
->digest
;
12435 salt_t
*salt
= hash_buf
->salt
;
12437 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12439 if (input_len
== 0)
12441 log_error ("TrueCrypt container not specified");
12446 FILE *fp
= fopen (input_buf
, "rb");
12450 log_error ("%s: %s", input_buf
, strerror (errno
));
12457 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12461 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12463 memcpy (tc
->salt_buf
, buf
, 64);
12465 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12467 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12469 salt
->salt_len
= 4;
12471 salt
->salt_iter
= 2000 - 1;
12473 digest
[0] = tc
->data_buf
[0];
12475 return (PARSER_OK
);
12478 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12480 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12482 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12484 u32
*digest
= (u32
*) hash_buf
->digest
;
12486 salt_t
*salt
= hash_buf
->salt
;
12488 char *salt_pos
= input_buf
+ 6;
12490 char *hash_pos
= strchr (salt_pos
, '$');
12492 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12494 uint salt_len
= hash_pos
- salt_pos
;
12496 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12498 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12500 salt
->salt_len
= salt_len
;
12502 salt
->salt_iter
= 1000;
12506 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12508 return (PARSER_OK
);
12511 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12513 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12515 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12517 u32
*digest
= (u32
*) hash_buf
->digest
;
12519 salt_t
*salt
= hash_buf
->salt
;
12521 char *iter_pos
= input_buf
+ 7;
12523 char *salt_pos
= strchr (iter_pos
, '$');
12525 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12529 char *hash_pos
= strchr (salt_pos
, '$');
12531 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12533 uint salt_len
= hash_pos
- salt_pos
;
12535 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12537 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12539 salt
->salt_len
= salt_len
;
12541 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12543 salt
->salt_sign
[0] = atoi (salt_iter
);
12545 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12549 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12551 digest
[0] = byte_swap_32 (digest
[0]);
12552 digest
[1] = byte_swap_32 (digest
[1]);
12553 digest
[2] = byte_swap_32 (digest
[2]);
12554 digest
[3] = byte_swap_32 (digest
[3]);
12555 digest
[4] = byte_swap_32 (digest
[4]);
12557 return (PARSER_OK
);
12560 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12562 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12564 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12566 u32
*digest
= (u32
*) hash_buf
->digest
;
12568 salt_t
*salt
= hash_buf
->salt
;
12570 char *iter_pos
= input_buf
+ 9;
12572 char *salt_pos
= strchr (iter_pos
, '$');
12574 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12578 char *hash_pos
= strchr (salt_pos
, '$');
12580 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12582 uint salt_len
= hash_pos
- salt_pos
;
12584 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12586 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12588 salt
->salt_len
= salt_len
;
12590 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12592 salt
->salt_sign
[0] = atoi (salt_iter
);
12594 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12598 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12600 digest
[0] = byte_swap_32 (digest
[0]);
12601 digest
[1] = byte_swap_32 (digest
[1]);
12602 digest
[2] = byte_swap_32 (digest
[2]);
12603 digest
[3] = byte_swap_32 (digest
[3]);
12604 digest
[4] = byte_swap_32 (digest
[4]);
12605 digest
[5] = byte_swap_32 (digest
[5]);
12606 digest
[6] = byte_swap_32 (digest
[6]);
12607 digest
[7] = byte_swap_32 (digest
[7]);
12609 return (PARSER_OK
);
12612 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12614 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12616 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12618 u64
*digest
= (u64
*) hash_buf
->digest
;
12620 salt_t
*salt
= hash_buf
->salt
;
12622 char *iter_pos
= input_buf
+ 9;
12624 char *salt_pos
= strchr (iter_pos
, '$');
12626 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12630 char *hash_pos
= strchr (salt_pos
, '$');
12632 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12634 uint salt_len
= hash_pos
- salt_pos
;
12636 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12638 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12640 salt
->salt_len
= salt_len
;
12642 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12644 salt
->salt_sign
[0] = atoi (salt_iter
);
12646 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12650 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12652 digest
[0] = byte_swap_64 (digest
[0]);
12653 digest
[1] = byte_swap_64 (digest
[1]);
12654 digest
[2] = byte_swap_64 (digest
[2]);
12655 digest
[3] = byte_swap_64 (digest
[3]);
12656 digest
[4] = byte_swap_64 (digest
[4]);
12657 digest
[5] = byte_swap_64 (digest
[5]);
12658 digest
[6] = byte_swap_64 (digest
[6]);
12659 digest
[7] = byte_swap_64 (digest
[7]);
12661 return (PARSER_OK
);
12664 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12666 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12668 u32
*digest
= (u32
*) hash_buf
->digest
;
12670 salt_t
*salt
= hash_buf
->salt
;
12672 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12678 char *iterations_pos
= input_buf
;
12680 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12682 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12684 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12686 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12690 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12692 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12694 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12696 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12698 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12700 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12705 * pbkdf2 iterations
12708 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12711 * handle salt encoding
12714 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12716 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12718 const char p0
= saltbuf_pos
[i
+ 0];
12719 const char p1
= saltbuf_pos
[i
+ 1];
12721 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12722 | hex_convert (p0
) << 4;
12725 salt
->salt_len
= saltbuf_len
/ 2;
12728 * handle cipher encoding
12731 uint
*tmp
= (uint
*) mymalloc (32);
12733 char *cipherbuf_ptr
= (char *) tmp
;
12735 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12737 const char p0
= cipherbuf_pos
[i
+ 0];
12738 const char p1
= cipherbuf_pos
[i
+ 1];
12740 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12741 | hex_convert (p0
) << 4;
12744 // iv is stored at salt_buf 4 (length 16)
12745 // data is stored at salt_buf 8 (length 16)
12747 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12748 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12749 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12750 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12752 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12753 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12754 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12755 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12759 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12761 const char p0
= cipherbuf_pos
[j
+ 0];
12762 const char p1
= cipherbuf_pos
[j
+ 1];
12764 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12765 | hex_convert (p0
) << 4;
12772 digest
[0] = 0x10101010;
12773 digest
[1] = 0x10101010;
12774 digest
[2] = 0x10101010;
12775 digest
[3] = 0x10101010;
12777 return (PARSER_OK
);
12780 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12782 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12784 u32
*digest
= (u32
*) hash_buf
->digest
;
12786 salt_t
*salt
= hash_buf
->salt
;
12788 char *hashbuf_pos
= input_buf
;
12790 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12792 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12794 uint hash_len
= iterations_pos
- hashbuf_pos
;
12796 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12800 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12802 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12804 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12808 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12810 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12812 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12814 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12816 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12818 salt
->salt_len
= salt_len
;
12820 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12822 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12823 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12824 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12825 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12827 return (PARSER_OK
);
12830 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12832 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12834 u32
*digest
= (u32
*) hash_buf
->digest
;
12836 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12837 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12838 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12839 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12840 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12841 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12842 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12843 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12845 digest
[0] = byte_swap_32 (digest
[0]);
12846 digest
[1] = byte_swap_32 (digest
[1]);
12847 digest
[2] = byte_swap_32 (digest
[2]);
12848 digest
[3] = byte_swap_32 (digest
[3]);
12849 digest
[4] = byte_swap_32 (digest
[4]);
12850 digest
[5] = byte_swap_32 (digest
[5]);
12851 digest
[6] = byte_swap_32 (digest
[6]);
12852 digest
[7] = byte_swap_32 (digest
[7]);
12854 return (PARSER_OK
);
12857 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12859 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12861 u32
*digest
= (u32
*) hash_buf
->digest
;
12863 salt_t
*salt
= hash_buf
->salt
;
12865 char *salt_pos
= input_buf
+ 3;
12867 uint iterations_len
= 0;
12869 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12873 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12875 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12876 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12880 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12884 iterations_len
+= 8;
12888 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12891 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12893 char *hash_pos
= strchr (salt_pos
, '$');
12895 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12897 uint salt_len
= hash_pos
- salt_pos
;
12899 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12901 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12903 salt
->salt_len
= salt_len
;
12907 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12909 return (PARSER_OK
);
12912 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12914 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12916 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12918 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12920 u64
*digest
= (u64
*) hash_buf
->digest
;
12922 salt_t
*salt
= hash_buf
->salt
;
12924 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12926 char *iter_pos
= input_buf
+ 4;
12928 char *salt_pos
= strchr (iter_pos
, '$');
12930 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12934 char *hash_pos
= strchr (salt_pos
, '$');
12936 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12938 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12942 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12943 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12944 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12945 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12946 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12947 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12948 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12949 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12951 uint salt_len
= hash_pos
- salt_pos
- 1;
12953 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12955 salt
->salt_len
= salt_len
/ 2;
12957 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12958 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12959 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12960 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12961 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12962 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12963 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12964 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12966 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12967 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12968 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12969 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12970 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12971 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12972 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12973 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12974 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12975 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12977 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12979 salt
->salt_iter
= atoi (iter_pos
) - 1;
12981 return (PARSER_OK
);
12984 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12986 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12988 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12990 u32
*digest
= (u32
*) hash_buf
->digest
;
12992 salt_t
*salt
= hash_buf
->salt
;
12994 char *salt_pos
= input_buf
+ 14;
12996 char *hash_pos
= strchr (salt_pos
, '*');
12998 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13002 uint salt_len
= hash_pos
- salt_pos
- 1;
13004 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13006 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13008 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13010 salt
->salt_len
= salt_len
;
13014 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13016 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13018 memcpy (digest
, tmp_buf
, 32);
13020 digest
[0] = byte_swap_32 (digest
[0]);
13021 digest
[1] = byte_swap_32 (digest
[1]);
13022 digest
[2] = byte_swap_32 (digest
[2]);
13023 digest
[3] = byte_swap_32 (digest
[3]);
13024 digest
[4] = byte_swap_32 (digest
[4]);
13025 digest
[5] = byte_swap_32 (digest
[5]);
13026 digest
[6] = byte_swap_32 (digest
[6]);
13027 digest
[7] = byte_swap_32 (digest
[7]);
13029 digest
[0] -= SHA256M_A
;
13030 digest
[1] -= SHA256M_B
;
13031 digest
[2] -= SHA256M_C
;
13032 digest
[3] -= SHA256M_D
;
13033 digest
[4] -= SHA256M_E
;
13034 digest
[5] -= SHA256M_F
;
13035 digest
[6] -= SHA256M_G
;
13036 digest
[7] -= SHA256M_H
;
13038 return (PARSER_OK
);
13041 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13043 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13045 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13047 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13049 u64
*digest
= (u64
*) hash_buf
->digest
;
13051 salt_t
*salt
= hash_buf
->salt
;
13053 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13055 char *iter_pos
= input_buf
+ 19;
13057 char *salt_pos
= strchr (iter_pos
, '.');
13059 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13063 char *hash_pos
= strchr (salt_pos
, '.');
13065 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13067 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13071 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13072 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13073 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13074 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13075 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13076 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13077 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13078 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13080 uint salt_len
= hash_pos
- salt_pos
- 1;
13084 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13088 for (i
= 0; i
< salt_len
; i
++)
13090 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13093 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13094 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13096 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13098 salt
->salt_len
= salt_len
;
13100 salt
->salt_iter
= atoi (iter_pos
) - 1;
13102 return (PARSER_OK
);
13105 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13107 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13109 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13111 u64
*digest
= (u64
*) hash_buf
->digest
;
13113 salt_t
*salt
= hash_buf
->salt
;
13117 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13119 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13121 memcpy (digest
, tmp_buf
, 64);
13123 digest
[0] = byte_swap_64 (digest
[0]);
13124 digest
[1] = byte_swap_64 (digest
[1]);
13125 digest
[2] = byte_swap_64 (digest
[2]);
13126 digest
[3] = byte_swap_64 (digest
[3]);
13127 digest
[4] = byte_swap_64 (digest
[4]);
13128 digest
[5] = byte_swap_64 (digest
[5]);
13129 digest
[6] = byte_swap_64 (digest
[6]);
13130 digest
[7] = byte_swap_64 (digest
[7]);
13132 digest
[0] -= SHA512M_A
;
13133 digest
[1] -= SHA512M_B
;
13134 digest
[2] -= SHA512M_C
;
13135 digest
[3] -= SHA512M_D
;
13136 digest
[4] -= SHA512M_E
;
13137 digest
[5] -= SHA512M_F
;
13138 digest
[6] -= SHA512M_G
;
13139 digest
[7] -= SHA512M_H
;
13141 salt
->salt_len
= tmp_len
- 64;
13143 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13145 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13147 char *ptr
= (char *) salt
->salt_buf
;
13149 ptr
[salt
->salt_len
] = 0x80;
13152 return (PARSER_OK
);
13155 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13157 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13159 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13163 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13166 u32
*digest
= (u32
*) hash_buf
->digest
;
13168 salt_t
*salt
= hash_buf
->salt
;
13170 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13171 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13172 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13173 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13175 digest
[0] = byte_swap_32 (digest
[0]);
13176 digest
[1] = byte_swap_32 (digest
[1]);
13177 digest
[2] = byte_swap_32 (digest
[2]);
13178 digest
[3] = byte_swap_32 (digest
[3]);
13180 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13182 uint salt_len
= input_len
- 32 - 1;
13184 char *salt_buf
= input_buf
+ 32 + 1;
13186 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13188 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13190 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13192 salt
->salt_len
= salt_len
;
13194 return (PARSER_OK
);
13197 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13199 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13201 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13205 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13208 u32
*digest
= (u32
*) hash_buf
->digest
;
13210 salt_t
*salt
= hash_buf
->salt
;
13212 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13213 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13214 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13215 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13216 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13218 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13220 uint salt_len
= input_len
- 40 - 1;
13222 char *salt_buf
= input_buf
+ 40 + 1;
13224 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13226 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13228 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13230 salt
->salt_len
= salt_len
;
13232 return (PARSER_OK
);
13235 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13237 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13239 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13243 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13246 u32
*digest
= (u32
*) hash_buf
->digest
;
13248 salt_t
*salt
= hash_buf
->salt
;
13250 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13251 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13252 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13253 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13254 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13255 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13256 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13257 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13259 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13261 uint salt_len
= input_len
- 64 - 1;
13263 char *salt_buf
= input_buf
+ 64 + 1;
13265 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13267 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13269 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13271 salt
->salt_len
= salt_len
;
13273 return (PARSER_OK
);
13276 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13278 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13280 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13284 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13287 u64
*digest
= (u64
*) hash_buf
->digest
;
13289 salt_t
*salt
= hash_buf
->salt
;
13291 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13292 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13293 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13294 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13295 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13296 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13297 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13298 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13300 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13302 uint salt_len
= input_len
- 128 - 1;
13304 char *salt_buf
= input_buf
+ 128 + 1;
13306 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13308 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13310 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13312 salt
->salt_len
= salt_len
;
13314 return (PARSER_OK
);
13317 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13319 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13321 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13323 u32
*digest
= (u32
*) hash_buf
->digest
;
13325 salt_t
*salt
= hash_buf
->salt
;
13327 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13333 char *user_pos
= input_buf
+ 10 + 1;
13335 char *realm_pos
= strchr (user_pos
, '$');
13337 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13339 uint user_len
= realm_pos
- user_pos
;
13341 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13345 char *salt_pos
= strchr (realm_pos
, '$');
13347 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13349 uint realm_len
= salt_pos
- realm_pos
;
13351 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13355 char *data_pos
= strchr (salt_pos
, '$');
13357 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13359 uint salt_len
= data_pos
- salt_pos
;
13361 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13365 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13367 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13373 memcpy (krb5pa
->user
, user_pos
, user_len
);
13374 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13375 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13377 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13379 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13381 const char p0
= data_pos
[i
+ 0];
13382 const char p1
= data_pos
[i
+ 1];
13384 *timestamp_ptr
++ = hex_convert (p1
) << 0
13385 | hex_convert (p0
) << 4;
13388 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13390 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13392 const char p0
= data_pos
[i
+ 0];
13393 const char p1
= data_pos
[i
+ 1];
13395 *checksum_ptr
++ = hex_convert (p1
) << 0
13396 | hex_convert (p0
) << 4;
13400 * copy some data to generic buffers to make sorting happy
13403 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13404 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13405 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13406 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13407 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13408 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13409 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13410 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13411 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13413 salt
->salt_len
= 36;
13415 digest
[0] = krb5pa
->checksum
[0];
13416 digest
[1] = krb5pa
->checksum
[1];
13417 digest
[2] = krb5pa
->checksum
[2];
13418 digest
[3] = krb5pa
->checksum
[3];
13420 return (PARSER_OK
);
13423 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13425 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13427 u32
*digest
= (u32
*) hash_buf
->digest
;
13429 salt_t
*salt
= hash_buf
->salt
;
13435 char *salt_pos
= input_buf
;
13437 char *hash_pos
= strchr (salt_pos
, '$');
13439 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13441 uint salt_len
= hash_pos
- salt_pos
;
13443 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13447 uint hash_len
= input_len
- 1 - salt_len
;
13449 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13457 for (uint i
= 0; i
< salt_len
; i
++)
13459 if (salt_pos
[i
] == ' ') continue;
13464 // SAP user names cannot be longer than 12 characters
13465 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13467 // SAP user name cannot start with ! or ?
13468 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13474 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13476 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13478 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13480 salt
->salt_len
= salt_len
;
13482 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13483 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13487 digest
[0] = byte_swap_32 (digest
[0]);
13488 digest
[1] = byte_swap_32 (digest
[1]);
13490 return (PARSER_OK
);
13493 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13495 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13497 u32
*digest
= (u32
*) hash_buf
->digest
;
13499 salt_t
*salt
= hash_buf
->salt
;
13505 char *salt_pos
= input_buf
;
13507 char *hash_pos
= strchr (salt_pos
, '$');
13509 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13511 uint salt_len
= hash_pos
- salt_pos
;
13513 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13517 uint hash_len
= input_len
- 1 - salt_len
;
13519 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13527 for (uint i
= 0; i
< salt_len
; i
++)
13529 if (salt_pos
[i
] == ' ') continue;
13534 // SAP user names cannot be longer than 12 characters
13535 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13536 // so far nobody complained so we stay with this because it helps in optimization
13537 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13539 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13541 // SAP user name cannot start with ! or ?
13542 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13548 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13550 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13552 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13554 salt
->salt_len
= salt_len
;
13556 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13557 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13558 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13559 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13560 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13562 return (PARSER_OK
);
13565 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13567 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13569 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13571 u64
*digest
= (u64
*) hash_buf
->digest
;
13573 salt_t
*salt
= hash_buf
->salt
;
13575 char *iter_pos
= input_buf
+ 3;
13577 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13579 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13581 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13583 salt
->salt_iter
= salt_iter
;
13585 char *salt_pos
= iter_pos
+ 1;
13589 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13591 salt
->salt_len
= salt_len
;
13593 char *hash_pos
= salt_pos
+ salt_len
;
13595 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13599 char *tmp
= (char *) salt
->salt_buf_pc
;
13601 tmp
[0] = hash_pos
[42];
13605 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13606 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13607 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13608 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13614 return (PARSER_OK
);
13617 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13619 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13621 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13623 u32
*digest
= (u32
*) hash_buf
->digest
;
13625 salt_t
*salt
= hash_buf
->salt
;
13627 char *salt_buf
= input_buf
+ 6;
13629 uint salt_len
= 16;
13631 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13633 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13635 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13637 salt
->salt_len
= salt_len
;
13639 char *hash_pos
= input_buf
+ 6 + 16;
13641 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13642 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13643 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13644 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13645 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13646 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13647 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13648 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13650 return (PARSER_OK
);
13653 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13655 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13657 u32
*digest
= (u32
*) hash_buf
->digest
;
13659 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13660 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13664 return (PARSER_OK
);
13667 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13669 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13671 u32
*digest
= (u32
*) hash_buf
->digest
;
13673 salt_t
*salt
= hash_buf
->salt
;
13675 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13677 char *saltbuf_pos
= input_buf
;
13679 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13681 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13683 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13685 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13686 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13688 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13692 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13694 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13696 char *salt_ptr
= (char *) saltbuf_pos
;
13697 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13702 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13704 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13707 rakp_ptr
[j
] = 0x80;
13709 rakp
->salt_len
= j
;
13711 for (i
= 0; i
< 64; i
++)
13713 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13716 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13717 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13718 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13719 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13720 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13721 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13722 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13723 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13725 salt
->salt_len
= 32; // muss min. 32 haben
13727 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13728 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13729 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13730 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13731 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13733 return (PARSER_OK
);
13736 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13738 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13740 u32
*digest
= (u32
*) hash_buf
->digest
;
13742 salt_t
*salt
= hash_buf
->salt
;
13744 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13746 char *salt_pos
= input_buf
+ 1;
13748 memcpy (salt
->salt_buf
, salt_pos
, 8);
13750 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13751 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13753 salt
->salt_len
= 8;
13755 char *hash_pos
= salt_pos
+ 8;
13757 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13758 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13759 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13760 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13761 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13763 digest
[0] -= SHA1M_A
;
13764 digest
[1] -= SHA1M_B
;
13765 digest
[2] -= SHA1M_C
;
13766 digest
[3] -= SHA1M_D
;
13767 digest
[4] -= SHA1M_E
;
13769 return (PARSER_OK
);
13772 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13774 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13776 u32
*digest
= (u32
*) hash_buf
->digest
;
13778 salt_t
*salt
= hash_buf
->salt
;
13780 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13781 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13782 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13783 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13785 digest
[0] = byte_swap_32 (digest
[0]);
13786 digest
[1] = byte_swap_32 (digest
[1]);
13787 digest
[2] = byte_swap_32 (digest
[2]);
13788 digest
[3] = byte_swap_32 (digest
[3]);
13790 digest
[0] -= MD5M_A
;
13791 digest
[1] -= MD5M_B
;
13792 digest
[2] -= MD5M_C
;
13793 digest
[3] -= MD5M_D
;
13795 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13797 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13799 u32
*salt_buf
= salt
->salt_buf
;
13801 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13802 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13803 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13804 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13806 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13807 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13808 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13809 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13811 salt
->salt_len
= 16 + 1;
13813 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13815 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13817 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13819 return (PARSER_OK
);
13822 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13824 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13826 u32
*digest
= (u32
*) hash_buf
->digest
;
13828 salt_t
*salt
= hash_buf
->salt
;
13830 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13836 char *hashbuf_pos
= input_buf
;
13838 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13840 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13842 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13844 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13848 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13850 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13852 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13854 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13858 char *databuf_pos
= strchr (iteration_pos
, ':');
13860 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13862 const uint iteration_len
= databuf_pos
- iteration_pos
;
13864 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13865 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13867 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13869 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13870 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13876 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13877 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13878 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13879 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13880 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13881 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13882 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13883 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13887 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13889 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13891 const char p0
= saltbuf_pos
[i
+ 0];
13892 const char p1
= saltbuf_pos
[i
+ 1];
13894 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13895 | hex_convert (p0
) << 4;
13898 salt
->salt_buf
[4] = 0x01000000;
13899 salt
->salt_buf
[5] = 0x80;
13901 salt
->salt_len
= saltbuf_len
/ 2;
13905 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13909 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13911 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13913 const char p0
= databuf_pos
[i
+ 0];
13914 const char p1
= databuf_pos
[i
+ 1];
13916 *databuf_ptr
++ = hex_convert (p1
) << 0
13917 | hex_convert (p0
) << 4;
13920 *databuf_ptr
++ = 0x80;
13922 for (uint i
= 0; i
< 512; i
++)
13924 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13927 cloudkey
->data_len
= databuf_len
/ 2;
13929 return (PARSER_OK
);
13932 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13934 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13936 u32
*digest
= (u32
*) hash_buf
->digest
;
13938 salt_t
*salt
= hash_buf
->salt
;
13944 char *hashbuf_pos
= input_buf
;
13946 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13948 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13950 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13952 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13956 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13958 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13960 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13962 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13964 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13968 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13970 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13972 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13974 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13976 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13980 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13982 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13983 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13985 // ok, the plan for this algorithm is the following:
13986 // we have 2 salts here, the domain-name and a random salt
13987 // while both are used in the initial transformation,
13988 // only the random salt is used in the following iterations
13989 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13990 // and one that includes only the real salt (stored into salt_buf[]).
13991 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13995 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13997 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
13999 memcpy (digest
, tmp_buf
, 20);
14001 digest
[0] = byte_swap_32 (digest
[0]);
14002 digest
[1] = byte_swap_32 (digest
[1]);
14003 digest
[2] = byte_swap_32 (digest
[2]);
14004 digest
[3] = byte_swap_32 (digest
[3]);
14005 digest
[4] = byte_swap_32 (digest
[4]);
14009 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14011 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14013 char *len_ptr
= NULL
;
14015 for (uint i
= 0; i
< domainbuf_len
; i
++)
14017 if (salt_buf_pc_ptr
[i
] == '.')
14019 len_ptr
= &salt_buf_pc_ptr
[i
];
14029 salt
->salt_buf_pc
[7] = domainbuf_len
;
14033 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14035 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14037 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14039 salt
->salt_len
= salt_len
;
14043 salt
->salt_iter
= atoi (iteration_pos
);
14045 return (PARSER_OK
);
14048 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14050 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14052 u32
*digest
= (u32
*) hash_buf
->digest
;
14054 salt_t
*salt
= hash_buf
->salt
;
14056 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14057 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14058 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14059 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14060 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14062 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14064 uint salt_len
= input_len
- 40 - 1;
14066 char *salt_buf
= input_buf
+ 40 + 1;
14068 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14070 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14072 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14074 salt
->salt_len
= salt_len
;
14076 return (PARSER_OK
);
14079 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14081 const u8 ascii_to_ebcdic
[] =
14083 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14084 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14085 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14086 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14087 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14088 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14089 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14090 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14091 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14092 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14093 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14094 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14095 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14096 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14097 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14098 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14101 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14103 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14105 u32
*digest
= (u32
*) hash_buf
->digest
;
14107 salt_t
*salt
= hash_buf
->salt
;
14109 char *salt_pos
= input_buf
+ 6 + 1;
14111 char *digest_pos
= strchr (salt_pos
, '*');
14113 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14115 uint salt_len
= digest_pos
- salt_pos
;
14117 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14119 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14121 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14125 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14126 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14128 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14130 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14132 salt
->salt_len
= salt_len
;
14134 for (uint i
= 0; i
< salt_len
; i
++)
14136 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14138 for (uint i
= salt_len
; i
< 8; i
++)
14140 salt_buf_pc_ptr
[i
] = 0x40;
14145 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14147 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14148 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14150 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14151 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14153 digest
[0] = byte_swap_32 (digest
[0]);
14154 digest
[1] = byte_swap_32 (digest
[1]);
14156 IP (digest
[0], digest
[1], tt
);
14158 digest
[0] = rotr32 (digest
[0], 29);
14159 digest
[1] = rotr32 (digest
[1], 29);
14163 return (PARSER_OK
);
14166 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14168 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14170 u32
*digest
= (u32
*) hash_buf
->digest
;
14172 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14173 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14174 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14175 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14177 digest
[0] = byte_swap_32 (digest
[0]);
14178 digest
[1] = byte_swap_32 (digest
[1]);
14179 digest
[2] = byte_swap_32 (digest
[2]);
14180 digest
[3] = byte_swap_32 (digest
[3]);
14182 return (PARSER_OK
);
14185 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14187 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14189 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14191 u32
*digest
= (u32
*) hash_buf
->digest
;
14193 salt_t
*salt
= hash_buf
->salt
;
14197 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14199 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14201 tmp_buf
[3] += -4; // dont ask!
14203 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14205 salt
->salt_len
= 5;
14207 memcpy (digest
, tmp_buf
+ 5, 9);
14209 // yes, only 9 byte are needed to crack, but 10 to display
14211 salt
->salt_buf_pc
[7] = input_buf
[20];
14213 return (PARSER_OK
);
14216 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14218 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14220 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14222 u32
*digest
= (u32
*) hash_buf
->digest
;
14224 salt_t
*salt
= hash_buf
->salt
;
14228 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14230 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14232 tmp_buf
[3] += -4; // dont ask!
14236 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14238 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)
14242 char tmp_iter_buf
[11];
14244 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14246 tmp_iter_buf
[10] = 0;
14248 salt
->salt_iter
= atoi (tmp_iter_buf
);
14250 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14252 return (PARSER_SALT_ITERATION
);
14255 salt
->salt_iter
--; // first round in init
14257 // 2 additional bytes for display only
14259 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14260 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14264 memcpy (digest
, tmp_buf
+ 28, 8);
14266 digest
[0] = byte_swap_32 (digest
[0]);
14267 digest
[1] = byte_swap_32 (digest
[1]);
14271 return (PARSER_OK
);
14274 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14276 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14278 u32
*digest
= (u32
*) hash_buf
->digest
;
14280 salt_t
*salt
= hash_buf
->salt
;
14282 char *salt_buf_pos
= input_buf
;
14284 char *hash_buf_pos
= salt_buf_pos
+ 6;
14286 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14287 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14288 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14289 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14290 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14291 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14292 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14293 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14295 digest
[0] -= SHA256M_A
;
14296 digest
[1] -= SHA256M_B
;
14297 digest
[2] -= SHA256M_C
;
14298 digest
[3] -= SHA256M_D
;
14299 digest
[4] -= SHA256M_E
;
14300 digest
[5] -= SHA256M_F
;
14301 digest
[6] -= SHA256M_G
;
14302 digest
[7] -= SHA256M_H
;
14304 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14306 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14308 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14310 salt
->salt_len
= salt_len
;
14312 return (PARSER_OK
);
14315 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14317 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14319 u32
*digest
= (u32
*) hash_buf
->digest
;
14321 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14323 salt_t
*salt
= hash_buf
->salt
;
14325 char *salt_buf
= input_buf
+ 6;
14327 char *digest_buf
= strchr (salt_buf
, '$');
14329 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14331 uint salt_len
= digest_buf
- salt_buf
;
14333 digest_buf
++; // skip the '$' symbol
14335 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14337 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14339 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14341 salt
->salt_len
= salt_len
;
14343 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14344 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14345 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14346 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14348 digest
[0] = byte_swap_32 (digest
[0]);
14349 digest
[1] = byte_swap_32 (digest
[1]);
14350 digest
[2] = byte_swap_32 (digest
[2]);
14351 digest
[3] = byte_swap_32 (digest
[3]);
14353 digest
[0] -= MD5M_A
;
14354 digest
[1] -= MD5M_B
;
14355 digest
[2] -= MD5M_C
;
14356 digest
[3] -= MD5M_D
;
14358 return (PARSER_OK
);
14361 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14363 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14365 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14367 u32
*digest
= (u32
*) hash_buf
->digest
;
14369 salt_t
*salt
= hash_buf
->salt
;
14371 char *salt_buf
= input_buf
+ 3;
14373 char *digest_buf
= strchr (salt_buf
, '$');
14375 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14377 uint salt_len
= digest_buf
- salt_buf
;
14379 digest_buf
++; // skip the '$' symbol
14381 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14383 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14385 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14387 salt_buf_ptr
[salt_len
] = 0x2d;
14389 salt
->salt_len
= salt_len
+ 1;
14391 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14392 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14393 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14394 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14396 digest
[0] = byte_swap_32 (digest
[0]);
14397 digest
[1] = byte_swap_32 (digest
[1]);
14398 digest
[2] = byte_swap_32 (digest
[2]);
14399 digest
[3] = byte_swap_32 (digest
[3]);
14401 digest
[0] -= MD5M_A
;
14402 digest
[1] -= MD5M_B
;
14403 digest
[2] -= MD5M_C
;
14404 digest
[3] -= MD5M_D
;
14406 return (PARSER_OK
);
14409 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14411 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14413 u32
*digest
= (u32
*) hash_buf
->digest
;
14417 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14419 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14421 memcpy (digest
, tmp_buf
, 20);
14423 digest
[0] = byte_swap_32 (digest
[0]);
14424 digest
[1] = byte_swap_32 (digest
[1]);
14425 digest
[2] = byte_swap_32 (digest
[2]);
14426 digest
[3] = byte_swap_32 (digest
[3]);
14427 digest
[4] = byte_swap_32 (digest
[4]);
14429 digest
[0] -= SHA1M_A
;
14430 digest
[1] -= SHA1M_B
;
14431 digest
[2] -= SHA1M_C
;
14432 digest
[3] -= SHA1M_D
;
14433 digest
[4] -= SHA1M_E
;
14435 return (PARSER_OK
);
14438 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14440 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14442 u32
*digest
= (u32
*) hash_buf
->digest
;
14444 salt_t
*salt
= hash_buf
->salt
;
14446 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14447 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14448 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14449 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14451 digest
[0] = byte_swap_32 (digest
[0]);
14452 digest
[1] = byte_swap_32 (digest
[1]);
14453 digest
[2] = byte_swap_32 (digest
[2]);
14454 digest
[3] = byte_swap_32 (digest
[3]);
14456 digest
[0] -= MD5M_A
;
14457 digest
[1] -= MD5M_B
;
14458 digest
[2] -= MD5M_C
;
14459 digest
[3] -= MD5M_D
;
14461 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14463 uint salt_len
= input_len
- 32 - 1;
14465 char *salt_buf
= input_buf
+ 32 + 1;
14467 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14469 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14471 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14474 * add static "salt" part
14477 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14481 salt
->salt_len
= salt_len
;
14483 return (PARSER_OK
);
14486 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14488 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14490 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14492 u32
*digest
= (u32
*) hash_buf
->digest
;
14494 salt_t
*salt
= hash_buf
->salt
;
14496 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14502 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14504 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14506 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14508 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14510 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14514 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14516 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14518 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14520 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14524 char *keybuf_pos
= strchr (keylen_pos
, '$');
14526 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14528 uint keylen_len
= keybuf_pos
- keylen_pos
;
14530 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14534 char *databuf_pos
= strchr (keybuf_pos
, '$');
14536 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14538 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14540 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14544 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14546 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14552 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14553 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14554 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14555 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14557 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14558 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14559 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14560 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14562 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14563 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14564 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14565 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14567 salt
->salt_len
= 16;
14568 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14570 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14572 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14575 return (PARSER_OK
);
14578 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14580 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14582 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14584 u32
*digest
= (u32
*) hash_buf
->digest
;
14586 salt_t
*salt
= hash_buf
->salt
;
14592 // first is the N salt parameter
14594 char *N_pos
= input_buf
+ 6;
14596 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14600 salt
->scrypt_N
= atoi (N_pos
);
14604 char *r_pos
= strchr (N_pos
, ':');
14606 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14610 salt
->scrypt_r
= atoi (r_pos
);
14614 char *p_pos
= strchr (r_pos
, ':');
14616 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14620 salt
->scrypt_p
= atoi (p_pos
);
14624 char *saltbuf_pos
= strchr (p_pos
, ':');
14626 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14630 char *hash_pos
= strchr (saltbuf_pos
, ':');
14632 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14640 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14642 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14644 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14646 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14648 salt
->salt_len
= tmp_len
;
14649 salt
->salt_iter
= 1;
14651 // digest - base64 decode
14653 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14655 tmp_len
= input_len
- (hash_pos
- input_buf
);
14657 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14659 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14661 memcpy (digest
, tmp_buf
, 32);
14663 return (PARSER_OK
);
14666 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14668 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14670 u32
*digest
= (u32
*) hash_buf
->digest
;
14672 salt_t
*salt
= hash_buf
->salt
;
14678 char decrypted
[76]; // iv + hash
14680 juniper_decrypt_hash (input_buf
, decrypted
);
14682 char *md5crypt_hash
= decrypted
+ 12;
14684 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14686 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14688 char *salt_pos
= md5crypt_hash
+ 3;
14690 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14692 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14694 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14698 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14700 return (PARSER_OK
);
14703 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14705 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14707 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14709 u32
*digest
= (u32
*) hash_buf
->digest
;
14711 salt_t
*salt
= hash_buf
->salt
;
14713 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14719 // first is *raw* salt
14721 char *salt_pos
= input_buf
+ 3;
14723 char *hash_pos
= strchr (salt_pos
, '$');
14725 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14727 uint salt_len
= hash_pos
- salt_pos
;
14729 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14733 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14735 memcpy (salt_buf_ptr
, salt_pos
, 14);
14737 salt_buf_ptr
[17] = 0x01;
14738 salt_buf_ptr
[18] = 0x80;
14740 // add some stuff to normal salt to make sorted happy
14742 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14743 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14744 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14745 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14747 salt
->salt_len
= salt_len
;
14748 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14750 // base64 decode hash
14754 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14756 uint hash_len
= input_len
- 3 - salt_len
- 1;
14758 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14760 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14762 memcpy (digest
, tmp_buf
, 32);
14764 digest
[0] = byte_swap_32 (digest
[0]);
14765 digest
[1] = byte_swap_32 (digest
[1]);
14766 digest
[2] = byte_swap_32 (digest
[2]);
14767 digest
[3] = byte_swap_32 (digest
[3]);
14768 digest
[4] = byte_swap_32 (digest
[4]);
14769 digest
[5] = byte_swap_32 (digest
[5]);
14770 digest
[6] = byte_swap_32 (digest
[6]);
14771 digest
[7] = byte_swap_32 (digest
[7]);
14773 return (PARSER_OK
);
14776 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14778 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14780 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14782 u32
*digest
= (u32
*) hash_buf
->digest
;
14784 salt_t
*salt
= hash_buf
->salt
;
14790 // first is *raw* salt
14792 char *salt_pos
= input_buf
+ 3;
14794 char *hash_pos
= strchr (salt_pos
, '$');
14796 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14798 uint salt_len
= hash_pos
- salt_pos
;
14800 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14802 salt
->salt_len
= salt_len
;
14805 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14807 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14808 salt_buf_ptr
[salt_len
] = 0;
14810 // base64 decode hash
14814 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14816 uint hash_len
= input_len
- 3 - salt_len
- 1;
14818 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14820 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14822 memcpy (digest
, tmp_buf
, 32);
14825 salt
->scrypt_N
= 16384;
14826 salt
->scrypt_r
= 1;
14827 salt
->scrypt_p
= 1;
14828 salt
->salt_iter
= 1;
14830 return (PARSER_OK
);
14833 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14835 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14837 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14839 u32
*digest
= (u32
*) hash_buf
->digest
;
14841 salt_t
*salt
= hash_buf
->salt
;
14843 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14849 char *version_pos
= input_buf
+ 8 + 1;
14851 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14853 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14855 u32 version_len
= verifierHashSize_pos
- version_pos
;
14857 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14859 verifierHashSize_pos
++;
14861 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14863 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14865 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14867 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14871 char *saltSize_pos
= strchr (keySize_pos
, '*');
14873 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14875 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14877 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14881 char *osalt_pos
= strchr (saltSize_pos
, '*');
14883 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14885 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14887 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14891 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14893 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14895 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14897 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14899 encryptedVerifier_pos
++;
14901 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14903 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14905 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14907 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14909 encryptedVerifierHash_pos
++;
14911 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;
14913 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14915 const uint version
= atoi (version_pos
);
14917 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14919 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14921 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14923 const uint keySize
= atoi (keySize_pos
);
14925 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14927 office2007
->keySize
= keySize
;
14929 const uint saltSize
= atoi (saltSize_pos
);
14931 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14937 salt
->salt_len
= 16;
14938 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14940 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14941 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14942 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14943 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14949 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14950 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14951 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14952 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14954 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14955 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14956 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14957 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14958 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14964 digest
[0] = office2007
->encryptedVerifierHash
[0];
14965 digest
[1] = office2007
->encryptedVerifierHash
[1];
14966 digest
[2] = office2007
->encryptedVerifierHash
[2];
14967 digest
[3] = office2007
->encryptedVerifierHash
[3];
14969 return (PARSER_OK
);
14972 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14974 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14976 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14978 u32
*digest
= (u32
*) hash_buf
->digest
;
14980 salt_t
*salt
= hash_buf
->salt
;
14982 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14988 char *version_pos
= input_buf
+ 8 + 1;
14990 char *spinCount_pos
= strchr (version_pos
, '*');
14992 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14994 u32 version_len
= spinCount_pos
- version_pos
;
14996 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15000 char *keySize_pos
= strchr (spinCount_pos
, '*');
15002 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15004 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15006 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15010 char *saltSize_pos
= strchr (keySize_pos
, '*');
15012 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15014 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15016 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15020 char *osalt_pos
= strchr (saltSize_pos
, '*');
15022 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15024 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15026 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15030 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15032 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15034 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15036 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15038 encryptedVerifier_pos
++;
15040 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15042 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15044 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15046 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15048 encryptedVerifierHash_pos
++;
15050 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;
15052 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15054 const uint version
= atoi (version_pos
);
15056 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15058 const uint spinCount
= atoi (spinCount_pos
);
15060 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15062 const uint keySize
= atoi (keySize_pos
);
15064 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15066 const uint saltSize
= atoi (saltSize_pos
);
15068 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15074 salt
->salt_len
= 16;
15075 salt
->salt_iter
= spinCount
;
15077 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15078 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15079 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15080 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15086 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15087 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15088 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15089 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15091 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15092 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15093 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15094 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15095 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15096 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15097 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15098 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15104 digest
[0] = office2010
->encryptedVerifierHash
[0];
15105 digest
[1] = office2010
->encryptedVerifierHash
[1];
15106 digest
[2] = office2010
->encryptedVerifierHash
[2];
15107 digest
[3] = office2010
->encryptedVerifierHash
[3];
15109 return (PARSER_OK
);
15112 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15114 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15116 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15118 u32
*digest
= (u32
*) hash_buf
->digest
;
15120 salt_t
*salt
= hash_buf
->salt
;
15122 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15128 char *version_pos
= input_buf
+ 8 + 1;
15130 char *spinCount_pos
= strchr (version_pos
, '*');
15132 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15134 u32 version_len
= spinCount_pos
- version_pos
;
15136 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15140 char *keySize_pos
= strchr (spinCount_pos
, '*');
15142 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15144 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15146 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15150 char *saltSize_pos
= strchr (keySize_pos
, '*');
15152 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15154 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15156 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15160 char *osalt_pos
= strchr (saltSize_pos
, '*');
15162 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15164 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15166 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15170 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15172 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15174 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15176 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15178 encryptedVerifier_pos
++;
15180 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15182 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15184 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15186 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15188 encryptedVerifierHash_pos
++;
15190 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;
15192 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15194 const uint version
= atoi (version_pos
);
15196 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15198 const uint spinCount
= atoi (spinCount_pos
);
15200 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15202 const uint keySize
= atoi (keySize_pos
);
15204 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15206 const uint saltSize
= atoi (saltSize_pos
);
15208 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15214 salt
->salt_len
= 16;
15215 salt
->salt_iter
= spinCount
;
15217 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15218 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15219 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15220 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15226 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15227 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15228 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15229 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15231 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15232 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15233 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15234 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15235 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15236 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15237 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15238 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15244 digest
[0] = office2013
->encryptedVerifierHash
[0];
15245 digest
[1] = office2013
->encryptedVerifierHash
[1];
15246 digest
[2] = office2013
->encryptedVerifierHash
[2];
15247 digest
[3] = office2013
->encryptedVerifierHash
[3];
15249 return (PARSER_OK
);
15252 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15254 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15256 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15258 u32
*digest
= (u32
*) hash_buf
->digest
;
15260 salt_t
*salt
= hash_buf
->salt
;
15262 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15268 char *version_pos
= input_buf
+ 11;
15270 char *osalt_pos
= strchr (version_pos
, '*');
15272 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15274 u32 version_len
= osalt_pos
- version_pos
;
15276 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15280 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15282 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15284 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15286 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15288 encryptedVerifier_pos
++;
15290 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15292 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15294 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15296 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15298 encryptedVerifierHash_pos
++;
15300 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15302 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15304 const uint version
= *version_pos
- 0x30;
15306 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15312 oldoffice01
->version
= version
;
15314 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15315 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15316 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15317 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15319 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15320 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15321 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15322 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15324 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15325 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15326 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15327 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15329 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15330 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15331 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15332 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15338 salt
->salt_len
= 16;
15340 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15341 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15342 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15343 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15345 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15346 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15347 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15348 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15350 // this is a workaround as office produces multiple documents with the same salt
15352 salt
->salt_len
+= 32;
15354 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15355 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15356 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15357 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15358 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15359 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15360 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15361 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15367 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15368 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15369 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15370 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15372 return (PARSER_OK
);
15375 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15377 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15380 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15382 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15384 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15386 u32
*digest
= (u32
*) hash_buf
->digest
;
15388 salt_t
*salt
= hash_buf
->salt
;
15390 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15396 char *version_pos
= input_buf
+ 11;
15398 char *osalt_pos
= strchr (version_pos
, '*');
15400 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15402 u32 version_len
= osalt_pos
- version_pos
;
15404 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15408 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15410 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15412 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15414 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15416 encryptedVerifier_pos
++;
15418 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15420 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15422 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15424 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15426 encryptedVerifierHash_pos
++;
15428 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15430 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15432 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15434 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15438 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15440 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15442 const uint version
= *version_pos
- 0x30;
15444 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15450 oldoffice01
->version
= version
;
15452 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15453 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15454 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15455 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15457 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15458 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15459 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15460 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15462 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15463 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15464 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15465 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15467 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15468 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15469 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15470 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15472 oldoffice01
->rc4key
[1] = 0;
15473 oldoffice01
->rc4key
[0] = 0;
15475 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15476 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15477 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15478 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15479 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15480 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15481 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15482 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15483 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15484 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15486 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15487 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15493 salt
->salt_len
= 16;
15495 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15496 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15497 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15498 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15500 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15501 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15502 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15503 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15505 // this is a workaround as office produces multiple documents with the same salt
15507 salt
->salt_len
+= 32;
15509 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15510 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15511 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15512 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15513 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15514 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15515 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15516 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15522 digest
[0] = oldoffice01
->rc4key
[0];
15523 digest
[1] = oldoffice01
->rc4key
[1];
15527 return (PARSER_OK
);
15530 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15532 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15534 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15536 u32
*digest
= (u32
*) hash_buf
->digest
;
15538 salt_t
*salt
= hash_buf
->salt
;
15540 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15546 char *version_pos
= input_buf
+ 11;
15548 char *osalt_pos
= strchr (version_pos
, '*');
15550 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15552 u32 version_len
= osalt_pos
- version_pos
;
15554 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15558 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15560 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15562 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15564 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15566 encryptedVerifier_pos
++;
15568 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15570 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15572 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15574 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15576 encryptedVerifierHash_pos
++;
15578 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15580 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15582 const uint version
= *version_pos
- 0x30;
15584 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15590 oldoffice34
->version
= version
;
15592 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15593 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15594 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15595 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15597 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15598 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15599 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15600 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15602 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15603 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15604 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15605 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15606 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15608 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15609 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15610 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15611 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15612 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15618 salt
->salt_len
= 16;
15620 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15621 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15622 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15623 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15625 // this is a workaround as office produces multiple documents with the same salt
15627 salt
->salt_len
+= 32;
15629 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15630 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15631 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15632 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15633 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15634 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15635 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15636 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15642 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15643 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15644 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15645 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15647 return (PARSER_OK
);
15650 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15652 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15654 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15657 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15659 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15661 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15663 u32
*digest
= (u32
*) hash_buf
->digest
;
15665 salt_t
*salt
= hash_buf
->salt
;
15667 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15673 char *version_pos
= input_buf
+ 11;
15675 char *osalt_pos
= strchr (version_pos
, '*');
15677 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15679 u32 version_len
= osalt_pos
- version_pos
;
15681 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15685 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15687 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15689 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15691 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15693 encryptedVerifier_pos
++;
15695 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15697 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15699 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15701 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15703 encryptedVerifierHash_pos
++;
15705 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15707 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15709 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15711 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15715 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15717 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15719 const uint version
= *version_pos
- 0x30;
15721 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15727 oldoffice34
->version
= version
;
15729 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15730 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15731 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15732 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15734 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15735 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15736 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15737 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15739 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15740 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15741 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15742 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15743 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15745 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15746 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15747 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15748 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15749 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15751 oldoffice34
->rc4key
[1] = 0;
15752 oldoffice34
->rc4key
[0] = 0;
15754 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15755 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15756 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15757 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15758 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15759 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15760 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15761 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15762 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15763 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15765 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15766 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15772 salt
->salt_len
= 16;
15774 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15775 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15776 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15777 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15779 // this is a workaround as office produces multiple documents with the same salt
15781 salt
->salt_len
+= 32;
15783 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15784 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15785 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15786 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15787 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15788 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15789 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15790 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15796 digest
[0] = oldoffice34
->rc4key
[0];
15797 digest
[1] = oldoffice34
->rc4key
[1];
15801 return (PARSER_OK
);
15804 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15806 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15808 u32
*digest
= (u32
*) hash_buf
->digest
;
15810 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15811 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15812 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15813 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15815 digest
[0] = byte_swap_32 (digest
[0]);
15816 digest
[1] = byte_swap_32 (digest
[1]);
15817 digest
[2] = byte_swap_32 (digest
[2]);
15818 digest
[3] = byte_swap_32 (digest
[3]);
15820 return (PARSER_OK
);
15823 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15825 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15827 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15829 u32
*digest
= (u32
*) hash_buf
->digest
;
15831 salt_t
*salt
= hash_buf
->salt
;
15833 char *signature_pos
= input_buf
;
15835 char *salt_pos
= strchr (signature_pos
, '$');
15837 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15839 u32 signature_len
= salt_pos
- signature_pos
;
15841 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15845 char *hash_pos
= strchr (salt_pos
, '$');
15847 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15849 u32 salt_len
= hash_pos
- salt_pos
;
15851 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15855 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15857 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15859 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15860 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15861 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15862 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15863 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15865 digest
[0] -= SHA1M_A
;
15866 digest
[1] -= SHA1M_B
;
15867 digest
[2] -= SHA1M_C
;
15868 digest
[3] -= SHA1M_D
;
15869 digest
[4] -= SHA1M_E
;
15871 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15873 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15875 salt
->salt_len
= salt_len
;
15877 return (PARSER_OK
);
15880 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15882 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15884 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15886 u32
*digest
= (u32
*) hash_buf
->digest
;
15888 salt_t
*salt
= hash_buf
->salt
;
15890 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15896 char *iter_pos
= input_buf
+ 14;
15898 const int iter
= atoi (iter_pos
);
15900 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15902 salt
->salt_iter
= iter
- 1;
15904 char *salt_pos
= strchr (iter_pos
, '$');
15906 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15910 char *hash_pos
= strchr (salt_pos
, '$');
15912 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15914 const uint salt_len
= hash_pos
- salt_pos
;
15918 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15920 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15922 salt
->salt_len
= salt_len
;
15924 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15925 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15927 // add some stuff to normal salt to make sorted happy
15929 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15930 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15931 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15932 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15933 salt
->salt_buf
[4] = salt
->salt_iter
;
15935 // base64 decode hash
15939 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15941 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15943 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15945 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15947 memcpy (digest
, tmp_buf
, 32);
15949 digest
[0] = byte_swap_32 (digest
[0]);
15950 digest
[1] = byte_swap_32 (digest
[1]);
15951 digest
[2] = byte_swap_32 (digest
[2]);
15952 digest
[3] = byte_swap_32 (digest
[3]);
15953 digest
[4] = byte_swap_32 (digest
[4]);
15954 digest
[5] = byte_swap_32 (digest
[5]);
15955 digest
[6] = byte_swap_32 (digest
[6]);
15956 digest
[7] = byte_swap_32 (digest
[7]);
15958 return (PARSER_OK
);
15961 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15963 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15965 u32
*digest
= (u32
*) hash_buf
->digest
;
15967 salt_t
*salt
= hash_buf
->salt
;
15969 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15970 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15974 digest
[0] = byte_swap_32 (digest
[0]);
15975 digest
[1] = byte_swap_32 (digest
[1]);
15977 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15978 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15979 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15981 char iter_c
= input_buf
[17];
15982 char iter_d
= input_buf
[19];
15984 // atm only defaults, let's see if there's more request
15985 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15986 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15988 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15990 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15991 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15992 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15993 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15995 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15996 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15997 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15998 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16000 salt
->salt_len
= 16;
16002 return (PARSER_OK
);
16005 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16007 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16009 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16011 u32
*digest
= (u32
*) hash_buf
->digest
;
16013 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16015 salt_t
*salt
= hash_buf
->salt
;
16017 char *salt_pos
= input_buf
+ 10;
16019 char *hash_pos
= strchr (salt_pos
, '$');
16021 uint salt_len
= hash_pos
- salt_pos
;
16023 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16027 uint hash_len
= input_len
- 10 - salt_len
- 1;
16029 // base64 decode salt
16033 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16035 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16037 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16039 tmp_buf
[salt_len
] = 0x80;
16041 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16043 salt
->salt_len
= salt_len
;
16045 // base64 decode salt
16047 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16049 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16051 uint user_len
= hash_len
- 32;
16053 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16055 user_len
--; // skip the trailing space
16057 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16058 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16059 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16060 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16062 digest
[0] = byte_swap_32 (digest
[0]);
16063 digest
[1] = byte_swap_32 (digest
[1]);
16064 digest
[2] = byte_swap_32 (digest
[2]);
16065 digest
[3] = byte_swap_32 (digest
[3]);
16067 // store username for host only (output hash if cracked)
16069 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16070 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16072 return (PARSER_OK
);
16075 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16077 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16079 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16081 u32
*digest
= (u32
*) hash_buf
->digest
;
16083 salt_t
*salt
= hash_buf
->salt
;
16085 char *iter_pos
= input_buf
+ 10;
16087 u32 iter
= atoi (iter_pos
);
16091 return (PARSER_SALT_ITERATION
);
16094 iter
--; // first iteration is special
16096 salt
->salt_iter
= iter
;
16098 char *base64_pos
= strchr (iter_pos
, '}');
16100 if (base64_pos
== NULL
)
16102 return (PARSER_SIGNATURE_UNMATCHED
);
16107 // base64 decode salt
16109 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16113 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16115 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16117 if (decoded_len
< 24)
16119 return (PARSER_SALT_LENGTH
);
16124 uint salt_len
= decoded_len
- 20;
16126 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16127 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16129 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16131 salt
->salt_len
= salt_len
;
16135 u32
*digest_ptr
= (u32
*) tmp_buf
;
16137 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16138 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16139 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16140 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16141 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16143 return (PARSER_OK
);
16146 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16148 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16150 u32
*digest
= (u32
*) hash_buf
->digest
;
16152 salt_t
*salt
= hash_buf
->salt
;
16154 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16155 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16156 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16157 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16158 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16160 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16162 uint salt_len
= input_len
- 40 - 1;
16164 char *salt_buf
= input_buf
+ 40 + 1;
16166 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16168 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16170 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16172 salt
->salt_len
= salt_len
;
16174 return (PARSER_OK
);
16177 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16179 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16181 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16183 u32
*digest
= (u32
*) hash_buf
->digest
;
16185 salt_t
*salt
= hash_buf
->salt
;
16187 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16193 char *V_pos
= input_buf
+ 5;
16195 char *R_pos
= strchr (V_pos
, '*');
16197 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16199 u32 V_len
= R_pos
- V_pos
;
16203 char *bits_pos
= strchr (R_pos
, '*');
16205 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16207 u32 R_len
= bits_pos
- R_pos
;
16211 char *P_pos
= strchr (bits_pos
, '*');
16213 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16215 u32 bits_len
= P_pos
- bits_pos
;
16219 char *enc_md_pos
= strchr (P_pos
, '*');
16221 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16223 u32 P_len
= enc_md_pos
- P_pos
;
16227 char *id_len_pos
= strchr (enc_md_pos
, '*');
16229 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16231 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16235 char *id_buf_pos
= strchr (id_len_pos
, '*');
16237 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16239 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16243 char *u_len_pos
= strchr (id_buf_pos
, '*');
16245 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16247 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16249 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16253 char *u_buf_pos
= strchr (u_len_pos
, '*');
16255 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16257 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16261 char *o_len_pos
= strchr (u_buf_pos
, '*');
16263 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16265 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16267 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16271 char *o_buf_pos
= strchr (o_len_pos
, '*');
16273 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16275 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16279 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;
16281 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16285 const int V
= atoi (V_pos
);
16286 const int R
= atoi (R_pos
);
16287 const int P
= atoi (P_pos
);
16289 if (V
!= 1) return (PARSER_SALT_VALUE
);
16290 if (R
!= 2) return (PARSER_SALT_VALUE
);
16292 const int enc_md
= atoi (enc_md_pos
);
16294 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16296 const int id_len
= atoi (id_len_pos
);
16297 const int u_len
= atoi (u_len_pos
);
16298 const int o_len
= atoi (o_len_pos
);
16300 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16301 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16302 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16304 const int bits
= atoi (bits_pos
);
16306 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16308 // copy data to esalt
16314 pdf
->enc_md
= enc_md
;
16316 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16317 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16318 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16319 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16320 pdf
->id_len
= id_len
;
16322 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16323 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16324 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16325 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16326 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16327 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16328 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16329 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16330 pdf
->u_len
= u_len
;
16332 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16333 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16334 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16335 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16336 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16337 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16338 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16339 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16340 pdf
->o_len
= o_len
;
16342 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16343 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16344 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16345 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16347 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16348 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16349 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16350 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16351 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16352 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16353 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16354 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16356 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16357 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16358 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16359 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16360 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16361 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16362 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16363 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16365 // we use ID for salt, maybe needs to change, we will see...
16367 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16368 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16369 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16370 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16371 salt
->salt_len
= pdf
->id_len
;
16373 digest
[0] = pdf
->u_buf
[0];
16374 digest
[1] = pdf
->u_buf
[1];
16375 digest
[2] = pdf
->u_buf
[2];
16376 digest
[3] = pdf
->u_buf
[3];
16378 return (PARSER_OK
);
16381 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16383 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16386 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16388 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16390 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16392 u32
*digest
= (u32
*) hash_buf
->digest
;
16394 salt_t
*salt
= hash_buf
->salt
;
16396 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16402 char *V_pos
= input_buf
+ 5;
16404 char *R_pos
= strchr (V_pos
, '*');
16406 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16408 u32 V_len
= R_pos
- V_pos
;
16412 char *bits_pos
= strchr (R_pos
, '*');
16414 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16416 u32 R_len
= bits_pos
- R_pos
;
16420 char *P_pos
= strchr (bits_pos
, '*');
16422 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16424 u32 bits_len
= P_pos
- bits_pos
;
16428 char *enc_md_pos
= strchr (P_pos
, '*');
16430 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16432 u32 P_len
= enc_md_pos
- P_pos
;
16436 char *id_len_pos
= strchr (enc_md_pos
, '*');
16438 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16440 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16444 char *id_buf_pos
= strchr (id_len_pos
, '*');
16446 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16448 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16452 char *u_len_pos
= strchr (id_buf_pos
, '*');
16454 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16456 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16458 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16462 char *u_buf_pos
= strchr (u_len_pos
, '*');
16464 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16466 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16470 char *o_len_pos
= strchr (u_buf_pos
, '*');
16472 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16474 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16476 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16480 char *o_buf_pos
= strchr (o_len_pos
, '*');
16482 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16484 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16488 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16490 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16492 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16494 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16498 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;
16500 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16504 const int V
= atoi (V_pos
);
16505 const int R
= atoi (R_pos
);
16506 const int P
= atoi (P_pos
);
16508 if (V
!= 1) return (PARSER_SALT_VALUE
);
16509 if (R
!= 2) return (PARSER_SALT_VALUE
);
16511 const int enc_md
= atoi (enc_md_pos
);
16513 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16515 const int id_len
= atoi (id_len_pos
);
16516 const int u_len
= atoi (u_len_pos
);
16517 const int o_len
= atoi (o_len_pos
);
16519 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16520 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16521 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16523 const int bits
= atoi (bits_pos
);
16525 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16527 // copy data to esalt
16533 pdf
->enc_md
= enc_md
;
16535 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16536 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16537 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16538 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16539 pdf
->id_len
= id_len
;
16541 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16542 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16543 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16544 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16545 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16546 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16547 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16548 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16549 pdf
->u_len
= u_len
;
16551 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16552 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16553 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16554 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16555 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16556 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16557 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16558 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16559 pdf
->o_len
= o_len
;
16561 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16562 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16563 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16564 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16566 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16567 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16568 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16569 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16570 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16571 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16572 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16573 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16575 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16576 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16577 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16578 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16579 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16580 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16581 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16582 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16584 pdf
->rc4key
[1] = 0;
16585 pdf
->rc4key
[0] = 0;
16587 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16588 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16589 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16590 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16591 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16592 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16593 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16594 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16595 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16596 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16598 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16599 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16601 // we use ID for salt, maybe needs to change, we will see...
16603 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16604 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16605 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16606 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16607 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16608 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16609 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16610 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16611 salt
->salt_len
= pdf
->id_len
+ 16;
16613 digest
[0] = pdf
->rc4key
[0];
16614 digest
[1] = pdf
->rc4key
[1];
16618 return (PARSER_OK
);
16621 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16623 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16625 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16627 u32
*digest
= (u32
*) hash_buf
->digest
;
16629 salt_t
*salt
= hash_buf
->salt
;
16631 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16637 char *V_pos
= input_buf
+ 5;
16639 char *R_pos
= strchr (V_pos
, '*');
16641 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16643 u32 V_len
= R_pos
- V_pos
;
16647 char *bits_pos
= strchr (R_pos
, '*');
16649 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16651 u32 R_len
= bits_pos
- R_pos
;
16655 char *P_pos
= strchr (bits_pos
, '*');
16657 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16659 u32 bits_len
= P_pos
- bits_pos
;
16663 char *enc_md_pos
= strchr (P_pos
, '*');
16665 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16667 u32 P_len
= enc_md_pos
- P_pos
;
16671 char *id_len_pos
= strchr (enc_md_pos
, '*');
16673 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16675 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16679 char *id_buf_pos
= strchr (id_len_pos
, '*');
16681 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16683 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16687 char *u_len_pos
= strchr (id_buf_pos
, '*');
16689 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16691 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16693 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16697 char *u_buf_pos
= strchr (u_len_pos
, '*');
16699 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16701 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16705 char *o_len_pos
= strchr (u_buf_pos
, '*');
16707 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16709 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16711 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16715 char *o_buf_pos
= strchr (o_len_pos
, '*');
16717 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16719 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16723 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;
16725 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16729 const int V
= atoi (V_pos
);
16730 const int R
= atoi (R_pos
);
16731 const int P
= atoi (P_pos
);
16735 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16736 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16738 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16740 const int id_len
= atoi (id_len_pos
);
16741 const int u_len
= atoi (u_len_pos
);
16742 const int o_len
= atoi (o_len_pos
);
16744 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16746 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16747 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16749 const int bits
= atoi (bits_pos
);
16751 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16757 enc_md
= atoi (enc_md_pos
);
16760 // copy data to esalt
16766 pdf
->enc_md
= enc_md
;
16768 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16769 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16770 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16771 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16775 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16776 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16777 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16778 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16781 pdf
->id_len
= id_len
;
16783 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16784 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16785 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16786 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16787 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16788 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16789 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16790 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16791 pdf
->u_len
= u_len
;
16793 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16794 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16795 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16796 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16797 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16798 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16799 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16800 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16801 pdf
->o_len
= o_len
;
16803 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16804 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16805 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16806 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16810 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16811 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16812 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16813 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16816 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16817 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16818 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16819 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16820 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16821 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16822 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16823 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16825 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16826 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16827 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16828 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16829 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16830 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16831 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16832 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16834 // precompute rc4 data for later use
16850 uint salt_pc_block
[32];
16852 char *salt_pc_ptr
= (char *) salt_pc_block
;
16854 memcpy (salt_pc_ptr
, padding
, 32);
16855 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16857 uint salt_pc_digest
[4];
16859 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16861 pdf
->rc4data
[0] = salt_pc_digest
[0];
16862 pdf
->rc4data
[1] = salt_pc_digest
[1];
16864 // we use ID for salt, maybe needs to change, we will see...
16866 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16867 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16868 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16869 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16870 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16871 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16872 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16873 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16874 salt
->salt_len
= pdf
->id_len
+ 16;
16876 salt
->salt_iter
= ROUNDS_PDF14
;
16878 digest
[0] = pdf
->u_buf
[0];
16879 digest
[1] = pdf
->u_buf
[1];
16883 return (PARSER_OK
);
16886 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16888 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16890 if (ret
!= PARSER_OK
)
16895 u32
*digest
= (u32
*) hash_buf
->digest
;
16897 salt_t
*salt
= hash_buf
->salt
;
16899 digest
[0] -= SHA256M_A
;
16900 digest
[1] -= SHA256M_B
;
16901 digest
[2] -= SHA256M_C
;
16902 digest
[3] -= SHA256M_D
;
16903 digest
[4] -= SHA256M_E
;
16904 digest
[5] -= SHA256M_F
;
16905 digest
[6] -= SHA256M_G
;
16906 digest
[7] -= SHA256M_H
;
16908 salt
->salt_buf
[2] = 0x80;
16910 return (PARSER_OK
);
16913 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16915 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16917 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16919 u32
*digest
= (u32
*) hash_buf
->digest
;
16921 salt_t
*salt
= hash_buf
->salt
;
16923 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16929 char *V_pos
= input_buf
+ 5;
16931 char *R_pos
= strchr (V_pos
, '*');
16933 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16935 u32 V_len
= R_pos
- V_pos
;
16939 char *bits_pos
= strchr (R_pos
, '*');
16941 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16943 u32 R_len
= bits_pos
- R_pos
;
16947 char *P_pos
= strchr (bits_pos
, '*');
16949 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16951 u32 bits_len
= P_pos
- bits_pos
;
16955 char *enc_md_pos
= strchr (P_pos
, '*');
16957 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16959 u32 P_len
= enc_md_pos
- P_pos
;
16963 char *id_len_pos
= strchr (enc_md_pos
, '*');
16965 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16967 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16971 char *id_buf_pos
= strchr (id_len_pos
, '*');
16973 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16975 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16979 char *u_len_pos
= strchr (id_buf_pos
, '*');
16981 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16983 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16987 char *u_buf_pos
= strchr (u_len_pos
, '*');
16989 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16991 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16995 char *o_len_pos
= strchr (u_buf_pos
, '*');
16997 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16999 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17003 char *o_buf_pos
= strchr (o_len_pos
, '*');
17005 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17007 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17011 char *last
= strchr (o_buf_pos
, '*');
17013 if (last
== NULL
) last
= input_buf
+ input_len
;
17015 u32 o_buf_len
= last
- o_buf_pos
;
17019 const int V
= atoi (V_pos
);
17020 const int R
= atoi (R_pos
);
17024 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17025 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17027 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17029 const int bits
= atoi (bits_pos
);
17031 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17033 int enc_md
= atoi (enc_md_pos
);
17035 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17037 const uint id_len
= atoi (id_len_pos
);
17038 const uint u_len
= atoi (u_len_pos
);
17039 const uint o_len
= atoi (o_len_pos
);
17041 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17042 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17043 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17044 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17045 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17046 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17047 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17048 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17050 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17051 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17052 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17054 // copy data to esalt
17056 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17058 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17060 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17063 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17064 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17066 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17067 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17069 salt
->salt_len
= 8;
17070 salt
->salt_iter
= ROUNDS_PDF17L8
;
17072 digest
[0] = pdf
->u_buf
[0];
17073 digest
[1] = pdf
->u_buf
[1];
17074 digest
[2] = pdf
->u_buf
[2];
17075 digest
[3] = pdf
->u_buf
[3];
17076 digest
[4] = pdf
->u_buf
[4];
17077 digest
[5] = pdf
->u_buf
[5];
17078 digest
[6] = pdf
->u_buf
[6];
17079 digest
[7] = pdf
->u_buf
[7];
17081 return (PARSER_OK
);
17084 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17086 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17088 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17090 u32
*digest
= (u32
*) hash_buf
->digest
;
17092 salt_t
*salt
= hash_buf
->salt
;
17094 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17102 char *iter_pos
= input_buf
+ 7;
17104 u32 iter
= atoi (iter_pos
);
17106 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17107 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17109 // first is *raw* salt
17111 char *salt_pos
= strchr (iter_pos
, ':');
17113 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17117 char *hash_pos
= strchr (salt_pos
, ':');
17119 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17121 u32 salt_len
= hash_pos
- salt_pos
;
17123 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17127 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17129 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17133 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17135 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17137 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17139 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17140 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17142 salt
->salt_len
= salt_len
;
17143 salt
->salt_iter
= iter
- 1;
17149 memset (tmp_buf
, 0, sizeof (tmp_buf
));
17151 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17153 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17155 memcpy (digest
, tmp_buf
, 16);
17157 digest
[0] = byte_swap_32 (digest
[0]);
17158 digest
[1] = byte_swap_32 (digest
[1]);
17159 digest
[2] = byte_swap_32 (digest
[2]);
17160 digest
[3] = byte_swap_32 (digest
[3]);
17162 // add some stuff to normal salt to make sorted happy
17164 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17165 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17166 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17167 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17168 salt
->salt_buf
[4] = salt
->salt_iter
;
17170 return (PARSER_OK
);
17173 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17175 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17177 u32
*digest
= (u32
*) hash_buf
->digest
;
17179 salt_t
*salt
= hash_buf
->salt
;
17181 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17182 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17183 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17184 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17186 digest
[0] = byte_swap_32 (digest
[0]);
17187 digest
[1] = byte_swap_32 (digest
[1]);
17188 digest
[2] = byte_swap_32 (digest
[2]);
17189 digest
[3] = byte_swap_32 (digest
[3]);
17191 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17193 uint salt_len
= input_len
- 32 - 1;
17195 char *salt_buf
= input_buf
+ 32 + 1;
17197 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17199 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17201 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17203 salt
->salt_len
= salt_len
;
17205 return (PARSER_OK
);
17208 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17210 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17212 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17214 u32
*digest
= (u32
*) hash_buf
->digest
;
17216 salt_t
*salt
= hash_buf
->salt
;
17218 char *user_pos
= input_buf
+ 10;
17220 char *salt_pos
= strchr (user_pos
, '*');
17222 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17226 char *hash_pos
= strchr (salt_pos
, '*');
17230 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17232 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17234 uint user_len
= salt_pos
- user_pos
- 1;
17236 uint salt_len
= hash_pos
- salt_pos
- 1;
17238 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17244 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17245 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17246 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17247 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17249 digest
[0] = byte_swap_32 (digest
[0]);
17250 digest
[1] = byte_swap_32 (digest
[1]);
17251 digest
[2] = byte_swap_32 (digest
[2]);
17252 digest
[3] = byte_swap_32 (digest
[3]);
17254 digest
[0] -= MD5M_A
;
17255 digest
[1] -= MD5M_B
;
17256 digest
[2] -= MD5M_C
;
17257 digest
[3] -= MD5M_D
;
17263 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17265 // first 4 bytes are the "challenge"
17267 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17268 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17269 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17270 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17272 // append the user name
17274 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17276 salt
->salt_len
= 4 + user_len
;
17278 return (PARSER_OK
);
17281 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17283 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17285 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17287 u32
*digest
= (u32
*) hash_buf
->digest
;
17289 salt_t
*salt
= hash_buf
->salt
;
17291 char *salt_pos
= input_buf
+ 9;
17293 char *hash_pos
= strchr (salt_pos
, '*');
17295 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17299 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17301 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17303 uint salt_len
= hash_pos
- salt_pos
- 1;
17305 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17311 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17312 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17313 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17314 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17315 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17321 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17323 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17325 salt
->salt_len
= salt_len
;
17327 return (PARSER_OK
);
17330 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17332 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17334 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17336 u32
*digest
= (u32
*) hash_buf
->digest
;
17338 salt_t
*salt
= hash_buf
->salt
;
17340 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17346 char *cry_master_len_pos
= input_buf
+ 9;
17348 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17350 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17352 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17354 cry_master_buf_pos
++;
17356 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17358 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17360 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17362 cry_salt_len_pos
++;
17364 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17366 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17368 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17370 cry_salt_buf_pos
++;
17372 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17374 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17376 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17380 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17382 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17384 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17388 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17390 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17392 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17396 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17398 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17400 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17402 public_key_len_pos
++;
17404 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17406 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17408 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17410 public_key_buf_pos
++;
17412 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;
17414 const uint cry_master_len
= atoi (cry_master_len_pos
);
17415 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17416 const uint ckey_len
= atoi (ckey_len_pos
);
17417 const uint public_key_len
= atoi (public_key_len_pos
);
17419 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17420 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17421 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17422 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17424 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17426 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17428 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17431 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17433 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17435 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17438 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17440 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17442 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17445 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17446 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17447 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17450 * store digest (should be unique enought, hopefully)
17453 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17454 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17455 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17456 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17462 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17464 const uint cry_rounds
= atoi (cry_rounds_pos
);
17466 salt
->salt_iter
= cry_rounds
- 1;
17468 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17470 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17472 salt
->salt_len
= salt_len
;
17474 return (PARSER_OK
);
17477 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17479 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17481 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17483 u32
*digest
= (u32
*) hash_buf
->digest
;
17485 salt_t
*salt
= hash_buf
->salt
;
17487 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17489 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17491 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17493 memcpy (temp_input_buf
, input_buf
, input_len
);
17497 char *URI_server_pos
= temp_input_buf
+ 6;
17499 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17501 if (URI_client_pos
== NULL
)
17503 myfree (temp_input_buf
);
17505 return (PARSER_SEPARATOR_UNMATCHED
);
17508 URI_client_pos
[0] = 0;
17511 uint URI_server_len
= strlen (URI_server_pos
);
17513 if (URI_server_len
> 512)
17515 myfree (temp_input_buf
);
17517 return (PARSER_SALT_LENGTH
);
17522 char *user_pos
= strchr (URI_client_pos
, '*');
17524 if (user_pos
== NULL
)
17526 myfree (temp_input_buf
);
17528 return (PARSER_SEPARATOR_UNMATCHED
);
17534 uint URI_client_len
= strlen (URI_client_pos
);
17536 if (URI_client_len
> 512)
17538 myfree (temp_input_buf
);
17540 return (PARSER_SALT_LENGTH
);
17545 char *realm_pos
= strchr (user_pos
, '*');
17547 if (realm_pos
== NULL
)
17549 myfree (temp_input_buf
);
17551 return (PARSER_SEPARATOR_UNMATCHED
);
17557 uint user_len
= strlen (user_pos
);
17559 if (user_len
> 116)
17561 myfree (temp_input_buf
);
17563 return (PARSER_SALT_LENGTH
);
17568 char *method_pos
= strchr (realm_pos
, '*');
17570 if (method_pos
== NULL
)
17572 myfree (temp_input_buf
);
17574 return (PARSER_SEPARATOR_UNMATCHED
);
17580 uint realm_len
= strlen (realm_pos
);
17582 if (realm_len
> 116)
17584 myfree (temp_input_buf
);
17586 return (PARSER_SALT_LENGTH
);
17591 char *URI_prefix_pos
= strchr (method_pos
, '*');
17593 if (URI_prefix_pos
== NULL
)
17595 myfree (temp_input_buf
);
17597 return (PARSER_SEPARATOR_UNMATCHED
);
17600 URI_prefix_pos
[0] = 0;
17603 uint method_len
= strlen (method_pos
);
17605 if (method_len
> 246)
17607 myfree (temp_input_buf
);
17609 return (PARSER_SALT_LENGTH
);
17614 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17616 if (URI_resource_pos
== NULL
)
17618 myfree (temp_input_buf
);
17620 return (PARSER_SEPARATOR_UNMATCHED
);
17623 URI_resource_pos
[0] = 0;
17624 URI_resource_pos
++;
17626 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17628 if (URI_prefix_len
> 245)
17630 myfree (temp_input_buf
);
17632 return (PARSER_SALT_LENGTH
);
17637 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17639 if (URI_suffix_pos
== NULL
)
17641 myfree (temp_input_buf
);
17643 return (PARSER_SEPARATOR_UNMATCHED
);
17646 URI_suffix_pos
[0] = 0;
17649 uint URI_resource_len
= strlen (URI_resource_pos
);
17651 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17653 myfree (temp_input_buf
);
17655 return (PARSER_SALT_LENGTH
);
17660 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17662 if (nonce_pos
== NULL
)
17664 myfree (temp_input_buf
);
17666 return (PARSER_SEPARATOR_UNMATCHED
);
17672 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17674 if (URI_suffix_len
> 245)
17676 myfree (temp_input_buf
);
17678 return (PARSER_SALT_LENGTH
);
17683 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17685 if (nonce_client_pos
== NULL
)
17687 myfree (temp_input_buf
);
17689 return (PARSER_SEPARATOR_UNMATCHED
);
17692 nonce_client_pos
[0] = 0;
17693 nonce_client_pos
++;
17695 uint nonce_len
= strlen (nonce_pos
);
17697 if (nonce_len
< 1 || nonce_len
> 50)
17699 myfree (temp_input_buf
);
17701 return (PARSER_SALT_LENGTH
);
17706 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17708 if (nonce_count_pos
== NULL
)
17710 myfree (temp_input_buf
);
17712 return (PARSER_SEPARATOR_UNMATCHED
);
17715 nonce_count_pos
[0] = 0;
17718 uint nonce_client_len
= strlen (nonce_client_pos
);
17720 if (nonce_client_len
> 50)
17722 myfree (temp_input_buf
);
17724 return (PARSER_SALT_LENGTH
);
17729 char *qop_pos
= strchr (nonce_count_pos
, '*');
17731 if (qop_pos
== NULL
)
17733 myfree (temp_input_buf
);
17735 return (PARSER_SEPARATOR_UNMATCHED
);
17741 uint nonce_count_len
= strlen (nonce_count_pos
);
17743 if (nonce_count_len
> 50)
17745 myfree (temp_input_buf
);
17747 return (PARSER_SALT_LENGTH
);
17752 char *directive_pos
= strchr (qop_pos
, '*');
17754 if (directive_pos
== NULL
)
17756 myfree (temp_input_buf
);
17758 return (PARSER_SEPARATOR_UNMATCHED
);
17761 directive_pos
[0] = 0;
17764 uint qop_len
= strlen (qop_pos
);
17768 myfree (temp_input_buf
);
17770 return (PARSER_SALT_LENGTH
);
17775 char *digest_pos
= strchr (directive_pos
, '*');
17777 if (digest_pos
== NULL
)
17779 myfree (temp_input_buf
);
17781 return (PARSER_SEPARATOR_UNMATCHED
);
17787 uint directive_len
= strlen (directive_pos
);
17789 if (directive_len
!= 3)
17791 myfree (temp_input_buf
);
17793 return (PARSER_SALT_LENGTH
);
17796 if (memcmp (directive_pos
, "MD5", 3))
17798 log_info ("ERROR: only the MD5 directive is currently supported\n");
17800 myfree (temp_input_buf
);
17802 return (PARSER_SIP_AUTH_DIRECTIVE
);
17806 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17811 uint md5_max_len
= 4 * 64;
17813 uint md5_remaining_len
= md5_max_len
;
17815 uint tmp_md5_buf
[64] = { 0 };
17817 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17819 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17821 md5_len
+= method_len
+ 1;
17822 tmp_md5_ptr
+= method_len
+ 1;
17824 if (URI_prefix_len
> 0)
17826 md5_remaining_len
= md5_max_len
- md5_len
;
17828 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17830 md5_len
+= URI_prefix_len
+ 1;
17831 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17834 md5_remaining_len
= md5_max_len
- md5_len
;
17836 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17838 md5_len
+= URI_resource_len
;
17839 tmp_md5_ptr
+= URI_resource_len
;
17841 if (URI_suffix_len
> 0)
17843 md5_remaining_len
= md5_max_len
- md5_len
;
17845 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17847 md5_len
+= 1 + URI_suffix_len
;
17850 uint tmp_digest
[4] = { 0 };
17852 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17854 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17855 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17856 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17857 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17863 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17865 uint esalt_len
= 0;
17867 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17869 // there are 2 possibilities for the esalt:
17871 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17873 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17875 if (esalt_len
> max_esalt_len
)
17877 myfree (temp_input_buf
);
17879 return (PARSER_SALT_LENGTH
);
17882 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17894 esalt_len
= 1 + nonce_len
+ 1 + 32;
17896 if (esalt_len
> max_esalt_len
)
17898 myfree (temp_input_buf
);
17900 return (PARSER_SALT_LENGTH
);
17903 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17911 // add 0x80 to esalt
17913 esalt_buf_ptr
[esalt_len
] = 0x80;
17915 sip
->esalt_len
= esalt_len
;
17921 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17923 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17925 uint max_salt_len
= 119;
17927 if (salt_len
> max_salt_len
)
17929 myfree (temp_input_buf
);
17931 return (PARSER_SALT_LENGTH
);
17934 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17936 sip
->salt_len
= salt_len
;
17939 * fake salt (for sorting)
17942 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17946 uint fake_salt_len
= salt_len
;
17948 if (fake_salt_len
> max_salt_len
)
17950 fake_salt_len
= max_salt_len
;
17953 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17955 salt
->salt_len
= fake_salt_len
;
17961 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17962 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17963 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17964 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17966 digest
[0] = byte_swap_32 (digest
[0]);
17967 digest
[1] = byte_swap_32 (digest
[1]);
17968 digest
[2] = byte_swap_32 (digest
[2]);
17969 digest
[3] = byte_swap_32 (digest
[3]);
17971 myfree (temp_input_buf
);
17973 return (PARSER_OK
);
17976 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17978 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17980 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17982 u32
*digest
= (u32
*) hash_buf
->digest
;
17984 salt_t
*salt
= hash_buf
->salt
;
17988 char *digest_pos
= input_buf
;
17990 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17997 char *salt_buf
= input_buf
+ 8 + 1;
18001 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18003 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18005 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18007 salt
->salt_len
= salt_len
;
18009 return (PARSER_OK
);
18012 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18014 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18016 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18018 u32
*digest
= (u32
*) hash_buf
->digest
;
18020 salt_t
*salt
= hash_buf
->salt
;
18022 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18028 char *p_buf_pos
= input_buf
+ 4;
18030 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18032 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18034 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18036 NumCyclesPower_pos
++;
18038 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18040 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18042 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18046 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18048 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18050 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18054 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18056 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18058 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18062 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18064 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18066 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18070 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18072 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18074 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18078 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18080 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18082 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18086 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18088 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18090 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18094 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18096 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18098 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18102 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;
18104 const uint iter
= atoi (NumCyclesPower_pos
);
18105 const uint crc
= atoi (crc_buf_pos
);
18106 const uint p_buf
= atoi (p_buf_pos
);
18107 const uint salt_len
= atoi (salt_len_pos
);
18108 const uint iv_len
= atoi (iv_len_pos
);
18109 const uint unpack_size
= atoi (unpack_size_pos
);
18110 const uint data_len
= atoi (data_len_pos
);
18116 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18117 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18119 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18121 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18123 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18129 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18130 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18131 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18132 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18134 seven_zip
->iv_len
= iv_len
;
18136 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18138 seven_zip
->salt_len
= 0;
18140 seven_zip
->crc
= crc
;
18142 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18144 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18146 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18149 seven_zip
->data_len
= data_len
;
18151 seven_zip
->unpack_size
= unpack_size
;
18155 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18156 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18157 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18158 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18160 salt
->salt_len
= 16;
18162 salt
->salt_sign
[0] = iter
;
18164 salt
->salt_iter
= 1 << iter
;
18175 return (PARSER_OK
);
18178 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18180 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18182 u32
*digest
= (u32
*) hash_buf
->digest
;
18184 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18185 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18186 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18187 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18188 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18189 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18190 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18191 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18193 digest
[0] = byte_swap_32 (digest
[0]);
18194 digest
[1] = byte_swap_32 (digest
[1]);
18195 digest
[2] = byte_swap_32 (digest
[2]);
18196 digest
[3] = byte_swap_32 (digest
[3]);
18197 digest
[4] = byte_swap_32 (digest
[4]);
18198 digest
[5] = byte_swap_32 (digest
[5]);
18199 digest
[6] = byte_swap_32 (digest
[6]);
18200 digest
[7] = byte_swap_32 (digest
[7]);
18202 return (PARSER_OK
);
18205 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18207 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18209 u32
*digest
= (u32
*) hash_buf
->digest
;
18211 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18212 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18213 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18214 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18215 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18216 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18217 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18218 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18219 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18220 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18221 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18222 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18223 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18224 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18225 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18226 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18228 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18229 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18230 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18231 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18232 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18233 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18234 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18235 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18236 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18237 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18238 digest
[10] = byte_swap_32 (digest
[10]);
18239 digest
[11] = byte_swap_32 (digest
[11]);
18240 digest
[12] = byte_swap_32 (digest
[12]);
18241 digest
[13] = byte_swap_32 (digest
[13]);
18242 digest
[14] = byte_swap_32 (digest
[14]);
18243 digest
[15] = byte_swap_32 (digest
[15]);
18245 return (PARSER_OK
);
18248 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18250 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18252 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18254 u32
*digest
= (u32
*) hash_buf
->digest
;
18256 salt_t
*salt
= hash_buf
->salt
;
18258 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18266 char *iter_pos
= input_buf
+ 4;
18268 u32 iter
= atoi (iter_pos
);
18270 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18271 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18273 // first is *raw* salt
18275 char *salt_pos
= strchr (iter_pos
, ':');
18277 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18281 char *hash_pos
= strchr (salt_pos
, ':');
18283 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18285 u32 salt_len
= hash_pos
- salt_pos
;
18287 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18291 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18293 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18297 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18299 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18301 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18303 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18304 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18306 salt
->salt_len
= salt_len
;
18307 salt
->salt_iter
= iter
- 1;
18313 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18315 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18317 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18319 memcpy (digest
, tmp_buf
, 16);
18321 // add some stuff to normal salt to make sorted happy
18323 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18324 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18325 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18326 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18327 salt
->salt_buf
[4] = salt
->salt_iter
;
18329 return (PARSER_OK
);
18332 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18334 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18336 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18338 u32
*digest
= (u32
*) hash_buf
->digest
;
18340 salt_t
*salt
= hash_buf
->salt
;
18342 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18350 char *iter_pos
= input_buf
+ 5;
18352 u32 iter
= atoi (iter_pos
);
18354 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18355 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18357 // first is *raw* salt
18359 char *salt_pos
= strchr (iter_pos
, ':');
18361 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18365 char *hash_pos
= strchr (salt_pos
, ':');
18367 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18369 u32 salt_len
= hash_pos
- salt_pos
;
18371 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18375 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18377 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18381 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18383 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18385 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18387 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18388 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18390 salt
->salt_len
= salt_len
;
18391 salt
->salt_iter
= iter
- 1;
18397 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18399 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18401 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18403 memcpy (digest
, tmp_buf
, 16);
18405 digest
[0] = byte_swap_32 (digest
[0]);
18406 digest
[1] = byte_swap_32 (digest
[1]);
18407 digest
[2] = byte_swap_32 (digest
[2]);
18408 digest
[3] = byte_swap_32 (digest
[3]);
18410 // add some stuff to normal salt to make sorted happy
18412 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18413 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18414 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18415 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18416 salt
->salt_buf
[4] = salt
->salt_iter
;
18418 return (PARSER_OK
);
18421 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18423 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18425 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18427 u64
*digest
= (u64
*) hash_buf
->digest
;
18429 salt_t
*salt
= hash_buf
->salt
;
18431 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18439 char *iter_pos
= input_buf
+ 7;
18441 u32 iter
= atoi (iter_pos
);
18443 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18444 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18446 // first is *raw* salt
18448 char *salt_pos
= strchr (iter_pos
, ':');
18450 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18454 char *hash_pos
= strchr (salt_pos
, ':');
18456 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18458 u32 salt_len
= hash_pos
- salt_pos
;
18460 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18464 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18466 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18470 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18472 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18474 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18476 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18477 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18479 salt
->salt_len
= salt_len
;
18480 salt
->salt_iter
= iter
- 1;
18486 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18488 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18490 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18492 memcpy (digest
, tmp_buf
, 64);
18494 digest
[0] = byte_swap_64 (digest
[0]);
18495 digest
[1] = byte_swap_64 (digest
[1]);
18496 digest
[2] = byte_swap_64 (digest
[2]);
18497 digest
[3] = byte_swap_64 (digest
[3]);
18498 digest
[4] = byte_swap_64 (digest
[4]);
18499 digest
[5] = byte_swap_64 (digest
[5]);
18500 digest
[6] = byte_swap_64 (digest
[6]);
18501 digest
[7] = byte_swap_64 (digest
[7]);
18503 // add some stuff to normal salt to make sorted happy
18505 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18506 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18507 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18508 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18509 salt
->salt_buf
[4] = salt
->salt_iter
;
18511 return (PARSER_OK
);
18514 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18516 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18518 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18520 uint
*digest
= (uint
*) hash_buf
->digest
;
18522 salt_t
*salt
= hash_buf
->salt
;
18528 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18530 char *hash_pos
= strchr (salt_pos
, '$');
18532 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18534 u32 salt_len
= hash_pos
- salt_pos
;
18536 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18540 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18542 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18546 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18547 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18565 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18566 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18568 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18569 salt
->salt_len
= 8;
18571 return (PARSER_OK
);
18574 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18576 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18578 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18580 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18582 if (c19
& 3) return (PARSER_HASH_VALUE
);
18584 salt_t
*salt
= hash_buf
->salt
;
18586 u32
*digest
= (u32
*) hash_buf
->digest
;
18590 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18591 | itoa64_to_int (input_buf
[2]) << 6
18592 | itoa64_to_int (input_buf
[3]) << 12
18593 | itoa64_to_int (input_buf
[4]) << 18;
18597 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18598 | itoa64_to_int (input_buf
[6]) << 6
18599 | itoa64_to_int (input_buf
[7]) << 12
18600 | itoa64_to_int (input_buf
[8]) << 18;
18602 salt
->salt_len
= 4;
18606 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18608 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18610 memcpy (digest
, tmp_buf
, 8);
18614 IP (digest
[0], digest
[1], tt
);
18616 digest
[0] = rotr32 (digest
[0], 31);
18617 digest
[1] = rotr32 (digest
[1], 31);
18621 return (PARSER_OK
);
18624 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18626 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18628 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18630 u32
*digest
= (u32
*) hash_buf
->digest
;
18632 salt_t
*salt
= hash_buf
->salt
;
18638 char *type_pos
= input_buf
+ 6 + 1;
18640 char *salt_pos
= strchr (type_pos
, '*');
18642 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18644 u32 type_len
= salt_pos
- type_pos
;
18646 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18650 char *crypted_pos
= strchr (salt_pos
, '*');
18652 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18654 u32 salt_len
= crypted_pos
- salt_pos
;
18656 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18660 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18662 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18668 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18669 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18671 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18672 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18674 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18675 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18676 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18677 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18679 salt
->salt_len
= 24;
18680 salt
->salt_iter
= ROUNDS_RAR3
;
18682 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18683 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18685 digest
[0] = 0xc43d7b00;
18686 digest
[1] = 0x40070000;
18690 return (PARSER_OK
);
18693 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18695 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18697 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18699 u32
*digest
= (u32
*) hash_buf
->digest
;
18701 salt_t
*salt
= hash_buf
->salt
;
18703 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18709 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18711 char *param1_pos
= strchr (param0_pos
, '$');
18713 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18715 u32 param0_len
= param1_pos
- param0_pos
;
18719 char *param2_pos
= strchr (param1_pos
, '$');
18721 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18723 u32 param1_len
= param2_pos
- param1_pos
;
18727 char *param3_pos
= strchr (param2_pos
, '$');
18729 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18731 u32 param2_len
= param3_pos
- param2_pos
;
18735 char *param4_pos
= strchr (param3_pos
, '$');
18737 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18739 u32 param3_len
= param4_pos
- param3_pos
;
18743 char *param5_pos
= strchr (param4_pos
, '$');
18745 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18747 u32 param4_len
= param5_pos
- param4_pos
;
18751 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18753 char *salt_buf
= param1_pos
;
18754 char *iv
= param3_pos
;
18755 char *pswcheck
= param5_pos
;
18757 const uint salt_len
= atoi (param0_pos
);
18758 const uint iterations
= atoi (param2_pos
);
18759 const uint pswcheck_len
= atoi (param4_pos
);
18765 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18766 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18767 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18769 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18770 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18771 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18777 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18778 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18779 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18780 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18782 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18783 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18784 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18785 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18787 salt
->salt_len
= 16;
18789 salt
->salt_sign
[0] = iterations
;
18791 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18797 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18798 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18802 return (PARSER_OK
);
18805 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18807 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18809 u32
*digest
= (u32
*) hash_buf
->digest
;
18811 salt_t
*salt
= hash_buf
->salt
;
18813 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18814 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18815 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18816 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18817 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18818 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18819 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18820 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18822 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18824 uint salt_len
= input_len
- 64 - 1;
18826 char *salt_buf
= input_buf
+ 64 + 1;
18828 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18830 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18832 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18834 salt
->salt_len
= salt_len
;
18837 * we can precompute the first sha256 transform
18842 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18843 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18844 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18845 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18846 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18847 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18848 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18849 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18850 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18851 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18852 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18853 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18854 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18855 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18856 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18857 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18861 pc256
[0] = SHA256M_A
;
18862 pc256
[1] = SHA256M_B
;
18863 pc256
[2] = SHA256M_C
;
18864 pc256
[3] = SHA256M_D
;
18865 pc256
[4] = SHA256M_E
;
18866 pc256
[5] = SHA256M_F
;
18867 pc256
[6] = SHA256M_G
;
18868 pc256
[7] = SHA256M_H
;
18870 sha256_64 (w
, pc256
);
18872 salt
->salt_buf_pc
[0] = pc256
[0];
18873 salt
->salt_buf_pc
[1] = pc256
[1];
18874 salt
->salt_buf_pc
[2] = pc256
[2];
18875 salt
->salt_buf_pc
[3] = pc256
[3];
18876 salt
->salt_buf_pc
[4] = pc256
[4];
18877 salt
->salt_buf_pc
[5] = pc256
[5];
18878 salt
->salt_buf_pc
[6] = pc256
[6];
18879 salt
->salt_buf_pc
[7] = pc256
[7];
18881 digest
[0] -= pc256
[0];
18882 digest
[1] -= pc256
[1];
18883 digest
[2] -= pc256
[2];
18884 digest
[3] -= pc256
[3];
18885 digest
[4] -= pc256
[4];
18886 digest
[5] -= pc256
[5];
18887 digest
[6] -= pc256
[6];
18888 digest
[7] -= pc256
[7];
18890 return (PARSER_OK
);
18893 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18895 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18897 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18899 u32
*digest
= (u32
*) hash_buf
->digest
;
18901 salt_t
*salt
= hash_buf
->salt
;
18907 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18909 char *data_buf_pos
= strchr (data_len_pos
, '$');
18911 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18913 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18915 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18916 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18920 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18922 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18924 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18926 u32 data_len
= atoi (data_len_pos
);
18928 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18934 char *salt_pos
= data_buf_pos
;
18936 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18937 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18938 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
18939 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
18941 // this is actually the CT, which is also the hash later (if matched)
18943 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
18944 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
18945 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
18946 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
18948 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18950 salt
->salt_iter
= 10 - 1;
18956 digest
[0] = salt
->salt_buf
[4];
18957 digest
[1] = salt
->salt_buf
[5];
18958 digest
[2] = salt
->salt_buf
[6];
18959 digest
[3] = salt
->salt_buf
[7];
18961 return (PARSER_OK
);
18964 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18966 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18968 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18970 u32
*digest
= (u32
*) hash_buf
->digest
;
18972 salt_t
*salt
= hash_buf
->salt
;
18978 char *salt_pos
= input_buf
+ 11 + 1;
18980 char *iter_pos
= strchr (salt_pos
, ',');
18982 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18984 u32 salt_len
= iter_pos
- salt_pos
;
18986 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18990 char *hash_pos
= strchr (iter_pos
, ',');
18992 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18994 u32 iter_len
= hash_pos
- iter_pos
;
18996 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19000 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19002 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19008 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19009 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19010 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19011 salt
->salt_buf
[3] = 0x00018000;
19013 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19014 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19015 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19016 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19018 salt
->salt_len
= salt_len
/ 2;
19020 salt
->salt_iter
= atoi (iter_pos
) - 1;
19026 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19027 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19028 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19029 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19030 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19031 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19032 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19033 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19035 return (PARSER_OK
);
19038 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19040 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19042 u32
*digest
= (u32
*) hash_buf
->digest
;
19044 salt_t
*salt
= hash_buf
->salt
;
19050 char *hash_pos
= input_buf
+ 64;
19051 char *salt1_pos
= input_buf
+ 128;
19052 char *salt2_pos
= input_buf
;
19058 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19059 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19060 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19061 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19063 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19064 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19065 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19066 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19068 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19069 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19070 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19071 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19073 salt
->salt_len
= 48;
19075 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19081 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19082 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19083 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19084 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19085 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19086 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19087 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19088 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19090 return (PARSER_OK
);
19094 * parallel running threads
19099 BOOL WINAPI
sigHandler_default (DWORD sig
)
19103 case CTRL_CLOSE_EVENT
:
19106 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19107 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19108 * function otherwise it is too late (e.g. after returning from this function)
19113 SetConsoleCtrlHandler (NULL
, TRUE
);
19120 case CTRL_LOGOFF_EVENT
:
19121 case CTRL_SHUTDOWN_EVENT
:
19125 SetConsoleCtrlHandler (NULL
, TRUE
);
19133 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19137 case CTRL_CLOSE_EVENT
:
19141 SetConsoleCtrlHandler (NULL
, TRUE
);
19148 case CTRL_LOGOFF_EVENT
:
19149 case CTRL_SHUTDOWN_EVENT
:
19153 SetConsoleCtrlHandler (NULL
, TRUE
);
19161 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19163 if (callback
== NULL
)
19165 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19169 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19175 void sigHandler_default (int sig
)
19179 signal (sig
, NULL
);
19182 void sigHandler_benchmark (int sig
)
19186 signal (sig
, NULL
);
19189 void hc_signal (void (callback
) (int))
19191 if (callback
== NULL
) callback
= SIG_DFL
;
19193 signal (SIGINT
, callback
);
19194 signal (SIGTERM
, callback
);
19195 signal (SIGABRT
, callback
);
19200 void status_display ();
19202 void *thread_keypress (void *p
)
19204 int benchmark
= *((int *) p
);
19206 uint quiet
= data
.quiet
;
19210 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19212 int ch
= tty_getchar();
19214 if (ch
== -1) break;
19216 if (ch
== 0) continue;
19222 hc_thread_mutex_lock (mux_display
);
19237 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19238 if (quiet
== 0) fflush (stdout
);
19250 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19251 if (quiet
== 0) fflush (stdout
);
19263 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19264 if (quiet
== 0) fflush (stdout
);
19276 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19277 if (quiet
== 0) fflush (stdout
);
19285 if (benchmark
== 1) break;
19287 stop_at_checkpoint ();
19291 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19292 if (quiet
== 0) fflush (stdout
);
19300 if (benchmark
== 1)
19312 hc_thread_mutex_unlock (mux_display
);
19324 bool class_num (const u8 c
)
19326 return ((c
>= '0') && (c
<= '9'));
19329 bool class_lower (const u8 c
)
19331 return ((c
>= 'a') && (c
<= 'z'));
19334 bool class_upper (const u8 c
)
19336 return ((c
>= 'A') && (c
<= 'Z'));
19339 bool class_alpha (const u8 c
)
19341 return (class_lower (c
) || class_upper (c
));
19344 int conv_ctoi (const u8 c
)
19350 else if (class_upper (c
))
19352 return c
- 'A' + 10;
19358 int conv_itoc (const u8 c
)
19366 return c
+ 'A' - 10;
19376 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19377 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19378 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19379 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19380 #define MAX_KERNEL_RULES 255
19381 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19382 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19383 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19385 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19386 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19387 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19388 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19390 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19395 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19397 switch (rule_buf
[rule_pos
])
19403 case RULE_OP_MANGLE_NOOP
:
19404 SET_NAME (rule
, rule_buf
[rule_pos
]);
19407 case RULE_OP_MANGLE_LREST
:
19408 SET_NAME (rule
, rule_buf
[rule_pos
]);
19411 case RULE_OP_MANGLE_UREST
:
19412 SET_NAME (rule
, rule_buf
[rule_pos
]);
19415 case RULE_OP_MANGLE_LREST_UFIRST
:
19416 SET_NAME (rule
, rule_buf
[rule_pos
]);
19419 case RULE_OP_MANGLE_UREST_LFIRST
:
19420 SET_NAME (rule
, rule_buf
[rule_pos
]);
19423 case RULE_OP_MANGLE_TREST
:
19424 SET_NAME (rule
, rule_buf
[rule_pos
]);
19427 case RULE_OP_MANGLE_TOGGLE_AT
:
19428 SET_NAME (rule
, rule_buf
[rule_pos
]);
19429 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19432 case RULE_OP_MANGLE_REVERSE
:
19433 SET_NAME (rule
, rule_buf
[rule_pos
]);
19436 case RULE_OP_MANGLE_DUPEWORD
:
19437 SET_NAME (rule
, rule_buf
[rule_pos
]);
19440 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19441 SET_NAME (rule
, rule_buf
[rule_pos
]);
19442 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19445 case RULE_OP_MANGLE_REFLECT
:
19446 SET_NAME (rule
, rule_buf
[rule_pos
]);
19449 case RULE_OP_MANGLE_ROTATE_LEFT
:
19450 SET_NAME (rule
, rule_buf
[rule_pos
]);
19453 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19454 SET_NAME (rule
, rule_buf
[rule_pos
]);
19457 case RULE_OP_MANGLE_APPEND
:
19458 SET_NAME (rule
, rule_buf
[rule_pos
]);
19459 SET_P0 (rule
, rule_buf
[rule_pos
]);
19462 case RULE_OP_MANGLE_PREPEND
:
19463 SET_NAME (rule
, rule_buf
[rule_pos
]);
19464 SET_P0 (rule
, rule_buf
[rule_pos
]);
19467 case RULE_OP_MANGLE_DELETE_FIRST
:
19468 SET_NAME (rule
, rule_buf
[rule_pos
]);
19471 case RULE_OP_MANGLE_DELETE_LAST
:
19472 SET_NAME (rule
, rule_buf
[rule_pos
]);
19475 case RULE_OP_MANGLE_DELETE_AT
:
19476 SET_NAME (rule
, rule_buf
[rule_pos
]);
19477 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19480 case RULE_OP_MANGLE_EXTRACT
:
19481 SET_NAME (rule
, rule_buf
[rule_pos
]);
19482 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19483 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19486 case RULE_OP_MANGLE_OMIT
:
19487 SET_NAME (rule
, rule_buf
[rule_pos
]);
19488 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19489 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19492 case RULE_OP_MANGLE_INSERT
:
19493 SET_NAME (rule
, rule_buf
[rule_pos
]);
19494 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19495 SET_P1 (rule
, rule_buf
[rule_pos
]);
19498 case RULE_OP_MANGLE_OVERSTRIKE
:
19499 SET_NAME (rule
, rule_buf
[rule_pos
]);
19500 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19501 SET_P1 (rule
, rule_buf
[rule_pos
]);
19504 case RULE_OP_MANGLE_TRUNCATE_AT
:
19505 SET_NAME (rule
, rule_buf
[rule_pos
]);
19506 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19509 case RULE_OP_MANGLE_REPLACE
:
19510 SET_NAME (rule
, rule_buf
[rule_pos
]);
19511 SET_P0 (rule
, rule_buf
[rule_pos
]);
19512 SET_P1 (rule
, rule_buf
[rule_pos
]);
19515 case RULE_OP_MANGLE_PURGECHAR
:
19519 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19523 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19524 SET_NAME (rule
, rule_buf
[rule_pos
]);
19525 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19528 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19529 SET_NAME (rule
, rule_buf
[rule_pos
]);
19530 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19533 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19534 SET_NAME (rule
, rule_buf
[rule_pos
]);
19537 case RULE_OP_MANGLE_SWITCH_FIRST
:
19538 SET_NAME (rule
, rule_buf
[rule_pos
]);
19541 case RULE_OP_MANGLE_SWITCH_LAST
:
19542 SET_NAME (rule
, rule_buf
[rule_pos
]);
19545 case RULE_OP_MANGLE_SWITCH_AT
:
19546 SET_NAME (rule
, rule_buf
[rule_pos
]);
19547 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19548 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19551 case RULE_OP_MANGLE_CHR_SHIFTL
:
19552 SET_NAME (rule
, rule_buf
[rule_pos
]);
19553 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19556 case RULE_OP_MANGLE_CHR_SHIFTR
:
19557 SET_NAME (rule
, rule_buf
[rule_pos
]);
19558 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19561 case RULE_OP_MANGLE_CHR_INCR
:
19562 SET_NAME (rule
, rule_buf
[rule_pos
]);
19563 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19566 case RULE_OP_MANGLE_CHR_DECR
:
19567 SET_NAME (rule
, rule_buf
[rule_pos
]);
19568 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19571 case RULE_OP_MANGLE_REPLACE_NP1
:
19572 SET_NAME (rule
, rule_buf
[rule_pos
]);
19573 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19576 case RULE_OP_MANGLE_REPLACE_NM1
:
19577 SET_NAME (rule
, rule_buf
[rule_pos
]);
19578 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19581 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19582 SET_NAME (rule
, rule_buf
[rule_pos
]);
19583 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19586 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19587 SET_NAME (rule
, rule_buf
[rule_pos
]);
19588 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19591 case RULE_OP_MANGLE_TITLE
:
19592 SET_NAME (rule
, rule_buf
[rule_pos
]);
19601 if (rule_pos
< rule_len
) return (-1);
19606 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19610 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19614 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19618 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19622 case RULE_OP_MANGLE_NOOP
:
19623 rule_buf
[rule_pos
] = rule_cmd
;
19626 case RULE_OP_MANGLE_LREST
:
19627 rule_buf
[rule_pos
] = rule_cmd
;
19630 case RULE_OP_MANGLE_UREST
:
19631 rule_buf
[rule_pos
] = rule_cmd
;
19634 case RULE_OP_MANGLE_LREST_UFIRST
:
19635 rule_buf
[rule_pos
] = rule_cmd
;
19638 case RULE_OP_MANGLE_UREST_LFIRST
:
19639 rule_buf
[rule_pos
] = rule_cmd
;
19642 case RULE_OP_MANGLE_TREST
:
19643 rule_buf
[rule_pos
] = rule_cmd
;
19646 case RULE_OP_MANGLE_TOGGLE_AT
:
19647 rule_buf
[rule_pos
] = rule_cmd
;
19648 GET_P0_CONV (rule
);
19651 case RULE_OP_MANGLE_REVERSE
:
19652 rule_buf
[rule_pos
] = rule_cmd
;
19655 case RULE_OP_MANGLE_DUPEWORD
:
19656 rule_buf
[rule_pos
] = rule_cmd
;
19659 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19660 rule_buf
[rule_pos
] = rule_cmd
;
19661 GET_P0_CONV (rule
);
19664 case RULE_OP_MANGLE_REFLECT
:
19665 rule_buf
[rule_pos
] = rule_cmd
;
19668 case RULE_OP_MANGLE_ROTATE_LEFT
:
19669 rule_buf
[rule_pos
] = rule_cmd
;
19672 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19673 rule_buf
[rule_pos
] = rule_cmd
;
19676 case RULE_OP_MANGLE_APPEND
:
19677 rule_buf
[rule_pos
] = rule_cmd
;
19681 case RULE_OP_MANGLE_PREPEND
:
19682 rule_buf
[rule_pos
] = rule_cmd
;
19686 case RULE_OP_MANGLE_DELETE_FIRST
:
19687 rule_buf
[rule_pos
] = rule_cmd
;
19690 case RULE_OP_MANGLE_DELETE_LAST
:
19691 rule_buf
[rule_pos
] = rule_cmd
;
19694 case RULE_OP_MANGLE_DELETE_AT
:
19695 rule_buf
[rule_pos
] = rule_cmd
;
19696 GET_P0_CONV (rule
);
19699 case RULE_OP_MANGLE_EXTRACT
:
19700 rule_buf
[rule_pos
] = rule_cmd
;
19701 GET_P0_CONV (rule
);
19702 GET_P1_CONV (rule
);
19705 case RULE_OP_MANGLE_OMIT
:
19706 rule_buf
[rule_pos
] = rule_cmd
;
19707 GET_P0_CONV (rule
);
19708 GET_P1_CONV (rule
);
19711 case RULE_OP_MANGLE_INSERT
:
19712 rule_buf
[rule_pos
] = rule_cmd
;
19713 GET_P0_CONV (rule
);
19717 case RULE_OP_MANGLE_OVERSTRIKE
:
19718 rule_buf
[rule_pos
] = rule_cmd
;
19719 GET_P0_CONV (rule
);
19723 case RULE_OP_MANGLE_TRUNCATE_AT
:
19724 rule_buf
[rule_pos
] = rule_cmd
;
19725 GET_P0_CONV (rule
);
19728 case RULE_OP_MANGLE_REPLACE
:
19729 rule_buf
[rule_pos
] = rule_cmd
;
19734 case RULE_OP_MANGLE_PURGECHAR
:
19738 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19742 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19743 rule_buf
[rule_pos
] = rule_cmd
;
19744 GET_P0_CONV (rule
);
19747 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19748 rule_buf
[rule_pos
] = rule_cmd
;
19749 GET_P0_CONV (rule
);
19752 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19753 rule_buf
[rule_pos
] = rule_cmd
;
19756 case RULE_OP_MANGLE_SWITCH_FIRST
:
19757 rule_buf
[rule_pos
] = rule_cmd
;
19760 case RULE_OP_MANGLE_SWITCH_LAST
:
19761 rule_buf
[rule_pos
] = rule_cmd
;
19764 case RULE_OP_MANGLE_SWITCH_AT
:
19765 rule_buf
[rule_pos
] = rule_cmd
;
19766 GET_P0_CONV (rule
);
19767 GET_P1_CONV (rule
);
19770 case RULE_OP_MANGLE_CHR_SHIFTL
:
19771 rule_buf
[rule_pos
] = rule_cmd
;
19772 GET_P0_CONV (rule
);
19775 case RULE_OP_MANGLE_CHR_SHIFTR
:
19776 rule_buf
[rule_pos
] = rule_cmd
;
19777 GET_P0_CONV (rule
);
19780 case RULE_OP_MANGLE_CHR_INCR
:
19781 rule_buf
[rule_pos
] = rule_cmd
;
19782 GET_P0_CONV (rule
);
19785 case RULE_OP_MANGLE_CHR_DECR
:
19786 rule_buf
[rule_pos
] = rule_cmd
;
19787 GET_P0_CONV (rule
);
19790 case RULE_OP_MANGLE_REPLACE_NP1
:
19791 rule_buf
[rule_pos
] = rule_cmd
;
19792 GET_P0_CONV (rule
);
19795 case RULE_OP_MANGLE_REPLACE_NM1
:
19796 rule_buf
[rule_pos
] = rule_cmd
;
19797 GET_P0_CONV (rule
);
19800 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19801 rule_buf
[rule_pos
] = rule_cmd
;
19802 GET_P0_CONV (rule
);
19805 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19806 rule_buf
[rule_pos
] = rule_cmd
;
19807 GET_P0_CONV (rule
);
19810 case RULE_OP_MANGLE_TITLE
:
19811 rule_buf
[rule_pos
] = rule_cmd
;
19815 return rule_pos
- 1;
19833 * CPU rules : this is from hashcat sources, cpu based rules
19836 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19837 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19839 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19840 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19841 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19843 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19844 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19845 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19847 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19851 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19856 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19860 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19865 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19869 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19874 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19879 for (l
= 0; l
< arr_len
; l
++)
19881 r
= arr_len
- 1 - l
;
19885 MANGLE_SWITCH (arr
, l
, r
);
19891 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19893 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19895 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19897 return (arr_len
* 2);
19900 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19902 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19904 int orig_len
= arr_len
;
19908 for (i
= 0; i
< times
; i
++)
19910 memcpy (&arr
[arr_len
], arr
, orig_len
);
19912 arr_len
+= orig_len
;
19918 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19920 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19922 mangle_double (arr
, arr_len
);
19924 mangle_reverse (arr
+ arr_len
, arr_len
);
19926 return (arr_len
* 2);
19929 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19934 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19936 MANGLE_SWITCH (arr
, l
, r
);
19942 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19947 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19949 MANGLE_SWITCH (arr
, l
, r
);
19955 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19957 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19961 return (arr_len
+ 1);
19964 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19966 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19970 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19972 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19977 return (arr_len
+ 1);
19980 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19982 if (upos
>= arr_len
) return (arr_len
);
19986 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19988 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19991 return (arr_len
- 1);
19994 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19996 if (upos
>= arr_len
) return (arr_len
);
19998 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20002 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20004 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20010 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20012 if (upos
>= arr_len
) return (arr_len
);
20014 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20018 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20020 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20023 return (arr_len
- ulen
);
20026 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20028 if (upos
>= arr_len
) return (arr_len
);
20030 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20034 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20036 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20041 return (arr_len
+ 1);
20044 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
)
20046 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20048 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20050 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20052 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20054 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20056 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20058 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20060 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20062 return (arr_len
+ arr2_cpy
);
20065 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20067 if (upos
>= arr_len
) return (arr_len
);
20074 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20076 if (upos
>= arr_len
) return (arr_len
);
20078 memset (arr
+ upos
, 0, arr_len
- upos
);
20083 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20087 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20089 if (arr
[arr_pos
] != oldc
) continue;
20091 arr
[arr_pos
] = newc
;
20097 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20103 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20105 if (arr
[arr_pos
] == c
) continue;
20107 arr
[ret_len
] = arr
[arr_pos
];
20115 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20117 if (ulen
> arr_len
) return (arr_len
);
20119 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20123 memcpy (cs
, arr
, ulen
);
20127 for (i
= 0; i
< ulen
; i
++)
20131 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20137 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20139 if (ulen
> arr_len
) return (arr_len
);
20141 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20143 int upos
= arr_len
- ulen
;
20147 for (i
= 0; i
< ulen
; i
++)
20149 char c
= arr
[upos
+ i
];
20151 arr_len
= mangle_append (arr
, arr_len
, c
);
20157 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20159 if ( arr_len
== 0) return (arr_len
);
20160 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20162 char c
= arr
[upos
];
20166 for (i
= 0; i
< ulen
; i
++)
20168 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20174 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20176 if ( arr_len
== 0) return (arr_len
);
20177 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20181 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20183 int new_pos
= arr_pos
* 2;
20185 arr
[new_pos
] = arr
[arr_pos
];
20187 arr
[new_pos
+ 1] = arr
[arr_pos
];
20190 return (arr_len
* 2);
20193 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20195 if (upos
>= arr_len
) return (arr_len
);
20196 if (upos2
>= arr_len
) return (arr_len
);
20198 MANGLE_SWITCH (arr
, upos
, upos2
);
20203 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20205 MANGLE_SWITCH (arr
, upos
, upos2
);
20210 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20212 if (upos
>= arr_len
) return (arr_len
);
20219 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20221 if (upos
>= arr_len
) return (arr_len
);
20228 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20230 if (upos
>= arr_len
) return (arr_len
);
20237 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20239 if (upos
>= arr_len
) return (arr_len
);
20246 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20248 int upper_next
= 1;
20252 for (pos
= 0; pos
< arr_len
; pos
++)
20254 if (arr
[pos
] == ' ')
20265 MANGLE_UPPER_AT (arr
, pos
);
20269 MANGLE_LOWER_AT (arr
, pos
);
20276 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20278 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20284 for (j
= 0; j
< rp_gen_num
; j
++)
20291 switch ((char) get_random_num (0, 9))
20294 r
= get_random_num (0, sizeof (grp_op_nop
));
20295 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20299 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20300 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20301 p1
= get_random_num (0, sizeof (grp_pos
));
20302 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20306 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20307 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20308 p1
= get_random_num (1, 6);
20309 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20313 r
= get_random_num (0, sizeof (grp_op_chr
));
20314 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20315 p1
= get_random_num (0x20, 0x7e);
20316 rule_buf
[rule_pos
++] = (char) p1
;
20320 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20321 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20322 p1
= get_random_num (0x20, 0x7e);
20323 rule_buf
[rule_pos
++] = (char) p1
;
20324 p2
= get_random_num (0x20, 0x7e);
20326 p2
= get_random_num (0x20, 0x7e);
20327 rule_buf
[rule_pos
++] = (char) p2
;
20331 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20332 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20333 p1
= get_random_num (0, sizeof (grp_pos
));
20334 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20335 p2
= get_random_num (0x20, 0x7e);
20336 rule_buf
[rule_pos
++] = (char) p2
;
20340 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20341 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20342 p1
= get_random_num (0, sizeof (grp_pos
));
20343 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20344 p2
= get_random_num (0, sizeof (grp_pos
));
20346 p2
= get_random_num (0, sizeof (grp_pos
));
20347 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20351 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20352 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20353 p1
= get_random_num (0, sizeof (grp_pos
));
20354 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20355 p2
= get_random_num (1, sizeof (grp_pos
));
20357 p2
= get_random_num (1, sizeof (grp_pos
));
20358 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20362 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20363 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20364 p1
= get_random_num (0, sizeof (grp_pos
));
20365 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20366 p2
= get_random_num (1, sizeof (grp_pos
));
20367 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20368 p3
= get_random_num (0, sizeof (grp_pos
));
20369 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20377 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20379 char mem
[BLOCK_SIZE
];
20381 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20383 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20385 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
20387 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20389 int out_len
= in_len
;
20390 int mem_len
= in_len
;
20392 memcpy (out
, in
, out_len
);
20396 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20398 int upos
; int upos2
;
20401 switch (rule
[rule_pos
])
20406 case RULE_OP_MANGLE_NOOP
:
20409 case RULE_OP_MANGLE_LREST
:
20410 out_len
= mangle_lrest (out
, out_len
);
20413 case RULE_OP_MANGLE_UREST
:
20414 out_len
= mangle_urest (out
, out_len
);
20417 case RULE_OP_MANGLE_LREST_UFIRST
:
20418 out_len
= mangle_lrest (out
, out_len
);
20419 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20422 case RULE_OP_MANGLE_UREST_LFIRST
:
20423 out_len
= mangle_urest (out
, out_len
);
20424 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20427 case RULE_OP_MANGLE_TREST
:
20428 out_len
= mangle_trest (out
, out_len
);
20431 case RULE_OP_MANGLE_TOGGLE_AT
:
20432 NEXT_RULEPOS (rule_pos
);
20433 NEXT_RPTOI (rule
, rule_pos
, upos
);
20434 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20437 case RULE_OP_MANGLE_REVERSE
:
20438 out_len
= mangle_reverse (out
, out_len
);
20441 case RULE_OP_MANGLE_DUPEWORD
:
20442 out_len
= mangle_double (out
, out_len
);
20445 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20446 NEXT_RULEPOS (rule_pos
);
20447 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20448 out_len
= mangle_double_times (out
, out_len
, ulen
);
20451 case RULE_OP_MANGLE_REFLECT
:
20452 out_len
= mangle_reflect (out
, out_len
);
20455 case RULE_OP_MANGLE_ROTATE_LEFT
:
20456 mangle_rotate_left (out
, out_len
);
20459 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20460 mangle_rotate_right (out
, out_len
);
20463 case RULE_OP_MANGLE_APPEND
:
20464 NEXT_RULEPOS (rule_pos
);
20465 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20468 case RULE_OP_MANGLE_PREPEND
:
20469 NEXT_RULEPOS (rule_pos
);
20470 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20473 case RULE_OP_MANGLE_DELETE_FIRST
:
20474 out_len
= mangle_delete_at (out
, out_len
, 0);
20477 case RULE_OP_MANGLE_DELETE_LAST
:
20478 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20481 case RULE_OP_MANGLE_DELETE_AT
:
20482 NEXT_RULEPOS (rule_pos
);
20483 NEXT_RPTOI (rule
, rule_pos
, upos
);
20484 out_len
= mangle_delete_at (out
, out_len
, upos
);
20487 case RULE_OP_MANGLE_EXTRACT
:
20488 NEXT_RULEPOS (rule_pos
);
20489 NEXT_RPTOI (rule
, rule_pos
, upos
);
20490 NEXT_RULEPOS (rule_pos
);
20491 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20492 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20495 case RULE_OP_MANGLE_OMIT
:
20496 NEXT_RULEPOS (rule_pos
);
20497 NEXT_RPTOI (rule
, rule_pos
, upos
);
20498 NEXT_RULEPOS (rule_pos
);
20499 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20500 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20503 case RULE_OP_MANGLE_INSERT
:
20504 NEXT_RULEPOS (rule_pos
);
20505 NEXT_RPTOI (rule
, rule_pos
, upos
);
20506 NEXT_RULEPOS (rule_pos
);
20507 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20510 case RULE_OP_MANGLE_OVERSTRIKE
:
20511 NEXT_RULEPOS (rule_pos
);
20512 NEXT_RPTOI (rule
, rule_pos
, upos
);
20513 NEXT_RULEPOS (rule_pos
);
20514 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20517 case RULE_OP_MANGLE_TRUNCATE_AT
:
20518 NEXT_RULEPOS (rule_pos
);
20519 NEXT_RPTOI (rule
, rule_pos
, upos
);
20520 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20523 case RULE_OP_MANGLE_REPLACE
:
20524 NEXT_RULEPOS (rule_pos
);
20525 NEXT_RULEPOS (rule_pos
);
20526 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20529 case RULE_OP_MANGLE_PURGECHAR
:
20530 NEXT_RULEPOS (rule_pos
);
20531 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20534 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20538 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20539 NEXT_RULEPOS (rule_pos
);
20540 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20541 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20544 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20545 NEXT_RULEPOS (rule_pos
);
20546 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20547 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20550 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20551 out_len
= mangle_dupechar (out
, out_len
);
20554 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20555 NEXT_RULEPOS (rule_pos
);
20556 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20557 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20560 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20561 NEXT_RULEPOS (rule_pos
);
20562 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20563 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20566 case RULE_OP_MANGLE_SWITCH_FIRST
:
20567 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20570 case RULE_OP_MANGLE_SWITCH_LAST
:
20571 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20574 case RULE_OP_MANGLE_SWITCH_AT
:
20575 NEXT_RULEPOS (rule_pos
);
20576 NEXT_RPTOI (rule
, rule_pos
, upos
);
20577 NEXT_RULEPOS (rule_pos
);
20578 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20579 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20582 case RULE_OP_MANGLE_CHR_SHIFTL
:
20583 NEXT_RULEPOS (rule_pos
);
20584 NEXT_RPTOI (rule
, rule_pos
, upos
);
20585 mangle_chr_shiftl (out
, out_len
, upos
);
20588 case RULE_OP_MANGLE_CHR_SHIFTR
:
20589 NEXT_RULEPOS (rule_pos
);
20590 NEXT_RPTOI (rule
, rule_pos
, upos
);
20591 mangle_chr_shiftr (out
, out_len
, upos
);
20594 case RULE_OP_MANGLE_CHR_INCR
:
20595 NEXT_RULEPOS (rule_pos
);
20596 NEXT_RPTOI (rule
, rule_pos
, upos
);
20597 mangle_chr_incr (out
, out_len
, upos
);
20600 case RULE_OP_MANGLE_CHR_DECR
:
20601 NEXT_RULEPOS (rule_pos
);
20602 NEXT_RPTOI (rule
, rule_pos
, upos
);
20603 mangle_chr_decr (out
, out_len
, upos
);
20606 case RULE_OP_MANGLE_REPLACE_NP1
:
20607 NEXT_RULEPOS (rule_pos
);
20608 NEXT_RPTOI (rule
, rule_pos
, upos
);
20609 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20612 case RULE_OP_MANGLE_REPLACE_NM1
:
20613 NEXT_RULEPOS (rule_pos
);
20614 NEXT_RPTOI (rule
, rule_pos
, upos
);
20615 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20618 case RULE_OP_MANGLE_TITLE
:
20619 out_len
= mangle_title (out
, out_len
);
20622 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20623 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20624 NEXT_RULEPOS (rule_pos
);
20625 NEXT_RPTOI (rule
, rule_pos
, upos
);
20626 NEXT_RULEPOS (rule_pos
);
20627 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20628 NEXT_RULEPOS (rule_pos
);
20629 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20630 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20633 case RULE_OP_MANGLE_APPEND_MEMORY
:
20634 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20635 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20636 memcpy (out
+ out_len
, mem
, mem_len
);
20637 out_len
+= mem_len
;
20640 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20641 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20642 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20643 memcpy (mem
+ mem_len
, out
, out_len
);
20644 out_len
+= mem_len
;
20645 memcpy (out
, mem
, out_len
);
20648 case RULE_OP_MEMORIZE_WORD
:
20649 memcpy (mem
, out
, out_len
);
20653 case RULE_OP_REJECT_LESS
:
20654 NEXT_RULEPOS (rule_pos
);
20655 NEXT_RPTOI (rule
, rule_pos
, upos
);
20656 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20659 case RULE_OP_REJECT_GREATER
:
20660 NEXT_RULEPOS (rule_pos
);
20661 NEXT_RPTOI (rule
, rule_pos
, upos
);
20662 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20665 case RULE_OP_REJECT_CONTAIN
:
20666 NEXT_RULEPOS (rule_pos
);
20667 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20670 case RULE_OP_REJECT_NOT_CONTAIN
:
20671 NEXT_RULEPOS (rule_pos
);
20672 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20675 case RULE_OP_REJECT_EQUAL_FIRST
:
20676 NEXT_RULEPOS (rule_pos
);
20677 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20680 case RULE_OP_REJECT_EQUAL_LAST
:
20681 NEXT_RULEPOS (rule_pos
);
20682 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20685 case RULE_OP_REJECT_EQUAL_AT
:
20686 NEXT_RULEPOS (rule_pos
);
20687 NEXT_RPTOI (rule
, rule_pos
, upos
);
20688 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20689 NEXT_RULEPOS (rule_pos
);
20690 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20693 case RULE_OP_REJECT_CONTAINS
:
20694 NEXT_RULEPOS (rule_pos
);
20695 NEXT_RPTOI (rule
, rule_pos
, upos
);
20696 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20697 NEXT_RULEPOS (rule_pos
);
20698 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20699 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20702 case RULE_OP_REJECT_MEMORY
:
20703 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20707 return (RULE_RC_SYNTAX_ERROR
);
20712 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);