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
++)
100 char s
[4096] = { 0 };
102 int max_len
= (int) sizeof (s
);
104 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
106 if (len
> max_len
) len
= max_len
;
108 fwrite (s
, len
, 1, fp
);
115 void log_out_nn (FILE *fp
, const char *fmt
, ...)
117 if (SUPPRESS_OUTPUT
) return;
123 log_final (fp
, fmt
, ap
);
128 void log_info_nn (const char *fmt
, ...)
130 if (SUPPRESS_OUTPUT
) return;
136 log_final (stdout
, fmt
, ap
);
141 void log_error_nn (const char *fmt
, ...)
143 if (SUPPRESS_OUTPUT
) return;
149 log_final (stderr
, fmt
, ap
);
154 void log_out (FILE *fp
, const char *fmt
, ...)
156 if (SUPPRESS_OUTPUT
) return;
162 log_final (fp
, fmt
, ap
);
171 void log_info (const char *fmt
, ...)
173 if (SUPPRESS_OUTPUT
) return;
179 log_final (stdout
, fmt
, ap
);
183 fputc ('\n', stdout
);
188 void log_error (const char *fmt
, ...)
190 if (SUPPRESS_OUTPUT
) return;
192 fputc ('\n', stderr
);
193 fputc ('\n', stderr
);
199 log_final (stderr
, fmt
, ap
);
203 fputc ('\n', stderr
);
204 fputc ('\n', stderr
);
213 u8
int_to_base32 (const u8 c
)
215 static const u8 tbl
[0x20] =
217 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
218 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
224 u8
base32_to_int (const u8 c
)
226 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
227 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
232 u8
int_to_itoa32 (const u8 c
)
234 static const u8 tbl
[0x20] =
236 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
237 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
243 u8
itoa32_to_int (const u8 c
)
245 if ((c
>= '0') && (c
<= '9')) return c
- '0';
246 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
251 u8
int_to_itoa64 (const u8 c
)
253 static const u8 tbl
[0x40] =
255 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
256 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
257 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
258 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
264 u8
itoa64_to_int (const u8 c
)
266 static const u8 tbl
[0x100] =
268 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
269 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
270 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
271 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
272 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
273 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
274 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
275 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
276 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
277 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
278 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
279 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
280 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
281 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
282 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
283 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
289 u8
int_to_base64 (const u8 c
)
291 static const u8 tbl
[0x40] =
293 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
294 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
295 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
296 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
302 u8
base64_to_int (const u8 c
)
304 static const u8 tbl
[0x100] =
306 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
308 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
309 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
310 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
311 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
313 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
327 u8
int_to_bf64 (const u8 c
)
329 static const u8 tbl
[0x40] =
331 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
332 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
333 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
334 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
340 u8
bf64_to_int (const u8 c
)
342 static const u8 tbl
[0x100] =
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
346 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
347 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
348 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
349 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
350 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
351 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
365 u8
int_to_lotus64 (const u8 c
)
367 if (c
< 10) return '0' + c
;
368 else if (c
< 36) return 'A' + c
- 10;
369 else if (c
< 62) return 'a' + c
- 36;
370 else if (c
== 62) return '+';
371 else if (c
== 63) return '/';
376 u8
lotus64_to_int (const u8 c
)
378 if ((c
>= '0') && (c
<= '9')) return c
- '0';
379 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
380 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
381 else if (c
== '+') return 62;
382 else if (c
== '/') return 63;
388 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
390 const u8
*in_ptr
= in_buf
;
392 u8
*out_ptr
= out_buf
;
394 for (int i
= 0; i
< in_len
; i
+= 8)
396 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
397 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
398 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
399 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
400 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
401 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
402 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
403 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
405 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
406 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
407 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
408 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
409 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
415 for (int i
= 0; i
< in_len
; i
++)
417 if (in_buf
[i
] != '=') continue;
422 int out_len
= (in_len
* 5) / 8;
427 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
429 const u8
*in_ptr
= in_buf
;
431 u8
*out_ptr
= out_buf
;
433 for (int i
= 0; i
< in_len
; i
+= 5)
435 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
436 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
437 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
438 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
439 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
440 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
441 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
442 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
444 out_ptr
[0] = out_val0
& 0x7f;
445 out_ptr
[1] = out_val1
& 0x7f;
446 out_ptr
[2] = out_val2
& 0x7f;
447 out_ptr
[3] = out_val3
& 0x7f;
448 out_ptr
[4] = out_val4
& 0x7f;
449 out_ptr
[5] = out_val5
& 0x7f;
450 out_ptr
[6] = out_val6
& 0x7f;
451 out_ptr
[7] = out_val7
& 0x7f;
457 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
461 out_buf
[out_len
] = '=';
469 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
471 const u8
*in_ptr
= in_buf
;
473 u8
*out_ptr
= out_buf
;
475 for (int i
= 0; i
< in_len
; i
+= 4)
477 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
478 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
479 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
480 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
482 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
483 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
484 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
490 for (int i
= 0; i
< in_len
; i
++)
492 if (in_buf
[i
] != '=') continue;
497 int out_len
= (in_len
* 6) / 8;
502 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
504 const u8
*in_ptr
= in_buf
;
506 u8
*out_ptr
= out_buf
;
508 for (int i
= 0; i
< in_len
; i
+= 3)
510 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
511 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
512 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
513 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
515 out_ptr
[0] = out_val0
& 0x7f;
516 out_ptr
[1] = out_val1
& 0x7f;
517 out_ptr
[2] = out_val2
& 0x7f;
518 out_ptr
[3] = out_val3
& 0x7f;
524 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
528 out_buf
[out_len
] = '=';
536 int is_valid_hex_char (const u8 c
)
538 if ((c
>= '0') && (c
<= '9')) return 1;
539 if ((c
>= 'A') && (c
<= 'F')) return 1;
540 if ((c
>= 'a') && (c
<= 'f')) return 1;
545 u8
hex_convert (const u8 c
)
547 return (c
& 15) + (c
>> 6) * 9;
550 u8
hex_to_u8 (const u8 hex
[2])
554 v
|= (hex_convert (hex
[1]) << 0);
555 v
|= (hex_convert (hex
[0]) << 4);
560 u32
hex_to_u32 (const u8 hex
[8])
564 v
|= ((u32
) hex_convert (hex
[7])) << 0;
565 v
|= ((u32
) hex_convert (hex
[6])) << 4;
566 v
|= ((u32
) hex_convert (hex
[5])) << 8;
567 v
|= ((u32
) hex_convert (hex
[4])) << 12;
568 v
|= ((u32
) hex_convert (hex
[3])) << 16;
569 v
|= ((u32
) hex_convert (hex
[2])) << 20;
570 v
|= ((u32
) hex_convert (hex
[1])) << 24;
571 v
|= ((u32
) hex_convert (hex
[0])) << 28;
576 u64
hex_to_u64 (const u8 hex
[16])
580 v
|= ((u64
) hex_convert (hex
[15]) << 0);
581 v
|= ((u64
) hex_convert (hex
[14]) << 4);
582 v
|= ((u64
) hex_convert (hex
[13]) << 8);
583 v
|= ((u64
) hex_convert (hex
[12]) << 12);
584 v
|= ((u64
) hex_convert (hex
[11]) << 16);
585 v
|= ((u64
) hex_convert (hex
[10]) << 20);
586 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
587 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
588 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
589 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
590 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
591 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
592 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
593 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
594 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
595 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
600 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
602 hex
[0] = v
>> 28 & 15;
603 hex
[1] = v
>> 24 & 15;
604 hex
[2] = v
>> 20 & 15;
605 hex
[3] = v
>> 16 & 15;
606 hex
[4] = v
>> 12 & 15;
607 hex
[5] = v
>> 8 & 15;
608 hex
[6] = v
>> 4 & 15;
609 hex
[7] = v
>> 0 & 15;
613 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
614 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
615 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
616 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
617 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
618 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
619 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
620 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
627 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
631 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
640 for (int i
= 0; i
< 16; i
+= 4)
650 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
657 out
[i
+ 0] = _out
[0];
658 out
[i
+ 1] = _out
[1];
659 out
[i
+ 2] = _out
[2];
660 out
[i
+ 3] = _out
[3];
669 static void juniper_decrypt_hash (char *in
, char *out
)
673 u8 base64_buf
[100] = { 0 };
675 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
679 u32 juniper_iv
[4] = { 0 };
681 memcpy (juniper_iv
, base64_buf
, 12);
683 memcpy (out
, juniper_iv
, 12);
687 u32 juniper_key
[4] = { 0 };
689 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
690 juniper_key
[1] = byte_swap_32 (0x8df91059);
691 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
692 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
696 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
697 u32
*out_ptr
= (u32
*) (out
+ 12);
699 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
702 void phpass_decode (u8 digest
[16], u8 buf
[22])
706 l
= itoa64_to_int (buf
[ 0]) << 0;
707 l
|= itoa64_to_int (buf
[ 1]) << 6;
708 l
|= itoa64_to_int (buf
[ 2]) << 12;
709 l
|= itoa64_to_int (buf
[ 3]) << 18;
711 digest
[ 0] = (l
>> 0) & 0xff;
712 digest
[ 1] = (l
>> 8) & 0xff;
713 digest
[ 2] = (l
>> 16) & 0xff;
715 l
= itoa64_to_int (buf
[ 4]) << 0;
716 l
|= itoa64_to_int (buf
[ 5]) << 6;
717 l
|= itoa64_to_int (buf
[ 6]) << 12;
718 l
|= itoa64_to_int (buf
[ 7]) << 18;
720 digest
[ 3] = (l
>> 0) & 0xff;
721 digest
[ 4] = (l
>> 8) & 0xff;
722 digest
[ 5] = (l
>> 16) & 0xff;
724 l
= itoa64_to_int (buf
[ 8]) << 0;
725 l
|= itoa64_to_int (buf
[ 9]) << 6;
726 l
|= itoa64_to_int (buf
[10]) << 12;
727 l
|= itoa64_to_int (buf
[11]) << 18;
729 digest
[ 6] = (l
>> 0) & 0xff;
730 digest
[ 7] = (l
>> 8) & 0xff;
731 digest
[ 8] = (l
>> 16) & 0xff;
733 l
= itoa64_to_int (buf
[12]) << 0;
734 l
|= itoa64_to_int (buf
[13]) << 6;
735 l
|= itoa64_to_int (buf
[14]) << 12;
736 l
|= itoa64_to_int (buf
[15]) << 18;
738 digest
[ 9] = (l
>> 0) & 0xff;
739 digest
[10] = (l
>> 8) & 0xff;
740 digest
[11] = (l
>> 16) & 0xff;
742 l
= itoa64_to_int (buf
[16]) << 0;
743 l
|= itoa64_to_int (buf
[17]) << 6;
744 l
|= itoa64_to_int (buf
[18]) << 12;
745 l
|= itoa64_to_int (buf
[19]) << 18;
747 digest
[12] = (l
>> 0) & 0xff;
748 digest
[13] = (l
>> 8) & 0xff;
749 digest
[14] = (l
>> 16) & 0xff;
751 l
= itoa64_to_int (buf
[20]) << 0;
752 l
|= itoa64_to_int (buf
[21]) << 6;
754 digest
[15] = (l
>> 0) & 0xff;
757 void phpass_encode (u8 digest
[16], u8 buf
[22])
761 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
763 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
766 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
768 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
770 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
773 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
775 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
777 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[11] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
784 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[15] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
791 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[19] = int_to_itoa64 (l
& 0x3f);
796 l
= (digest
[15] << 0);
798 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[21] = int_to_itoa64 (l
& 0x3f);
802 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
806 l
= itoa64_to_int (buf
[ 0]) << 0;
807 l
|= itoa64_to_int (buf
[ 1]) << 6;
808 l
|= itoa64_to_int (buf
[ 2]) << 12;
809 l
|= itoa64_to_int (buf
[ 3]) << 18;
811 digest
[ 0] = (l
>> 16) & 0xff;
812 digest
[ 6] = (l
>> 8) & 0xff;
813 digest
[12] = (l
>> 0) & 0xff;
815 l
= itoa64_to_int (buf
[ 4]) << 0;
816 l
|= itoa64_to_int (buf
[ 5]) << 6;
817 l
|= itoa64_to_int (buf
[ 6]) << 12;
818 l
|= itoa64_to_int (buf
[ 7]) << 18;
820 digest
[ 1] = (l
>> 16) & 0xff;
821 digest
[ 7] = (l
>> 8) & 0xff;
822 digest
[13] = (l
>> 0) & 0xff;
824 l
= itoa64_to_int (buf
[ 8]) << 0;
825 l
|= itoa64_to_int (buf
[ 9]) << 6;
826 l
|= itoa64_to_int (buf
[10]) << 12;
827 l
|= itoa64_to_int (buf
[11]) << 18;
829 digest
[ 2] = (l
>> 16) & 0xff;
830 digest
[ 8] = (l
>> 8) & 0xff;
831 digest
[14] = (l
>> 0) & 0xff;
833 l
= itoa64_to_int (buf
[12]) << 0;
834 l
|= itoa64_to_int (buf
[13]) << 6;
835 l
|= itoa64_to_int (buf
[14]) << 12;
836 l
|= itoa64_to_int (buf
[15]) << 18;
838 digest
[ 3] = (l
>> 16) & 0xff;
839 digest
[ 9] = (l
>> 8) & 0xff;
840 digest
[15] = (l
>> 0) & 0xff;
842 l
= itoa64_to_int (buf
[16]) << 0;
843 l
|= itoa64_to_int (buf
[17]) << 6;
844 l
|= itoa64_to_int (buf
[18]) << 12;
845 l
|= itoa64_to_int (buf
[19]) << 18;
847 digest
[ 4] = (l
>> 16) & 0xff;
848 digest
[10] = (l
>> 8) & 0xff;
849 digest
[ 5] = (l
>> 0) & 0xff;
851 l
= itoa64_to_int (buf
[20]) << 0;
852 l
|= itoa64_to_int (buf
[21]) << 6;
854 digest
[11] = (l
>> 0) & 0xff;
857 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
861 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
863 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
866 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
870 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
873 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
877 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
884 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
891 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 l
= (digest
[11] << 0);
898 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
902 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
906 l
= itoa64_to_int (buf
[ 0]) << 0;
907 l
|= itoa64_to_int (buf
[ 1]) << 6;
908 l
|= itoa64_to_int (buf
[ 2]) << 12;
909 l
|= itoa64_to_int (buf
[ 3]) << 18;
911 digest
[ 0] = (l
>> 16) & 0xff;
912 digest
[21] = (l
>> 8) & 0xff;
913 digest
[42] = (l
>> 0) & 0xff;
915 l
= itoa64_to_int (buf
[ 4]) << 0;
916 l
|= itoa64_to_int (buf
[ 5]) << 6;
917 l
|= itoa64_to_int (buf
[ 6]) << 12;
918 l
|= itoa64_to_int (buf
[ 7]) << 18;
920 digest
[22] = (l
>> 16) & 0xff;
921 digest
[43] = (l
>> 8) & 0xff;
922 digest
[ 1] = (l
>> 0) & 0xff;
924 l
= itoa64_to_int (buf
[ 8]) << 0;
925 l
|= itoa64_to_int (buf
[ 9]) << 6;
926 l
|= itoa64_to_int (buf
[10]) << 12;
927 l
|= itoa64_to_int (buf
[11]) << 18;
929 digest
[44] = (l
>> 16) & 0xff;
930 digest
[ 2] = (l
>> 8) & 0xff;
931 digest
[23] = (l
>> 0) & 0xff;
933 l
= itoa64_to_int (buf
[12]) << 0;
934 l
|= itoa64_to_int (buf
[13]) << 6;
935 l
|= itoa64_to_int (buf
[14]) << 12;
936 l
|= itoa64_to_int (buf
[15]) << 18;
938 digest
[ 3] = (l
>> 16) & 0xff;
939 digest
[24] = (l
>> 8) & 0xff;
940 digest
[45] = (l
>> 0) & 0xff;
942 l
= itoa64_to_int (buf
[16]) << 0;
943 l
|= itoa64_to_int (buf
[17]) << 6;
944 l
|= itoa64_to_int (buf
[18]) << 12;
945 l
|= itoa64_to_int (buf
[19]) << 18;
947 digest
[25] = (l
>> 16) & 0xff;
948 digest
[46] = (l
>> 8) & 0xff;
949 digest
[ 4] = (l
>> 0) & 0xff;
951 l
= itoa64_to_int (buf
[20]) << 0;
952 l
|= itoa64_to_int (buf
[21]) << 6;
953 l
|= itoa64_to_int (buf
[22]) << 12;
954 l
|= itoa64_to_int (buf
[23]) << 18;
956 digest
[47] = (l
>> 16) & 0xff;
957 digest
[ 5] = (l
>> 8) & 0xff;
958 digest
[26] = (l
>> 0) & 0xff;
960 l
= itoa64_to_int (buf
[24]) << 0;
961 l
|= itoa64_to_int (buf
[25]) << 6;
962 l
|= itoa64_to_int (buf
[26]) << 12;
963 l
|= itoa64_to_int (buf
[27]) << 18;
965 digest
[ 6] = (l
>> 16) & 0xff;
966 digest
[27] = (l
>> 8) & 0xff;
967 digest
[48] = (l
>> 0) & 0xff;
969 l
= itoa64_to_int (buf
[28]) << 0;
970 l
|= itoa64_to_int (buf
[29]) << 6;
971 l
|= itoa64_to_int (buf
[30]) << 12;
972 l
|= itoa64_to_int (buf
[31]) << 18;
974 digest
[28] = (l
>> 16) & 0xff;
975 digest
[49] = (l
>> 8) & 0xff;
976 digest
[ 7] = (l
>> 0) & 0xff;
978 l
= itoa64_to_int (buf
[32]) << 0;
979 l
|= itoa64_to_int (buf
[33]) << 6;
980 l
|= itoa64_to_int (buf
[34]) << 12;
981 l
|= itoa64_to_int (buf
[35]) << 18;
983 digest
[50] = (l
>> 16) & 0xff;
984 digest
[ 8] = (l
>> 8) & 0xff;
985 digest
[29] = (l
>> 0) & 0xff;
987 l
= itoa64_to_int (buf
[36]) << 0;
988 l
|= itoa64_to_int (buf
[37]) << 6;
989 l
|= itoa64_to_int (buf
[38]) << 12;
990 l
|= itoa64_to_int (buf
[39]) << 18;
992 digest
[ 9] = (l
>> 16) & 0xff;
993 digest
[30] = (l
>> 8) & 0xff;
994 digest
[51] = (l
>> 0) & 0xff;
996 l
= itoa64_to_int (buf
[40]) << 0;
997 l
|= itoa64_to_int (buf
[41]) << 6;
998 l
|= itoa64_to_int (buf
[42]) << 12;
999 l
|= itoa64_to_int (buf
[43]) << 18;
1001 digest
[31] = (l
>> 16) & 0xff;
1002 digest
[52] = (l
>> 8) & 0xff;
1003 digest
[10] = (l
>> 0) & 0xff;
1005 l
= itoa64_to_int (buf
[44]) << 0;
1006 l
|= itoa64_to_int (buf
[45]) << 6;
1007 l
|= itoa64_to_int (buf
[46]) << 12;
1008 l
|= itoa64_to_int (buf
[47]) << 18;
1010 digest
[53] = (l
>> 16) & 0xff;
1011 digest
[11] = (l
>> 8) & 0xff;
1012 digest
[32] = (l
>> 0) & 0xff;
1014 l
= itoa64_to_int (buf
[48]) << 0;
1015 l
|= itoa64_to_int (buf
[49]) << 6;
1016 l
|= itoa64_to_int (buf
[50]) << 12;
1017 l
|= itoa64_to_int (buf
[51]) << 18;
1019 digest
[12] = (l
>> 16) & 0xff;
1020 digest
[33] = (l
>> 8) & 0xff;
1021 digest
[54] = (l
>> 0) & 0xff;
1023 l
= itoa64_to_int (buf
[52]) << 0;
1024 l
|= itoa64_to_int (buf
[53]) << 6;
1025 l
|= itoa64_to_int (buf
[54]) << 12;
1026 l
|= itoa64_to_int (buf
[55]) << 18;
1028 digest
[34] = (l
>> 16) & 0xff;
1029 digest
[55] = (l
>> 8) & 0xff;
1030 digest
[13] = (l
>> 0) & 0xff;
1032 l
= itoa64_to_int (buf
[56]) << 0;
1033 l
|= itoa64_to_int (buf
[57]) << 6;
1034 l
|= itoa64_to_int (buf
[58]) << 12;
1035 l
|= itoa64_to_int (buf
[59]) << 18;
1037 digest
[56] = (l
>> 16) & 0xff;
1038 digest
[14] = (l
>> 8) & 0xff;
1039 digest
[35] = (l
>> 0) & 0xff;
1041 l
= itoa64_to_int (buf
[60]) << 0;
1042 l
|= itoa64_to_int (buf
[61]) << 6;
1043 l
|= itoa64_to_int (buf
[62]) << 12;
1044 l
|= itoa64_to_int (buf
[63]) << 18;
1046 digest
[15] = (l
>> 16) & 0xff;
1047 digest
[36] = (l
>> 8) & 0xff;
1048 digest
[57] = (l
>> 0) & 0xff;
1050 l
= itoa64_to_int (buf
[64]) << 0;
1051 l
|= itoa64_to_int (buf
[65]) << 6;
1052 l
|= itoa64_to_int (buf
[66]) << 12;
1053 l
|= itoa64_to_int (buf
[67]) << 18;
1055 digest
[37] = (l
>> 16) & 0xff;
1056 digest
[58] = (l
>> 8) & 0xff;
1057 digest
[16] = (l
>> 0) & 0xff;
1059 l
= itoa64_to_int (buf
[68]) << 0;
1060 l
|= itoa64_to_int (buf
[69]) << 6;
1061 l
|= itoa64_to_int (buf
[70]) << 12;
1062 l
|= itoa64_to_int (buf
[71]) << 18;
1064 digest
[59] = (l
>> 16) & 0xff;
1065 digest
[17] = (l
>> 8) & 0xff;
1066 digest
[38] = (l
>> 0) & 0xff;
1068 l
= itoa64_to_int (buf
[72]) << 0;
1069 l
|= itoa64_to_int (buf
[73]) << 6;
1070 l
|= itoa64_to_int (buf
[74]) << 12;
1071 l
|= itoa64_to_int (buf
[75]) << 18;
1073 digest
[18] = (l
>> 16) & 0xff;
1074 digest
[39] = (l
>> 8) & 0xff;
1075 digest
[60] = (l
>> 0) & 0xff;
1077 l
= itoa64_to_int (buf
[76]) << 0;
1078 l
|= itoa64_to_int (buf
[77]) << 6;
1079 l
|= itoa64_to_int (buf
[78]) << 12;
1080 l
|= itoa64_to_int (buf
[79]) << 18;
1082 digest
[40] = (l
>> 16) & 0xff;
1083 digest
[61] = (l
>> 8) & 0xff;
1084 digest
[19] = (l
>> 0) & 0xff;
1086 l
= itoa64_to_int (buf
[80]) << 0;
1087 l
|= itoa64_to_int (buf
[81]) << 6;
1088 l
|= itoa64_to_int (buf
[82]) << 12;
1089 l
|= itoa64_to_int (buf
[83]) << 18;
1091 digest
[62] = (l
>> 16) & 0xff;
1092 digest
[20] = (l
>> 8) & 0xff;
1093 digest
[41] = (l
>> 0) & 0xff;
1095 l
= itoa64_to_int (buf
[84]) << 0;
1096 l
|= itoa64_to_int (buf
[85]) << 6;
1098 digest
[63] = (l
>> 0) & 0xff;
1101 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1105 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1107 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1110 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1114 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1117 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1121 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1128 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1135 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1142 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1149 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1156 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1163 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1170 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1177 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1184 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1191 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1198 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1205 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1212 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1219 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1226 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1233 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1240 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1247 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 l
= 0 | 0 | (digest
[63] << 0);
1254 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1258 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1262 l
= itoa64_to_int (buf
[ 0]) << 0;
1263 l
|= itoa64_to_int (buf
[ 1]) << 6;
1264 l
|= itoa64_to_int (buf
[ 2]) << 12;
1265 l
|= itoa64_to_int (buf
[ 3]) << 18;
1267 digest
[ 2] = (l
>> 0) & 0xff;
1268 digest
[ 1] = (l
>> 8) & 0xff;
1269 digest
[ 0] = (l
>> 16) & 0xff;
1271 l
= itoa64_to_int (buf
[ 4]) << 0;
1272 l
|= itoa64_to_int (buf
[ 5]) << 6;
1273 l
|= itoa64_to_int (buf
[ 6]) << 12;
1274 l
|= itoa64_to_int (buf
[ 7]) << 18;
1276 digest
[ 5] = (l
>> 0) & 0xff;
1277 digest
[ 4] = (l
>> 8) & 0xff;
1278 digest
[ 3] = (l
>> 16) & 0xff;
1280 l
= itoa64_to_int (buf
[ 8]) << 0;
1281 l
|= itoa64_to_int (buf
[ 9]) << 6;
1282 l
|= itoa64_to_int (buf
[10]) << 12;
1283 l
|= itoa64_to_int (buf
[11]) << 18;
1285 digest
[ 8] = (l
>> 0) & 0xff;
1286 digest
[ 7] = (l
>> 8) & 0xff;
1287 digest
[ 6] = (l
>> 16) & 0xff;
1289 l
= itoa64_to_int (buf
[12]) << 0;
1290 l
|= itoa64_to_int (buf
[13]) << 6;
1291 l
|= itoa64_to_int (buf
[14]) << 12;
1292 l
|= itoa64_to_int (buf
[15]) << 18;
1294 digest
[11] = (l
>> 0) & 0xff;
1295 digest
[10] = (l
>> 8) & 0xff;
1296 digest
[ 9] = (l
>> 16) & 0xff;
1298 l
= itoa64_to_int (buf
[16]) << 0;
1299 l
|= itoa64_to_int (buf
[17]) << 6;
1300 l
|= itoa64_to_int (buf
[18]) << 12;
1301 l
|= itoa64_to_int (buf
[19]) << 18;
1303 digest
[14] = (l
>> 0) & 0xff;
1304 digest
[13] = (l
>> 8) & 0xff;
1305 digest
[12] = (l
>> 16) & 0xff;
1307 l
= itoa64_to_int (buf
[20]) << 0;
1308 l
|= itoa64_to_int (buf
[21]) << 6;
1309 l
|= itoa64_to_int (buf
[22]) << 12;
1310 l
|= itoa64_to_int (buf
[23]) << 18;
1312 digest
[17] = (l
>> 0) & 0xff;
1313 digest
[16] = (l
>> 8) & 0xff;
1314 digest
[15] = (l
>> 16) & 0xff;
1316 l
= itoa64_to_int (buf
[24]) << 0;
1317 l
|= itoa64_to_int (buf
[25]) << 6;
1318 l
|= itoa64_to_int (buf
[26]) << 12;
1320 digest
[19] = (l
>> 8) & 0xff;
1321 digest
[18] = (l
>> 16) & 0xff;
1324 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1328 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1330 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1333 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1335 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1337 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1340 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1342 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1344 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[11] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1351 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[15] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1358 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[19] = int_to_itoa64 (l
& 0x3f);
1363 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1365 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[23] = int_to_itoa64 (l
& 0x3f);
1370 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1372 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1374 buf
[26] = int_to_itoa64 (l
& 0x3f);
1377 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1381 l
= itoa64_to_int (buf
[ 0]) << 0;
1382 l
|= itoa64_to_int (buf
[ 1]) << 6;
1383 l
|= itoa64_to_int (buf
[ 2]) << 12;
1384 l
|= itoa64_to_int (buf
[ 3]) << 18;
1386 digest
[ 2] = (l
>> 0) & 0xff;
1387 digest
[ 1] = (l
>> 8) & 0xff;
1388 digest
[ 0] = (l
>> 16) & 0xff;
1390 l
= itoa64_to_int (buf
[ 4]) << 0;
1391 l
|= itoa64_to_int (buf
[ 5]) << 6;
1392 l
|= itoa64_to_int (buf
[ 6]) << 12;
1393 l
|= itoa64_to_int (buf
[ 7]) << 18;
1395 digest
[ 5] = (l
>> 0) & 0xff;
1396 digest
[ 4] = (l
>> 8) & 0xff;
1397 digest
[ 3] = (l
>> 16) & 0xff;
1399 l
= itoa64_to_int (buf
[ 8]) << 0;
1400 l
|= itoa64_to_int (buf
[ 9]) << 6;
1401 l
|= itoa64_to_int (buf
[10]) << 12;
1402 l
|= itoa64_to_int (buf
[11]) << 18;
1404 digest
[ 8] = (l
>> 0) & 0xff;
1405 digest
[ 7] = (l
>> 8) & 0xff;
1406 digest
[ 6] = (l
>> 16) & 0xff;
1408 l
= itoa64_to_int (buf
[12]) << 0;
1409 l
|= itoa64_to_int (buf
[13]) << 6;
1410 l
|= itoa64_to_int (buf
[14]) << 12;
1411 l
|= itoa64_to_int (buf
[15]) << 18;
1413 digest
[11] = (l
>> 0) & 0xff;
1414 digest
[10] = (l
>> 8) & 0xff;
1415 digest
[ 9] = (l
>> 16) & 0xff;
1417 l
= itoa64_to_int (buf
[16]) << 0;
1418 l
|= itoa64_to_int (buf
[17]) << 6;
1419 l
|= itoa64_to_int (buf
[18]) << 12;
1420 l
|= itoa64_to_int (buf
[19]) << 18;
1422 digest
[14] = (l
>> 0) & 0xff;
1423 digest
[13] = (l
>> 8) & 0xff;
1424 digest
[12] = (l
>> 16) & 0xff;
1426 l
= itoa64_to_int (buf
[20]) << 0;
1427 l
|= itoa64_to_int (buf
[21]) << 6;
1428 l
|= itoa64_to_int (buf
[22]) << 12;
1429 l
|= itoa64_to_int (buf
[23]) << 18;
1431 digest
[17] = (l
>> 0) & 0xff;
1432 digest
[16] = (l
>> 8) & 0xff;
1433 digest
[15] = (l
>> 16) & 0xff;
1435 l
= itoa64_to_int (buf
[24]) << 0;
1436 l
|= itoa64_to_int (buf
[25]) << 6;
1437 l
|= itoa64_to_int (buf
[26]) << 12;
1438 l
|= itoa64_to_int (buf
[27]) << 18;
1440 digest
[20] = (l
>> 0) & 0xff;
1441 digest
[19] = (l
>> 8) & 0xff;
1442 digest
[18] = (l
>> 16) & 0xff;
1444 l
= itoa64_to_int (buf
[28]) << 0;
1445 l
|= itoa64_to_int (buf
[29]) << 6;
1446 l
|= itoa64_to_int (buf
[30]) << 12;
1447 l
|= itoa64_to_int (buf
[31]) << 18;
1449 digest
[23] = (l
>> 0) & 0xff;
1450 digest
[22] = (l
>> 8) & 0xff;
1451 digest
[21] = (l
>> 16) & 0xff;
1453 l
= itoa64_to_int (buf
[32]) << 0;
1454 l
|= itoa64_to_int (buf
[33]) << 6;
1455 l
|= itoa64_to_int (buf
[34]) << 12;
1456 l
|= itoa64_to_int (buf
[35]) << 18;
1458 digest
[26] = (l
>> 0) & 0xff;
1459 digest
[25] = (l
>> 8) & 0xff;
1460 digest
[24] = (l
>> 16) & 0xff;
1462 l
= itoa64_to_int (buf
[36]) << 0;
1463 l
|= itoa64_to_int (buf
[37]) << 6;
1464 l
|= itoa64_to_int (buf
[38]) << 12;
1465 l
|= itoa64_to_int (buf
[39]) << 18;
1467 digest
[29] = (l
>> 0) & 0xff;
1468 digest
[28] = (l
>> 8) & 0xff;
1469 digest
[27] = (l
>> 16) & 0xff;
1471 l
= itoa64_to_int (buf
[40]) << 0;
1472 l
|= itoa64_to_int (buf
[41]) << 6;
1473 l
|= itoa64_to_int (buf
[42]) << 12;
1475 //digest[32] = (l >> 0) & 0xff;
1476 digest
[31] = (l
>> 8) & 0xff;
1477 digest
[30] = (l
>> 16) & 0xff;
1480 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1484 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1486 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1489 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1491 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1493 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1496 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1498 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1500 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[11] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1507 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[15] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1514 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[19] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1521 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[23] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1528 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[27] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1535 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[31] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1542 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[35] = int_to_itoa64 (l
& 0x3f);
1547 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1549 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[39] = int_to_itoa64 (l
& 0x3f);
1554 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1556 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1558 buf
[42] = int_to_itoa64 (l
& 0x3f);
1561 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1565 l
= itoa64_to_int (buf
[ 0]) << 0;
1566 l
|= itoa64_to_int (buf
[ 1]) << 6;
1567 l
|= itoa64_to_int (buf
[ 2]) << 12;
1568 l
|= itoa64_to_int (buf
[ 3]) << 18;
1570 digest
[ 2] = (l
>> 0) & 0xff;
1571 digest
[ 1] = (l
>> 8) & 0xff;
1572 digest
[ 0] = (l
>> 16) & 0xff;
1574 l
= itoa64_to_int (buf
[ 4]) << 0;
1575 l
|= itoa64_to_int (buf
[ 5]) << 6;
1576 l
|= itoa64_to_int (buf
[ 6]) << 12;
1577 l
|= itoa64_to_int (buf
[ 7]) << 18;
1579 digest
[ 5] = (l
>> 0) & 0xff;
1580 digest
[ 4] = (l
>> 8) & 0xff;
1581 digest
[ 3] = (l
>> 16) & 0xff;
1583 l
= itoa64_to_int (buf
[ 8]) << 0;
1584 l
|= itoa64_to_int (buf
[ 9]) << 6;
1585 l
|= itoa64_to_int (buf
[10]) << 12;
1586 l
|= itoa64_to_int (buf
[11]) << 18;
1588 digest
[ 8] = (l
>> 0) & 0xff;
1589 digest
[ 7] = (l
>> 8) & 0xff;
1590 digest
[ 6] = (l
>> 16) & 0xff;
1592 l
= itoa64_to_int (buf
[12]) << 0;
1593 l
|= itoa64_to_int (buf
[13]) << 6;
1594 l
|= itoa64_to_int (buf
[14]) << 12;
1595 l
|= itoa64_to_int (buf
[15]) << 18;
1597 digest
[11] = (l
>> 0) & 0xff;
1598 digest
[10] = (l
>> 8) & 0xff;
1599 digest
[ 9] = (l
>> 16) & 0xff;
1601 l
= itoa64_to_int (buf
[16]) << 0;
1602 l
|= itoa64_to_int (buf
[17]) << 6;
1603 l
|= itoa64_to_int (buf
[18]) << 12;
1604 l
|= itoa64_to_int (buf
[19]) << 18;
1606 digest
[14] = (l
>> 0) & 0xff;
1607 digest
[13] = (l
>> 8) & 0xff;
1608 digest
[12] = (l
>> 16) & 0xff;
1610 l
= itoa64_to_int (buf
[20]) << 0;
1611 l
|= itoa64_to_int (buf
[21]) << 6;
1612 l
|= itoa64_to_int (buf
[22]) << 12;
1613 l
|= itoa64_to_int (buf
[23]) << 18;
1615 digest
[17] = (l
>> 0) & 0xff;
1616 digest
[16] = (l
>> 8) & 0xff;
1617 digest
[15] = (l
>> 16) & 0xff;
1619 l
= itoa64_to_int (buf
[24]) << 0;
1620 l
|= itoa64_to_int (buf
[25]) << 6;
1621 l
|= itoa64_to_int (buf
[26]) << 12;
1622 l
|= itoa64_to_int (buf
[27]) << 18;
1624 digest
[20] = (l
>> 0) & 0xff;
1625 digest
[19] = (l
>> 8) & 0xff;
1626 digest
[18] = (l
>> 16) & 0xff;
1628 l
= itoa64_to_int (buf
[28]) << 0;
1629 l
|= itoa64_to_int (buf
[29]) << 6;
1630 l
|= itoa64_to_int (buf
[30]) << 12;
1631 l
|= itoa64_to_int (buf
[31]) << 18;
1633 digest
[23] = (l
>> 0) & 0xff;
1634 digest
[22] = (l
>> 8) & 0xff;
1635 digest
[21] = (l
>> 16) & 0xff;
1637 l
= itoa64_to_int (buf
[32]) << 0;
1638 l
|= itoa64_to_int (buf
[33]) << 6;
1639 l
|= itoa64_to_int (buf
[34]) << 12;
1640 l
|= itoa64_to_int (buf
[35]) << 18;
1642 digest
[26] = (l
>> 0) & 0xff;
1643 digest
[25] = (l
>> 8) & 0xff;
1644 digest
[24] = (l
>> 16) & 0xff;
1646 l
= itoa64_to_int (buf
[36]) << 0;
1647 l
|= itoa64_to_int (buf
[37]) << 6;
1648 l
|= itoa64_to_int (buf
[38]) << 12;
1649 l
|= itoa64_to_int (buf
[39]) << 18;
1651 digest
[29] = (l
>> 0) & 0xff;
1652 digest
[28] = (l
>> 8) & 0xff;
1653 digest
[27] = (l
>> 16) & 0xff;
1655 l
= itoa64_to_int (buf
[40]) << 0;
1656 l
|= itoa64_to_int (buf
[41]) << 6;
1657 l
|= itoa64_to_int (buf
[42]) << 12;
1658 l
|= itoa64_to_int (buf
[43]) << 18;
1660 digest
[32] = (l
>> 0) & 0xff;
1661 digest
[31] = (l
>> 8) & 0xff;
1662 digest
[30] = (l
>> 16) & 0xff;
1664 l
= itoa64_to_int (buf
[44]) << 0;
1665 l
|= itoa64_to_int (buf
[45]) << 6;
1666 l
|= itoa64_to_int (buf
[46]) << 12;
1667 l
|= itoa64_to_int (buf
[47]) << 18;
1669 digest
[35] = (l
>> 0) & 0xff;
1670 digest
[34] = (l
>> 8) & 0xff;
1671 digest
[33] = (l
>> 16) & 0xff;
1673 l
= itoa64_to_int (buf
[48]) << 0;
1674 l
|= itoa64_to_int (buf
[49]) << 6;
1675 l
|= itoa64_to_int (buf
[50]) << 12;
1676 l
|= itoa64_to_int (buf
[51]) << 18;
1678 digest
[38] = (l
>> 0) & 0xff;
1679 digest
[37] = (l
>> 8) & 0xff;
1680 digest
[36] = (l
>> 16) & 0xff;
1682 l
= itoa64_to_int (buf
[52]) << 0;
1683 l
|= itoa64_to_int (buf
[53]) << 6;
1684 l
|= itoa64_to_int (buf
[54]) << 12;
1685 l
|= itoa64_to_int (buf
[55]) << 18;
1687 digest
[41] = (l
>> 0) & 0xff;
1688 digest
[40] = (l
>> 8) & 0xff;
1689 digest
[39] = (l
>> 16) & 0xff;
1691 l
= itoa64_to_int (buf
[56]) << 0;
1692 l
|= itoa64_to_int (buf
[57]) << 6;
1693 l
|= itoa64_to_int (buf
[58]) << 12;
1694 l
|= itoa64_to_int (buf
[59]) << 18;
1696 digest
[44] = (l
>> 0) & 0xff;
1697 digest
[43] = (l
>> 8) & 0xff;
1698 digest
[42] = (l
>> 16) & 0xff;
1700 l
= itoa64_to_int (buf
[60]) << 0;
1701 l
|= itoa64_to_int (buf
[61]) << 6;
1702 l
|= itoa64_to_int (buf
[62]) << 12;
1703 l
|= itoa64_to_int (buf
[63]) << 18;
1705 digest
[47] = (l
>> 0) & 0xff;
1706 digest
[46] = (l
>> 8) & 0xff;
1707 digest
[45] = (l
>> 16) & 0xff;
1709 l
= itoa64_to_int (buf
[64]) << 0;
1710 l
|= itoa64_to_int (buf
[65]) << 6;
1711 l
|= itoa64_to_int (buf
[66]) << 12;
1712 l
|= itoa64_to_int (buf
[67]) << 18;
1714 digest
[50] = (l
>> 0) & 0xff;
1715 digest
[49] = (l
>> 8) & 0xff;
1716 digest
[48] = (l
>> 16) & 0xff;
1718 l
= itoa64_to_int (buf
[68]) << 0;
1719 l
|= itoa64_to_int (buf
[69]) << 6;
1720 l
|= itoa64_to_int (buf
[70]) << 12;
1721 l
|= itoa64_to_int (buf
[71]) << 18;
1723 digest
[53] = (l
>> 0) & 0xff;
1724 digest
[52] = (l
>> 8) & 0xff;
1725 digest
[51] = (l
>> 16) & 0xff;
1727 l
= itoa64_to_int (buf
[72]) << 0;
1728 l
|= itoa64_to_int (buf
[73]) << 6;
1729 l
|= itoa64_to_int (buf
[74]) << 12;
1730 l
|= itoa64_to_int (buf
[75]) << 18;
1732 digest
[56] = (l
>> 0) & 0xff;
1733 digest
[55] = (l
>> 8) & 0xff;
1734 digest
[54] = (l
>> 16) & 0xff;
1736 l
= itoa64_to_int (buf
[76]) << 0;
1737 l
|= itoa64_to_int (buf
[77]) << 6;
1738 l
|= itoa64_to_int (buf
[78]) << 12;
1739 l
|= itoa64_to_int (buf
[79]) << 18;
1741 digest
[59] = (l
>> 0) & 0xff;
1742 digest
[58] = (l
>> 8) & 0xff;
1743 digest
[57] = (l
>> 16) & 0xff;
1745 l
= itoa64_to_int (buf
[80]) << 0;
1746 l
|= itoa64_to_int (buf
[81]) << 6;
1747 l
|= itoa64_to_int (buf
[82]) << 12;
1748 l
|= itoa64_to_int (buf
[83]) << 18;
1750 digest
[62] = (l
>> 0) & 0xff;
1751 digest
[61] = (l
>> 8) & 0xff;
1752 digest
[60] = (l
>> 16) & 0xff;
1754 l
= itoa64_to_int (buf
[84]) << 0;
1755 l
|= itoa64_to_int (buf
[85]) << 6;
1757 digest
[63] = (l
>> 16) & 0xff;
1760 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1764 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1766 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1769 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1771 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1773 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1776 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1778 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1780 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[11] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1787 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[15] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1794 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[19] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1801 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[23] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1808 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[27] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1815 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[31] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1822 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[35] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1829 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[39] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1836 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[43] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1843 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[47] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1850 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[51] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1857 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[55] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1864 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[59] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1871 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[63] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1878 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[67] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1885 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[71] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1892 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[75] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1899 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[79] = int_to_itoa64 (l
& 0x3f);
1904 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1906 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[83] = int_to_itoa64 (l
& 0x3f);
1911 l
= 0 | 0 | (digest
[63] << 16);
1913 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1917 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1921 l
= itoa64_to_int (buf
[ 0]) << 0;
1922 l
|= itoa64_to_int (buf
[ 1]) << 6;
1923 l
|= itoa64_to_int (buf
[ 2]) << 12;
1924 l
|= itoa64_to_int (buf
[ 3]) << 18;
1926 digest
[ 0] = (l
>> 16) & 0xff;
1927 digest
[10] = (l
>> 8) & 0xff;
1928 digest
[20] = (l
>> 0) & 0xff;
1930 l
= itoa64_to_int (buf
[ 4]) << 0;
1931 l
|= itoa64_to_int (buf
[ 5]) << 6;
1932 l
|= itoa64_to_int (buf
[ 6]) << 12;
1933 l
|= itoa64_to_int (buf
[ 7]) << 18;
1935 digest
[21] = (l
>> 16) & 0xff;
1936 digest
[ 1] = (l
>> 8) & 0xff;
1937 digest
[11] = (l
>> 0) & 0xff;
1939 l
= itoa64_to_int (buf
[ 8]) << 0;
1940 l
|= itoa64_to_int (buf
[ 9]) << 6;
1941 l
|= itoa64_to_int (buf
[10]) << 12;
1942 l
|= itoa64_to_int (buf
[11]) << 18;
1944 digest
[12] = (l
>> 16) & 0xff;
1945 digest
[22] = (l
>> 8) & 0xff;
1946 digest
[ 2] = (l
>> 0) & 0xff;
1948 l
= itoa64_to_int (buf
[12]) << 0;
1949 l
|= itoa64_to_int (buf
[13]) << 6;
1950 l
|= itoa64_to_int (buf
[14]) << 12;
1951 l
|= itoa64_to_int (buf
[15]) << 18;
1953 digest
[ 3] = (l
>> 16) & 0xff;
1954 digest
[13] = (l
>> 8) & 0xff;
1955 digest
[23] = (l
>> 0) & 0xff;
1957 l
= itoa64_to_int (buf
[16]) << 0;
1958 l
|= itoa64_to_int (buf
[17]) << 6;
1959 l
|= itoa64_to_int (buf
[18]) << 12;
1960 l
|= itoa64_to_int (buf
[19]) << 18;
1962 digest
[24] = (l
>> 16) & 0xff;
1963 digest
[ 4] = (l
>> 8) & 0xff;
1964 digest
[14] = (l
>> 0) & 0xff;
1966 l
= itoa64_to_int (buf
[20]) << 0;
1967 l
|= itoa64_to_int (buf
[21]) << 6;
1968 l
|= itoa64_to_int (buf
[22]) << 12;
1969 l
|= itoa64_to_int (buf
[23]) << 18;
1971 digest
[15] = (l
>> 16) & 0xff;
1972 digest
[25] = (l
>> 8) & 0xff;
1973 digest
[ 5] = (l
>> 0) & 0xff;
1975 l
= itoa64_to_int (buf
[24]) << 0;
1976 l
|= itoa64_to_int (buf
[25]) << 6;
1977 l
|= itoa64_to_int (buf
[26]) << 12;
1978 l
|= itoa64_to_int (buf
[27]) << 18;
1980 digest
[ 6] = (l
>> 16) & 0xff;
1981 digest
[16] = (l
>> 8) & 0xff;
1982 digest
[26] = (l
>> 0) & 0xff;
1984 l
= itoa64_to_int (buf
[28]) << 0;
1985 l
|= itoa64_to_int (buf
[29]) << 6;
1986 l
|= itoa64_to_int (buf
[30]) << 12;
1987 l
|= itoa64_to_int (buf
[31]) << 18;
1989 digest
[27] = (l
>> 16) & 0xff;
1990 digest
[ 7] = (l
>> 8) & 0xff;
1991 digest
[17] = (l
>> 0) & 0xff;
1993 l
= itoa64_to_int (buf
[32]) << 0;
1994 l
|= itoa64_to_int (buf
[33]) << 6;
1995 l
|= itoa64_to_int (buf
[34]) << 12;
1996 l
|= itoa64_to_int (buf
[35]) << 18;
1998 digest
[18] = (l
>> 16) & 0xff;
1999 digest
[28] = (l
>> 8) & 0xff;
2000 digest
[ 8] = (l
>> 0) & 0xff;
2002 l
= itoa64_to_int (buf
[36]) << 0;
2003 l
|= itoa64_to_int (buf
[37]) << 6;
2004 l
|= itoa64_to_int (buf
[38]) << 12;
2005 l
|= itoa64_to_int (buf
[39]) << 18;
2007 digest
[ 9] = (l
>> 16) & 0xff;
2008 digest
[19] = (l
>> 8) & 0xff;
2009 digest
[29] = (l
>> 0) & 0xff;
2011 l
= itoa64_to_int (buf
[40]) << 0;
2012 l
|= itoa64_to_int (buf
[41]) << 6;
2013 l
|= itoa64_to_int (buf
[42]) << 12;
2015 digest
[31] = (l
>> 8) & 0xff;
2016 digest
[30] = (l
>> 0) & 0xff;
2019 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2023 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2025 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2028 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2032 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2035 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2039 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2046 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2053 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2060 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2067 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2074 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2081 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2088 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2095 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2097 buf
[42] = int_to_itoa64 (l
& 0x3f);
2100 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2104 l
= itoa64_to_int (buf
[ 0]) << 0;
2105 l
|= itoa64_to_int (buf
[ 1]) << 6;
2106 l
|= itoa64_to_int (buf
[ 2]) << 12;
2107 l
|= itoa64_to_int (buf
[ 3]) << 18;
2109 digest
[ 0] = (l
>> 0) & 0xff;
2110 digest
[ 1] = (l
>> 8) & 0xff;
2111 digest
[ 2] = (l
>> 16) & 0xff;
2113 l
= itoa64_to_int (buf
[ 4]) << 0;
2114 l
|= itoa64_to_int (buf
[ 5]) << 6;
2115 l
|= itoa64_to_int (buf
[ 6]) << 12;
2116 l
|= itoa64_to_int (buf
[ 7]) << 18;
2118 digest
[ 3] = (l
>> 0) & 0xff;
2119 digest
[ 4] = (l
>> 8) & 0xff;
2120 digest
[ 5] = (l
>> 16) & 0xff;
2122 l
= itoa64_to_int (buf
[ 8]) << 0;
2123 l
|= itoa64_to_int (buf
[ 9]) << 6;
2124 l
|= itoa64_to_int (buf
[10]) << 12;
2125 l
|= itoa64_to_int (buf
[11]) << 18;
2127 digest
[ 6] = (l
>> 0) & 0xff;
2128 digest
[ 7] = (l
>> 8) & 0xff;
2129 digest
[ 8] = (l
>> 16) & 0xff;
2131 l
= itoa64_to_int (buf
[12]) << 0;
2132 l
|= itoa64_to_int (buf
[13]) << 6;
2133 l
|= itoa64_to_int (buf
[14]) << 12;
2134 l
|= itoa64_to_int (buf
[15]) << 18;
2136 digest
[ 9] = (l
>> 0) & 0xff;
2137 digest
[10] = (l
>> 8) & 0xff;
2138 digest
[11] = (l
>> 16) & 0xff;
2140 l
= itoa64_to_int (buf
[16]) << 0;
2141 l
|= itoa64_to_int (buf
[17]) << 6;
2142 l
|= itoa64_to_int (buf
[18]) << 12;
2143 l
|= itoa64_to_int (buf
[19]) << 18;
2145 digest
[12] = (l
>> 0) & 0xff;
2146 digest
[13] = (l
>> 8) & 0xff;
2147 digest
[14] = (l
>> 16) & 0xff;
2149 l
= itoa64_to_int (buf
[20]) << 0;
2150 l
|= itoa64_to_int (buf
[21]) << 6;
2151 l
|= itoa64_to_int (buf
[22]) << 12;
2152 l
|= itoa64_to_int (buf
[23]) << 18;
2154 digest
[15] = (l
>> 0) & 0xff;
2155 digest
[16] = (l
>> 8) & 0xff;
2156 digest
[17] = (l
>> 16) & 0xff;
2158 l
= itoa64_to_int (buf
[24]) << 0;
2159 l
|= itoa64_to_int (buf
[25]) << 6;
2160 l
|= itoa64_to_int (buf
[26]) << 12;
2161 l
|= itoa64_to_int (buf
[27]) << 18;
2163 digest
[18] = (l
>> 0) & 0xff;
2164 digest
[19] = (l
>> 8) & 0xff;
2165 digest
[20] = (l
>> 16) & 0xff;
2167 l
= itoa64_to_int (buf
[28]) << 0;
2168 l
|= itoa64_to_int (buf
[29]) << 6;
2169 l
|= itoa64_to_int (buf
[30]) << 12;
2170 l
|= itoa64_to_int (buf
[31]) << 18;
2172 digest
[21] = (l
>> 0) & 0xff;
2173 digest
[22] = (l
>> 8) & 0xff;
2174 digest
[23] = (l
>> 16) & 0xff;
2176 l
= itoa64_to_int (buf
[32]) << 0;
2177 l
|= itoa64_to_int (buf
[33]) << 6;
2178 l
|= itoa64_to_int (buf
[34]) << 12;
2179 l
|= itoa64_to_int (buf
[35]) << 18;
2181 digest
[24] = (l
>> 0) & 0xff;
2182 digest
[25] = (l
>> 8) & 0xff;
2183 digest
[26] = (l
>> 16) & 0xff;
2185 l
= itoa64_to_int (buf
[36]) << 0;
2186 l
|= itoa64_to_int (buf
[37]) << 6;
2187 l
|= itoa64_to_int (buf
[38]) << 12;
2188 l
|= itoa64_to_int (buf
[39]) << 18;
2190 digest
[27] = (l
>> 0) & 0xff;
2191 digest
[28] = (l
>> 8) & 0xff;
2192 digest
[29] = (l
>> 16) & 0xff;
2194 l
= itoa64_to_int (buf
[40]) << 0;
2195 l
|= itoa64_to_int (buf
[41]) << 6;
2196 l
|= itoa64_to_int (buf
[42]) << 12;
2197 l
|= itoa64_to_int (buf
[43]) << 18;
2199 digest
[30] = (l
>> 0) & 0xff;
2200 digest
[31] = (l
>> 8) & 0xff;
2201 digest
[32] = (l
>> 16) & 0xff;
2236 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2240 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2242 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2245 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2247 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2249 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2252 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2254 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2256 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[11] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2263 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[15] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2270 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[19] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2277 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[23] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2284 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[27] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2291 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[31] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2298 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[35] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2305 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[39] = int_to_itoa64 (l
& 0x3f);
2310 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2312 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2315 //buf[43] = int_to_itoa64 (l & 0x3f);
2323 static struct termio savemodes
;
2324 static int havemodes
= 0;
2328 struct termio modmodes
;
2330 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2334 modmodes
= savemodes
;
2335 modmodes
.c_lflag
&= ~ICANON
;
2336 modmodes
.c_cc
[VMIN
] = 1;
2337 modmodes
.c_cc
[VTIME
] = 0;
2339 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2348 FD_SET (fileno (stdin
), &rfds
);
2355 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2357 if (retval
== 0) return 0;
2358 if (retval
== -1) return -1;
2365 if (!havemodes
) return 0;
2367 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2372 static struct termios savemodes
;
2373 static int havemodes
= 0;
2377 struct termios modmodes
;
2379 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2383 modmodes
= savemodes
;
2384 modmodes
.c_lflag
&= ~ICANON
;
2385 modmodes
.c_cc
[VMIN
] = 1;
2386 modmodes
.c_cc
[VTIME
] = 0;
2388 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2397 FD_SET (fileno (stdin
), &rfds
);
2404 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2406 if (retval
== 0) return 0;
2407 if (retval
== -1) return -1;
2414 if (!havemodes
) return 0;
2416 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2421 static DWORD saveMode
= 0;
2425 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2427 GetConsoleMode (stdinHandle
, &saveMode
);
2428 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2435 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2437 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2439 if (rc
== WAIT_TIMEOUT
) return 0;
2440 if (rc
== WAIT_ABANDONED
) return -1;
2441 if (rc
== WAIT_FAILED
) return -1;
2443 // The whole ReadConsoleInput () part is a workaround.
2444 // For some unknown reason, maybe a mingw bug, a random signal
2445 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2446 // Then it wants to read with getche () a keyboard input
2447 // which has never been made.
2449 INPUT_RECORD buf
[100];
2453 memset (buf
, 0, sizeof (buf
));
2455 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2457 FlushConsoleInputBuffer (stdinHandle
);
2459 for (uint i
= 0; i
< num
; i
++)
2461 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2463 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2465 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2467 return KeyEvent
.uChar
.AsciiChar
;
2475 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2477 SetConsoleMode (stdinHandle
, saveMode
);
2487 #define MSG_ENOMEM "Insufficient memory available"
2489 void *mycalloc (size_t nmemb
, size_t size
)
2491 void *p
= calloc (nmemb
, size
);
2495 log_error ("ERROR: %s", MSG_ENOMEM
);
2503 void *mymalloc (size_t size
)
2505 void *p
= malloc (size
);
2509 log_error ("ERROR: %s", MSG_ENOMEM
);
2514 memset (p
, 0, size
);
2519 void myfree (void *ptr
)
2521 if (ptr
== NULL
) return;
2526 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2528 void *p
= realloc (ptr
, oldsz
+ add
);
2532 log_error ("ERROR: %s", MSG_ENOMEM
);
2537 memset ((char *) p
+ oldsz
, 0, add
);
2542 char *mystrdup (const char *s
)
2544 const size_t len
= strlen (s
);
2546 char *b
= (char *) mymalloc (len
+ 1);
2553 FILE *logfile_open (char *logfile
)
2555 FILE *fp
= fopen (logfile
, "ab");
2565 void logfile_close (FILE *fp
)
2567 if (fp
== stdout
) return;
2572 void logfile_append (const char *fmt
, ...)
2574 if (data
.logfile_disable
== 1) return;
2576 FILE *fp
= logfile_open (data
.logfile
);
2582 vfprintf (fp
, fmt
, ap
);
2593 int logfile_generate_id ()
2595 const int n
= rand ();
2604 char *logfile_generate_topid ()
2606 const int id
= logfile_generate_id ();
2608 char *topid
= (char *) mymalloc (1 + 16 + 1);
2610 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2615 char *logfile_generate_subid ()
2617 const int id
= logfile_generate_id ();
2619 char *subid
= (char *) mymalloc (1 + 16 + 1);
2621 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2631 void lock_file (FILE *fp
)
2633 struct flock lock
= { 0 };
2635 lock
.l_type
= F_WRLCK
;
2636 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2640 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2647 void unlock_file (FILE *fp
)
2649 struct flock lock
= { 0 };
2651 lock
.l_type
= F_UNLCK
;
2652 fcntl(fileno(fp
), F_SETLK
, &lock
);
2654 #endif /* F_SETLKW */
2659 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2661 FlushFileBuffers (h
);
2670 #if defined(_WIN) && defined(HAVE_NVAPI)
2671 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2675 if (hc_NvAPI_EnumPhysicalGPUs (nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2679 log_info ("WARN: No NvAPI adapters found");
2686 #endif // _WIN && HAVE_NVAPI
2688 #if defined(LINUX) && defined(HAVE_NVML)
2689 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2693 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2695 if (hc_NVML_nvmlDeviceGetHandleByIndex (data
.hm_dll_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2697 // can be used to determine if the device by index matches the cuda device by index
2698 // char name[100]; memset (name, 0, sizeof (name));
2699 // hc_NVML_nvmlDeviceGetName (data.hm_dll_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2706 log_info ("WARN: No NVML adapters found");
2713 #endif // LINUX && HAVE_NVML
2715 #if defined(HAVE_ADL) || defined(HAVE_NVML)
2716 void hm_close (HM_LIB hm_dll
)
2722 FreeLibrary (hm_dll
);
2727 HM_LIB
hm_init (const cl_uint vendor_id
)
2729 HM_LIB hm_dll
= NULL
;
2732 if (vendor_id
== VENDOR_ID_AMD
)
2735 hm_dll
= dlopen ("libatiadlxx.so", RTLD_LAZY
| RTLD_GLOBAL
);
2738 hm_dll
= LoadLibrary ("atiadlxx.dll");
2742 hm_dll
= LoadLibrary ("atiadlxy.dll");
2749 #if defined(LINUX) && defined(HAVE_NVML)
2750 if (vendor_id
== VENDOR_ID_NV
)
2752 hm_dll
= dlopen ("libnvidia-ml.so", RTLD_LAZY
| RTLD_GLOBAL
);
2758 #endif // HAVE_ADL || HAVE_NVML
2761 int get_adapters_num_amd (HM_LIB hm_dll_amd
, int *iNumberAdapters
)
2763 if (hc_ADL_Adapter_NumberOfAdapters_Get (hm_dll_amd
, iNumberAdapters
) != ADL_OK
) return -1;
2765 if (iNumberAdapters
== 0)
2767 log_info ("WARN: No ADL adapters found.");
2776 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2778 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2779 ADLODParameters lpOdParameters;
2781 lpOdParameters.iSize = sizeof (ADLODParameters);
2782 size_t plevels_size = 0;
2784 if (hc_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2786 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2787 __func__, iAdapterIndex,
2788 lpOdParameters.iNumberOfPerformanceLevels,
2789 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2790 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2792 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2794 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2796 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2798 if (hc_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2800 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2801 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2802 __func__, iAdapterIndex, j,
2803 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2805 myfree (lpOdPerformanceLevels);
2811 LPAdapterInfo
hm_get_adapter_info_amd (HM_LIB hm_dll_amd
, int iNumberAdapters
)
2813 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2815 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2817 if (hc_ADL_Adapter_AdapterInfo_Get (hm_dll_amd
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2819 return lpAdapterInfo
;
2824 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2827 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2831 for (uint i = 0; i < num_adl_adapters; i++)
2833 int opencl_bus_num = hm_device[i].busid;
2834 int opencl_dev_num = hm_device[i].devid;
2836 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2844 if (idx >= DEVICES_MAX) return -1;
2849 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2851 for (uint i = 0; i < opencl_num_devices; i++)
2853 cl_device_topology_amd device_topology;
2855 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2857 hm_device[i].busid = device_topology.pcie.bus;
2858 hm_device[i].devid = device_topology.pcie.device;
2863 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2865 // basically bubble sort
2867 for (int i
= 0; i
< num_adl_adapters
; i
++)
2869 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2871 // get info of adapter [x]
2873 u32 adapter_index_x
= valid_adl_device_list
[j
];
2874 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2876 u32 bus_num_x
= info_x
.iBusNumber
;
2877 u32 dev_num_x
= info_x
.iDeviceNumber
;
2879 // get info of adapter [y]
2881 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2882 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2884 u32 bus_num_y
= info_y
.iBusNumber
;
2885 u32 dev_num_y
= info_y
.iDeviceNumber
;
2889 if (bus_num_y
< bus_num_x
)
2893 else if (bus_num_y
== bus_num_x
)
2895 if (dev_num_y
< dev_num_x
)
2903 u32 temp
= valid_adl_device_list
[j
+ 1];
2905 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2906 valid_adl_device_list
[j
+ 0] = temp
;
2912 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2914 *num_adl_adapters
= 0;
2916 u32
*adl_adapters
= NULL
;
2918 int *bus_numbers
= NULL
;
2919 int *device_numbers
= NULL
;
2921 for (int i
= 0; i
< iNumberAdapters
; i
++)
2923 AdapterInfo info
= lpAdapterInfo
[i
];
2925 if (strlen (info
.strUDID
) < 1) continue;
2928 if (info
.iVendorID
!= 1002) continue;
2930 if (info
.iVendorID
!= 0x1002) continue;
2933 if (info
.iBusNumber
< 0) continue;
2934 if (info
.iDeviceNumber
< 0) continue;
2938 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2940 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2947 if (found
) continue;
2949 // add it to the list
2951 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2953 adl_adapters
[*num_adl_adapters
] = i
;
2955 // rest is just bookkeeping
2957 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2958 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2960 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2961 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2963 (*num_adl_adapters
)++;
2966 myfree (bus_numbers
);
2967 myfree (device_numbers
);
2969 // sort the list by increasing bus id, device id number
2971 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2973 return adl_adapters
;
2976 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
)
2978 // loop through all valid devices
2980 for (int i
= 0; i
< num_adl_adapters
; i
++)
2982 u32 adapter_index
= valid_adl_device_list
[i
];
2986 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2988 // unfortunately this doesn't work since bus id and dev id are not unique
2989 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2990 // if (opencl_device_index == -1) continue;
2992 int opencl_device_index
= i
;
2994 // if (hm_show_performance_level (hm_dll_amd, info.iAdapterIndex) != 0) return -1;
2996 // get fanspeed info
2998 if (hm_device
[opencl_device_index
].od_version
== 5)
3000 ADLFanSpeedInfo FanSpeedInfo
;
3002 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
3004 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
3006 if (hc_ADL_Overdrive5_FanSpeedInfo_Get (hm_dll_amd
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
3008 // check read and write capability in fanspeedinfo
3010 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
3011 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
3013 hm_device
[opencl_device_index
].fan_supported
= 1;
3017 hm_device
[opencl_device_index
].fan_supported
= 0;
3020 else // od_version == 6
3022 ADLOD6FanSpeedInfo faninfo
;
3024 memset (&faninfo
, 0, sizeof (faninfo
));
3026 if (hc_ADL_Overdrive6_FanSpeed_Get (hm_dll_amd
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
3028 // check read capability in fanspeedinfo
3030 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
3032 hm_device
[opencl_device_index
].fan_supported
= 1;
3036 hm_device
[opencl_device_index
].fan_supported
= 0;
3044 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
)
3046 for (int i
= 0; i
< num_adl_adapters
; i
++)
3048 u32 adapter_index
= valid_adl_device_list
[i
];
3052 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3054 // get overdrive version
3056 int od_supported
= 0;
3060 if (hc_ADL_Overdrive_Caps (hm_dll_amd
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3062 // store the overdrive version in hm_device
3064 // unfortunately this doesn't work since bus id and dev id are not unique
3065 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3066 // if (opencl_device_index == -1) continue;
3068 int opencl_device_index
= i
;
3070 hm_device
[opencl_device_index
].od_version
= od_version
;
3076 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3078 for (int i
= 0; i
< num_adl_adapters
; i
++)
3080 u32 adapter_index
= valid_adl_device_list
[i
];
3084 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3086 // store the iAdapterIndex in hm_device
3088 // unfortunately this doesn't work since bus id and dev id are not unique
3089 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3090 // if (opencl_device_index == -1) continue;
3092 int opencl_device_index
= i
;
3094 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3097 return num_adl_adapters
;
3101 int hm_get_temperature_with_device_id (const uint device_id
)
3103 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3106 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3108 if (data
.hm_dll_amd
)
3110 if (data
.hm_device
[device_id
].od_version
== 5)
3112 ADLTemperature Temperature
;
3114 Temperature
.iSize
= sizeof (ADLTemperature
);
3116 if (hc_ADL_Overdrive5_Temperature_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3118 return Temperature
.iTemperature
/ 1000;
3120 else if (data
.hm_device
[device_id
].od_version
== 6)
3122 int Temperature
= 0;
3124 if (hc_ADL_Overdrive6_Temperature_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3126 return Temperature
/ 1000;
3132 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3133 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3135 #if defined(LINUX) && defined(HAVE_NVML)
3136 int temperature
= 0;
3138 hc_NVML_nvmlDeviceGetTemperature (data
.hm_dll_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3143 #if defined(WIN) && defined(HAVE_NVAPI)
3144 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3146 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3147 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3148 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3149 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3151 if (hc_NvAPI_GPU_GetThermalSettings (data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3153 return pThermalSettings
.sensor
[0].currentTemp
;
3154 #endif // WIN && HAVE_NVAPI
3156 #endif // HAVE_NVML || HAVE_NVAPI
3161 int hm_get_fanspeed_with_device_id (const uint device_id
)
3163 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3164 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3166 if (data
.hm_device
[device_id
].fan_supported
== 1)
3169 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3171 if (data
.hm_dll_amd
)
3173 if (data
.hm_device
[device_id
].od_version
== 5)
3175 ADLFanSpeedValue lpFanSpeedValue
;
3177 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3179 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3180 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3181 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3183 if (hc_ADL_Overdrive5_FanSpeed_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3185 return lpFanSpeedValue
.iFanSpeed
;
3187 else // od_version == 6
3189 ADLOD6FanSpeedInfo faninfo
;
3191 memset (&faninfo
, 0, sizeof (faninfo
));
3193 if (hc_ADL_Overdrive6_FanSpeed_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3195 return faninfo
.iFanSpeedPercent
;
3201 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3202 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3204 #if defined(LINUX) && defined(HAVE_NVML)
3207 hc_NVML_nvmlDeviceGetFanSpeed (data
.hm_dll_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3212 #if defined(WIN) && defined(HAVE_NVAPI)
3215 hc_NvAPI_GPU_GetTachReading (data
.hm_device
[device_id
].adapter_index
.nv
, &speed
);
3220 #endif // HAVE_NVML || HAVE_NVAPI
3226 int hm_get_utilization_with_device_id (const uint device_id
)
3228 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3231 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3233 if (data
.hm_dll_amd
)
3235 ADLPMActivity PMActivity
;
3237 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3239 if (hc_ADL_Overdrive_CurrentActivity_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3241 return PMActivity
.iActivityPercent
;
3246 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3247 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3249 #if defined(LINUX) && defined(HAVE_NVML)
3250 nvmlUtilization_t utilization
;
3252 hc_NVML_nvmlDeviceGetUtilizationRates (data
.hm_dll_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3254 return utilization
.gpu
;
3257 #if defined(WIN) && defined(HAVE_NVAPI)
3258 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3260 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3262 if (hc_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3264 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3267 #endif // HAVE_NVML || HAVE_NVAPI
3273 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3275 if (data
.hm_device
[device_id
].fan_supported
== 1)
3277 if (data
.hm_dll_amd
)
3279 if (data
.hm_device
[device_id
].od_version
== 5)
3281 ADLFanSpeedValue lpFanSpeedValue
;
3283 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3285 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3286 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3287 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3288 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3290 if (hc_ADL_Overdrive5_FanSpeed_Set (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3294 else // od_version == 6
3296 ADLOD6FanSpeedValue fan_speed_value
;
3298 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3300 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3301 fan_speed_value
.iFanSpeed
= fanspeed
;
3303 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;
3314 // helper function for status display
3316 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3318 #define VALUE_NOT_AVAILABLE "N/A"
3322 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3326 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3329 #endif // HAVE_HWMON
3335 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3337 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3339 if (css_cnt
> SP_PW_MAX
)
3341 log_error ("ERROR: mask length is too long");
3346 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3348 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3350 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3351 uint cs_len
= css
[css_pos
].cs_len
;
3353 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3355 uint c
= cs_buf
[cs_pos
] & 0xff;
3362 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3364 cs_t
*cs
= &css
[css_cnt
];
3366 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3368 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3372 for (i
= 0; i
< cs
->cs_len
; i
++)
3374 const uint u
= cs
->cs_buf
[i
];
3379 for (i
= 0; i
< in_len
; i
++)
3381 uint u
= in_buf
[i
] & 0xff;
3383 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3385 if (css_uniq
[u
] == 1) continue;
3389 cs
->cs_buf
[cs
->cs_len
] = u
;
3397 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3401 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3403 uint p0
= in_buf
[in_pos
] & 0xff;
3405 if (interpret
== 1 && p0
== '?')
3409 if (in_pos
== in_len
) break;
3411 uint p1
= in_buf
[in_pos
] & 0xff;
3415 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3417 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3419 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3421 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3423 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3425 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3427 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3428 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3430 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3431 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3433 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3434 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3436 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3437 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3439 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3441 default: log_error ("Syntax error: %s", in_buf
);
3447 if (data
.hex_charset
)
3451 if (in_pos
== in_len
)
3453 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3458 uint p1
= in_buf
[in_pos
] & 0xff;
3460 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3462 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3469 chr
= hex_convert (p1
) << 0;
3470 chr
|= hex_convert (p0
) << 4;
3472 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3478 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3484 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3488 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3490 sum
*= css
[css_pos
].cs_len
;
3496 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3498 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3503 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3505 char p0
= mask_buf
[mask_pos
];
3511 if (mask_pos
== mask_len
) break;
3513 char p1
= mask_buf
[mask_pos
];
3519 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3521 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3523 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3525 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3527 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3529 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3531 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3532 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3534 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3535 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3537 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3538 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3540 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3541 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3543 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3545 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3551 if (data
.hex_charset
)
3555 // if there is no 2nd hex character, show an error:
3557 if (mask_pos
== mask_len
)
3559 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3564 char p1
= mask_buf
[mask_pos
];
3566 // if they are not valid hex character, show an error:
3568 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3570 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3577 chr
|= hex_convert (p1
) << 0;
3578 chr
|= hex_convert (p0
) << 4;
3580 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3586 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3593 log_error ("ERROR: invalid mask length (0)");
3603 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3605 for (int i
= 0; i
< css_cnt
; i
++)
3607 uint len
= css
[i
].cs_len
;
3608 u64 next
= val
/ len
;
3609 uint pos
= val
% len
;
3610 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3615 void mp_cut_at (char *mask
, uint max
)
3619 uint mask_len
= strlen (mask
);
3621 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3623 if (mask
[i
] == '?') i
++;
3629 void mp_setup_sys (cs_t
*mp_sys
)
3633 uint donec
[CHARSIZ
] = { 0 };
3635 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3636 mp_sys
[0].cs_buf
[pos
++] = chr
;
3637 mp_sys
[0].cs_len
= pos
; }
3639 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3640 mp_sys
[1].cs_buf
[pos
++] = chr
;
3641 mp_sys
[1].cs_len
= pos
; }
3643 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3644 mp_sys
[2].cs_buf
[pos
++] = chr
;
3645 mp_sys
[2].cs_len
= pos
; }
3647 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3648 mp_sys
[3].cs_buf
[pos
++] = chr
;
3649 mp_sys
[3].cs_len
= pos
; }
3651 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3652 mp_sys
[4].cs_len
= pos
; }
3654 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3655 mp_sys
[5].cs_len
= pos
; }
3658 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3660 FILE *fp
= fopen (buf
, "rb");
3662 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3664 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3668 char mp_file
[1024] = { 0 };
3670 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3674 len
= in_superchop (mp_file
);
3678 log_info ("WARNING: charset file corrupted");
3680 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3684 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3689 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3691 mp_usr
[index
].cs_len
= 0;
3693 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3696 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3698 char *new_mask_buf
= (char *) mymalloc (256);
3704 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3706 if (css_pos
== len
) break;
3708 char p0
= mask_buf
[mask_pos
];
3710 new_mask_buf
[mask_pos
] = p0
;
3716 if (mask_pos
== mask_len
) break;
3718 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3722 if (data
.hex_charset
)
3726 if (mask_pos
== mask_len
)
3728 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3733 char p1
= mask_buf
[mask_pos
];
3735 // if they are not valid hex character, show an error:
3737 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3739 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3744 new_mask_buf
[mask_pos
] = p1
;
3749 if (css_pos
== len
) return (new_mask_buf
);
3751 myfree (new_mask_buf
);
3760 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3766 for (i
= start
; i
< stop
; i
++)
3768 sum
*= root_css_buf
[i
].cs_len
;
3774 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3778 cs_t
*cs
= &root_css_buf
[start
];
3782 for (i
= start
; i
< stop
; i
++)
3784 const u64 m
= v
% cs
->cs_len
;
3785 const u64 d
= v
/ cs
->cs_len
;
3789 const uint k
= cs
->cs_buf
[m
];
3791 pw_buf
[i
- start
] = (char) k
;
3793 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3797 int sp_comp_val (const void *p1
, const void *p2
)
3799 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3800 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3802 return b2
->val
- b1
->val
;
3805 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
)
3812 * Initialize hcstats
3815 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3817 u64
*root_stats_ptr
= root_stats_buf
;
3819 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3821 for (i
= 0; i
< SP_PW_MAX
; i
++)
3823 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3825 root_stats_ptr
+= CHARSIZ
;
3828 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3830 u64
*markov_stats_ptr
= markov_stats_buf
;
3832 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3834 for (i
= 0; i
< SP_PW_MAX
; i
++)
3836 for (j
= 0; j
< CHARSIZ
; j
++)
3838 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3840 markov_stats_ptr
+= CHARSIZ
;
3850 char hcstat_tmp
[256] = { 0 };
3852 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3854 hcstat
= hcstat_tmp
;
3857 FILE *fd
= fopen (hcstat
, "rb");
3861 log_error ("%s: %s", hcstat
, strerror (errno
));
3866 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3868 log_error ("%s: Could not load data", hcstat
);
3875 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3877 log_error ("%s: Could not load data", hcstat
);
3887 * Markov modifier of hcstat_table on user request
3892 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3893 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3898 /* Add all stats to first position */
3900 for (i
= 1; i
< SP_PW_MAX
; i
++)
3902 u64
*out
= root_stats_buf_by_pos
[0];
3903 u64
*in
= root_stats_buf_by_pos
[i
];
3905 for (j
= 0; j
< CHARSIZ
; j
++)
3911 for (i
= 1; i
< SP_PW_MAX
; i
++)
3913 u64
*out
= markov_stats_buf_by_key
[0][0];
3914 u64
*in
= markov_stats_buf_by_key
[i
][0];
3916 for (j
= 0; j
< CHARSIZ
; j
++)
3918 for (k
= 0; k
< CHARSIZ
; k
++)
3925 /* copy them to all pw_positions */
3927 for (i
= 1; i
< SP_PW_MAX
; i
++)
3929 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3932 for (i
= 1; i
< SP_PW_MAX
; i
++)
3934 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3942 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3944 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3946 for (i
= 0; i
< SP_PW_MAX
; i
++)
3948 root_table_buf_by_pos
[i
] = root_table_ptr
;
3950 root_table_ptr
+= CHARSIZ
;
3953 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3955 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3957 for (i
= 0; i
< SP_PW_MAX
; i
++)
3959 for (j
= 0; j
< CHARSIZ
; j
++)
3961 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3963 markov_table_ptr
+= CHARSIZ
;
3968 * Convert hcstat to tables
3971 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3973 uint key
= i
% CHARSIZ
;
3975 root_table_buf
[i
].key
= key
;
3976 root_table_buf
[i
].val
= root_stats_buf
[i
];
3979 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3981 uint key
= i
% CHARSIZ
;
3983 markov_table_buf
[i
].key
= key
;
3984 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3987 myfree (root_stats_buf
);
3988 myfree (markov_stats_buf
);
3994 for (i
= 0; i
< SP_PW_MAX
; i
++)
3996 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3999 for (i
= 0; i
< SP_PW_MAX
; i
++)
4001 for (j
= 0; j
< CHARSIZ
; j
++)
4003 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4008 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
])
4011 * Convert tables to css
4014 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4016 uint pw_pos
= i
/ CHARSIZ
;
4018 cs_t
*cs
= &root_css_buf
[pw_pos
];
4020 if (cs
->cs_len
== threshold
) continue;
4022 uint key
= root_table_buf
[i
].key
;
4024 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4026 cs
->cs_buf
[cs
->cs_len
] = key
;
4032 * Convert table to css
4035 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4037 uint c
= i
/ CHARSIZ
;
4039 cs_t
*cs
= &markov_css_buf
[c
];
4041 if (cs
->cs_len
== threshold
) continue;
4043 uint pw_pos
= c
/ CHARSIZ
;
4045 uint key
= markov_table_buf
[i
].key
;
4047 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4049 cs
->cs_buf
[cs
->cs_len
] = key
;
4055 for (uint i = 0; i < 8; i++)
4057 for (uint j = 0x20; j < 0x80; j++)
4059 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4061 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4063 for (uint k = 0; k < 10; k++)
4065 printf (" %u\n", ptr->cs_buf[k]);
4072 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4074 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4076 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4086 for (uint j
= 1; j
< CHARSIZ
; j
++)
4096 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4098 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4100 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4102 out
+= CHARSIZ
* CHARSIZ
;
4103 in
+= CHARSIZ
* CHARSIZ
;
4105 for (uint j
= 0; j
< CHARSIZ
; j
++)
4112 for (uint k
= 1; k
< CHARSIZ
; k
++)
4124 * mixed shared functions
4127 void dump_hex (const u8
*s
, const int sz
)
4129 for (int i
= 0; i
< sz
; i
++)
4131 log_info_nn ("%02x ", s
[i
]);
4137 void usage_mini_print (const char *progname
)
4139 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4142 void usage_big_print (const char *progname
)
4144 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4147 char *get_exec_path ()
4149 int exec_path_len
= 1024;
4151 char *exec_path
= (char *) mymalloc (exec_path_len
);
4155 char tmp
[32] = { 0 };
4157 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4159 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4163 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4167 uint size
= exec_path_len
;
4169 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4171 log_error("! executable path buffer too small\n");
4176 const int len
= strlen (exec_path
);
4179 #error Your Operating System is not supported or detected
4187 char *get_install_dir (const char *progname
)
4189 char *install_dir
= mystrdup (progname
);
4190 char *last_slash
= NULL
;
4192 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4196 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4202 install_dir
[0] = '.';
4206 return (install_dir
);
4209 char *get_profile_dir (const char *homedir
)
4211 #define DOT_HASHCAT ".hashcat"
4213 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4215 char *profile_dir
= (char *) mymalloc (len
+ 1);
4217 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4222 char *get_session_dir (const char *profile_dir
)
4224 #define SESSIONS_FOLDER "sessions"
4226 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4228 char *session_dir
= (char *) mymalloc (len
+ 1);
4230 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4235 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4239 FILE *fd
= fopen (filename
, "rb");
4243 log_error ("%s: %s", filename
, strerror (errno
));
4248 #define MAX_KEY_SIZE (1024 * 1024)
4250 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4252 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4258 for (int fpos
= 0; fpos
< nread
; fpos
++)
4260 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4262 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4263 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4264 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4265 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4267 if (kpos
>= 64) kpos
= 0;
4273 void set_cpu_affinity (char *cpu_affinity
)
4276 DWORD_PTR aff_mask
= 0;
4284 char *devices
= strdup (cpu_affinity
);
4286 char *next
= strtok (devices
, ",");
4290 uint cpu_id
= atoi (next
);
4305 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4311 aff_mask
|= 1 << (cpu_id
- 1);
4313 CPU_SET ((cpu_id
- 1), &cpuset
);
4316 } while ((next
= strtok (NULL
, ",")) != NULL
);
4322 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4323 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4325 pthread_t thread
= pthread_self ();
4326 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4330 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4332 char *element
, *end
;
4334 end
= (char *) base
+ nmemb
* size
;
4336 for (element
= (char *) base
; element
< end
; element
+= size
)
4337 if (!compar (element
, key
))
4343 int sort_by_salt (const void *v1
, const void *v2
)
4345 const salt_t
*s1
= (const salt_t
*) v1
;
4346 const salt_t
*s2
= (const salt_t
*) v2
;
4348 const int res1
= s1
->salt_len
- s2
->salt_len
;
4350 if (res1
!= 0) return (res1
);
4352 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4354 if (res2
!= 0) return (res2
);
4362 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4363 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4370 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4371 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4377 int sort_by_salt_buf (const void *v1
, const void *v2
)
4379 const pot_t
*p1
= (const pot_t
*) v1
;
4380 const pot_t
*p2
= (const pot_t
*) v2
;
4382 const hash_t
*h1
= &p1
->hash
;
4383 const hash_t
*h2
= &p2
->hash
;
4385 const salt_t
*s1
= h1
->salt
;
4386 const salt_t
*s2
= h2
->salt
;
4392 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4393 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4399 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4401 const hash_t
*h1
= (const hash_t
*) v1
;
4402 const hash_t
*h2
= (const hash_t
*) v2
;
4404 const salt_t
*s1
= h1
->salt
;
4405 const salt_t
*s2
= h2
->salt
;
4407 // testphase: this should work
4412 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4413 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4416 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4417 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4418 if (s1->salt_len > s2->salt_len) return ( 1);
4419 if (s1->salt_len < s2->salt_len) return (-1);
4421 uint n = s1->salt_len;
4425 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4426 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4433 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4435 const hash_t
*h1
= (const hash_t
*) v1
;
4436 const hash_t
*h2
= (const hash_t
*) v2
;
4438 const salt_t
*s1
= h1
->salt
;
4439 const salt_t
*s2
= h2
->salt
;
4441 // 12 - 2 (since last 2 uints contain the digest)
4446 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4447 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4453 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4455 const hash_t
*h1
= (const hash_t
*) v1
;
4456 const hash_t
*h2
= (const hash_t
*) v2
;
4458 const void *d1
= h1
->digest
;
4459 const void *d2
= h2
->digest
;
4461 return data
.sort_by_digest (d1
, d2
);
4464 int sort_by_hash (const void *v1
, const void *v2
)
4466 const hash_t
*h1
= (const hash_t
*) v1
;
4467 const hash_t
*h2
= (const hash_t
*) v2
;
4471 const salt_t
*s1
= h1
->salt
;
4472 const salt_t
*s2
= h2
->salt
;
4474 int res
= sort_by_salt (s1
, s2
);
4476 if (res
!= 0) return (res
);
4479 const void *d1
= h1
->digest
;
4480 const void *d2
= h2
->digest
;
4482 return data
.sort_by_digest (d1
, d2
);
4485 int sort_by_pot (const void *v1
, const void *v2
)
4487 const pot_t
*p1
= (const pot_t
*) v1
;
4488 const pot_t
*p2
= (const pot_t
*) v2
;
4490 const hash_t
*h1
= &p1
->hash
;
4491 const hash_t
*h2
= &p2
->hash
;
4493 return sort_by_hash (h1
, h2
);
4496 int sort_by_mtime (const void *p1
, const void *p2
)
4498 const char **f1
= (const char **) p1
;
4499 const char **f2
= (const char **) p2
;
4501 struct stat s1
; stat (*f1
, &s1
);
4502 struct stat s2
; stat (*f2
, &s2
);
4504 return s2
.st_mtime
- s1
.st_mtime
;
4507 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4509 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4510 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4512 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4515 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4517 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4518 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4520 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4523 int sort_by_stringptr (const void *p1
, const void *p2
)
4525 const char **s1
= (const char **) p1
;
4526 const char **s2
= (const char **) p2
;
4528 return strcmp (*s1
, *s2
);
4531 int sort_by_dictstat (const void *s1
, const void *s2
)
4533 dictstat_t
*d1
= (dictstat_t
*) s1
;
4534 dictstat_t
*d2
= (dictstat_t
*) s2
;
4537 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4539 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4542 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4545 int sort_by_bitmap (const void *p1
, const void *p2
)
4547 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4548 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4550 return b1
->collisions
- b2
->collisions
;
4553 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4555 const u32
*d1
= (const u32
*) v1
;
4556 const u32
*d2
= (const u32
*) v2
;
4562 if (d1
[n
] > d2
[n
]) return ( 1);
4563 if (d1
[n
] < d2
[n
]) return (-1);
4569 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4571 const u32
*d1
= (const u32
*) v1
;
4572 const u32
*d2
= (const u32
*) v2
;
4578 if (d1
[n
] > d2
[n
]) return ( 1);
4579 if (d1
[n
] < d2
[n
]) return (-1);
4585 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4587 const u32
*d1
= (const u32
*) v1
;
4588 const u32
*d2
= (const u32
*) v2
;
4594 if (d1
[n
] > d2
[n
]) return ( 1);
4595 if (d1
[n
] < d2
[n
]) return (-1);
4601 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4603 const u32
*d1
= (const u32
*) v1
;
4604 const u32
*d2
= (const u32
*) v2
;
4610 if (d1
[n
] > d2
[n
]) return ( 1);
4611 if (d1
[n
] < d2
[n
]) return (-1);
4617 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4619 const u32
*d1
= (const u32
*) v1
;
4620 const u32
*d2
= (const u32
*) v2
;
4626 if (d1
[n
] > d2
[n
]) return ( 1);
4627 if (d1
[n
] < d2
[n
]) return (-1);
4633 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4635 const u32
*d1
= (const u32
*) v1
;
4636 const u32
*d2
= (const u32
*) v2
;
4642 if (d1
[n
] > d2
[n
]) return ( 1);
4643 if (d1
[n
] < d2
[n
]) return (-1);
4649 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4651 const u32
*d1
= (const u32
*) v1
;
4652 const u32
*d2
= (const u32
*) v2
;
4658 if (d1
[n
] > d2
[n
]) return ( 1);
4659 if (d1
[n
] < d2
[n
]) return (-1);
4665 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4667 const u32
*d1
= (const u32
*) v1
;
4668 const u32
*d2
= (const u32
*) v2
;
4674 if (d1
[n
] > d2
[n
]) return ( 1);
4675 if (d1
[n
] < d2
[n
]) return (-1);
4681 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4683 const u64
*d1
= (const u64
*) v1
;
4684 const u64
*d2
= (const u64
*) v2
;
4690 if (d1
[n
] > d2
[n
]) return ( 1);
4691 if (d1
[n
] < d2
[n
]) return (-1);
4697 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4699 const u64
*d1
= (const u64
*) v1
;
4700 const u64
*d2
= (const u64
*) v2
;
4706 if (d1
[n
] > d2
[n
]) return ( 1);
4707 if (d1
[n
] < d2
[n
]) return (-1);
4713 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4715 const u64
*d1
= (const u64
*) v1
;
4716 const u64
*d2
= (const u64
*) v2
;
4722 if (d1
[n
] > d2
[n
]) return ( 1);
4723 if (d1
[n
] < d2
[n
]) return (-1);
4729 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4731 const u32
*d1
= (const u32
*) v1
;
4732 const u32
*d2
= (const u32
*) v2
;
4734 const uint dgst_pos0
= data
.dgst_pos0
;
4735 const uint dgst_pos1
= data
.dgst_pos1
;
4736 const uint dgst_pos2
= data
.dgst_pos2
;
4737 const uint dgst_pos3
= data
.dgst_pos3
;
4739 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4740 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4741 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4742 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4743 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4744 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4745 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4746 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4751 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
)
4753 uint outfile_autohex
= data
.outfile_autohex
;
4755 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4757 FILE *debug_fp
= NULL
;
4759 if (debug_file
!= NULL
)
4761 debug_fp
= fopen (debug_file
, "ab");
4763 lock_file (debug_fp
);
4770 if (debug_fp
== NULL
)
4772 log_info ("WARNING: Could not open debug-file for writing");
4776 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4778 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4780 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4783 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4785 if (debug_mode
== 4)
4787 fputc (':', debug_fp
);
4789 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4792 fputc ('\n', debug_fp
);
4794 if (debug_file
!= NULL
) fclose (debug_fp
);
4798 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4800 int needs_hexify
= 0;
4802 if (outfile_autohex
== 1)
4804 for (uint i
= 0; i
< plain_len
; i
++)
4806 if (plain_ptr
[i
] < 0x20)
4813 if (plain_ptr
[i
] > 0x7f)
4822 if (needs_hexify
== 1)
4824 fprintf (fp
, "$HEX[");
4826 for (uint i
= 0; i
< plain_len
; i
++)
4828 fprintf (fp
, "%02x", plain_ptr
[i
]);
4835 fwrite (plain_ptr
, plain_len
, 1, fp
);
4839 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
)
4841 uint outfile_format
= data
.outfile_format
;
4843 char separator
= data
.separator
;
4845 if (outfile_format
& OUTFILE_FMT_HASH
)
4847 fprintf (out_fp
, "%s", out_buf
);
4849 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4851 fputc (separator
, out_fp
);
4854 else if (data
.username
)
4856 if (username
!= NULL
)
4858 for (uint i
= 0; i
< user_len
; i
++)
4860 fprintf (out_fp
, "%c", username
[i
]);
4863 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4865 fputc (separator
, out_fp
);
4870 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4872 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4874 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4876 fputc (separator
, out_fp
);
4880 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4882 for (uint i
= 0; i
< plain_len
; i
++)
4884 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4887 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4889 fputc (separator
, out_fp
);
4893 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4896 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4901 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4903 fprintf (out_fp
, "%llu", crackpos
);
4908 fputc ('\n', out_fp
);
4911 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
)
4915 pot_key
.hash
.salt
= hashes_buf
->salt
;
4916 pot_key
.hash
.digest
= hashes_buf
->digest
;
4918 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4924 input_buf
[input_len
] = 0;
4927 unsigned char *username
= NULL
;
4932 user_t
*user
= hashes_buf
->hash_info
->user
;
4936 username
= (unsigned char *) (user
->user_name
);
4938 user_len
= user
->user_len
;
4942 // do output the line
4943 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4947 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4948 #define LM_MASKED_PLAIN "[notfound]"
4950 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
)
4956 pot_left_key
.hash
.salt
= hash_left
->salt
;
4957 pot_left_key
.hash
.digest
= hash_left
->digest
;
4959 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4963 uint weak_hash_found
= 0;
4965 pot_t pot_right_key
;
4967 pot_right_key
.hash
.salt
= hash_right
->salt
;
4968 pot_right_key
.hash
.digest
= hash_right
->digest
;
4970 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4972 if (pot_right_ptr
== NULL
)
4974 // special case, if "weak hash"
4976 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4978 weak_hash_found
= 1;
4980 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4982 // in theory this is not needed, but we are paranoia:
4984 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4985 pot_right_ptr
->plain_len
= 0;
4989 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4991 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
4996 // at least one half was found:
5000 input_buf
[input_len
] = 0;
5004 unsigned char *username
= NULL
;
5009 user_t
*user
= hash_left
->hash_info
->user
;
5013 username
= (unsigned char *) (user
->user_name
);
5015 user_len
= user
->user_len
;
5019 // mask the part which was not found
5021 uint left_part_masked
= 0;
5022 uint right_part_masked
= 0;
5024 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5026 if (pot_left_ptr
== NULL
)
5028 left_part_masked
= 1;
5030 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5032 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5034 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5035 pot_left_ptr
->plain_len
= mask_plain_len
;
5038 if (pot_right_ptr
== NULL
)
5040 right_part_masked
= 1;
5042 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5044 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5046 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5047 pot_right_ptr
->plain_len
= mask_plain_len
;
5050 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5054 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5056 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5058 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5060 // do output the line
5062 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5064 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5066 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5067 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5070 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
)
5074 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5076 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5078 if (pot_ptr
== NULL
)
5082 input_buf
[input_len
] = 0;
5084 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5088 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
)
5094 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5096 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5100 pot_t pot_right_key
;
5102 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5104 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5106 uint weak_hash_found
= 0;
5108 if (pot_right_ptr
== NULL
)
5110 // special case, if "weak hash"
5112 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5114 weak_hash_found
= 1;
5116 // we just need that pot_right_ptr is not a NULL pointer
5118 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5122 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5124 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5129 // ... at least one part was not cracked
5133 input_buf
[input_len
] = 0;
5135 // only show the hash part which is still not cracked
5137 uint user_len
= input_len
- 32;
5139 char *hash_output
= (char *) mymalloc (33);
5141 memcpy (hash_output
, input_buf
, input_len
);
5143 if (pot_left_ptr
!= NULL
)
5145 // only show right part (because left part was already found)
5147 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5149 hash_output
[user_len
+ 16] = 0;
5152 if (pot_right_ptr
!= NULL
)
5154 // only show left part (because right part was already found)
5156 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5158 hash_output
[user_len
+ 16] = 0;
5161 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5163 myfree (hash_output
);
5165 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5168 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5170 uint opencl_platforms_filter
= 0;
5172 if (opencl_platforms
)
5174 char *platforms
= strdup (opencl_platforms
);
5176 char *next
= strtok (platforms
, ",");
5180 int platform
= atoi (next
);
5182 if (platform
< 1 || platform
> 32)
5184 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5189 opencl_platforms_filter
|= 1 << (platform
- 1);
5191 } while ((next
= strtok (NULL
, ",")) != NULL
);
5197 opencl_platforms_filter
= -1;
5200 return opencl_platforms_filter
;
5203 u32
setup_devices_filter (char *opencl_devices
)
5205 u32 devices_filter
= 0;
5209 char *devices
= strdup (opencl_devices
);
5211 char *next
= strtok (devices
, ",");
5215 int device_id
= atoi (next
);
5217 if (device_id
< 1 || device_id
> 32)
5219 log_error ("ERROR: invalid device_id %u specified", device_id
);
5224 devices_filter
|= 1 << (device_id
- 1);
5226 } while ((next
= strtok (NULL
, ",")) != NULL
);
5232 devices_filter
= -1;
5235 return devices_filter
;
5238 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5240 cl_device_type device_types_filter
= 0;
5242 if (opencl_device_types
)
5244 char *device_types
= strdup (opencl_device_types
);
5246 char *next
= strtok (device_types
, ",");
5250 int device_type
= atoi (next
);
5252 if (device_type
< 1 || device_type
> 3)
5254 log_error ("ERROR: invalid device_type %u specified", device_type
);
5259 device_types_filter
|= 1 << device_type
;
5261 } while ((next
= strtok (NULL
, ",")) != NULL
);
5263 free (device_types
);
5267 // Do not use CPU by default, this often reduces GPU performance because
5268 // the CPU is too busy to handle GPU synchronization
5270 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5273 return device_types_filter
;
5276 u32
get_random_num (const u32 min
, const u32 max
)
5278 if (min
== max
) return (min
);
5280 return ((rand () % (max
- min
)) + min
);
5283 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5285 u32 quotient
= dividend
/ divisor
;
5287 if (dividend
% divisor
) quotient
++;
5292 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5294 u64 quotient
= dividend
/ divisor
;
5296 if (dividend
% divisor
) quotient
++;
5301 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5303 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5304 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5306 if (tm
->tm_year
- 70)
5308 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5309 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5311 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5313 else if (tm
->tm_yday
)
5315 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5316 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5318 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5320 else if (tm
->tm_hour
)
5322 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5323 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5325 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5327 else if (tm
->tm_min
)
5329 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5330 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5332 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5336 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5338 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5342 void format_speed_display (float val
, char *buf
, size_t len
)
5353 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5364 /* generate output */
5368 snprintf (buf
, len
- 1, "%.0f ", val
);
5372 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5376 void lowercase (u8
*buf
, int len
)
5378 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5381 void uppercase (u8
*buf
, int len
)
5383 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5386 int fgetl (FILE *fp
, char *line_buf
)
5392 const int c
= fgetc (fp
);
5394 if (c
== EOF
) break;
5396 line_buf
[line_len
] = (char) c
;
5400 if (line_len
== BUFSIZ
) line_len
--;
5402 if (c
== '\n') break;
5405 if (line_len
== 0) return 0;
5407 if (line_buf
[line_len
- 1] == '\n')
5411 line_buf
[line_len
] = 0;
5414 if (line_len
== 0) return 0;
5416 if (line_buf
[line_len
- 1] == '\r')
5420 line_buf
[line_len
] = 0;
5426 int in_superchop (char *buf
)
5428 int len
= strlen (buf
);
5432 if (buf
[len
- 1] == '\n')
5439 if (buf
[len
- 1] == '\r')
5454 char **scan_directory (const char *path
)
5456 char *tmp_path
= mystrdup (path
);
5458 size_t tmp_path_len
= strlen (tmp_path
);
5460 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5462 tmp_path
[tmp_path_len
- 1] = 0;
5464 tmp_path_len
= strlen (tmp_path
);
5467 char **files
= NULL
;
5473 if ((d
= opendir (tmp_path
)) != NULL
)
5479 memset (&e
, 0, sizeof (e
));
5480 struct dirent
*de
= NULL
;
5482 if (readdir_r (d
, &e
, &de
) != 0)
5484 log_error ("ERROR: readdir_r() failed");
5489 if (de
== NULL
) break;
5493 while ((de
= readdir (d
)) != NULL
)
5496 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5498 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5500 char *path_file
= (char *) mymalloc (path_size
+ 1);
5502 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5504 path_file
[path_size
] = 0;
5508 if ((d_test
= opendir (path_file
)) != NULL
)
5516 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5520 files
[num_files
- 1] = path_file
;
5526 else if (errno
== ENOTDIR
)
5528 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5532 files
[num_files
- 1] = mystrdup (path
);
5535 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5539 files
[num_files
- 1] = NULL
;
5546 int count_dictionaries (char **dictionary_files
)
5548 if (dictionary_files
== NULL
) return 0;
5552 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5560 char *stroptitype (const uint opti_type
)
5564 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5565 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5566 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5567 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5568 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5569 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5570 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5571 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5572 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5573 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5574 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5575 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5576 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5577 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5583 char *strparser (const uint parser_status
)
5585 switch (parser_status
)
5587 case PARSER_OK
: return ((char *) PA_000
); break;
5588 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5589 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5590 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5591 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5592 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5593 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5594 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5595 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5596 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5597 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5598 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5599 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5600 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5601 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5602 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5603 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5606 return ((char *) PA_255
);
5609 char *strhashtype (const uint hash_mode
)
5613 case 0: return ((char *) HT_00000
); break;
5614 case 10: return ((char *) HT_00010
); break;
5615 case 11: return ((char *) HT_00011
); break;
5616 case 12: return ((char *) HT_00012
); break;
5617 case 20: return ((char *) HT_00020
); break;
5618 case 21: return ((char *) HT_00021
); break;
5619 case 22: return ((char *) HT_00022
); break;
5620 case 23: return ((char *) HT_00023
); break;
5621 case 30: return ((char *) HT_00030
); break;
5622 case 40: return ((char *) HT_00040
); break;
5623 case 50: return ((char *) HT_00050
); break;
5624 case 60: return ((char *) HT_00060
); break;
5625 case 100: return ((char *) HT_00100
); break;
5626 case 101: return ((char *) HT_00101
); break;
5627 case 110: return ((char *) HT_00110
); break;
5628 case 111: return ((char *) HT_00111
); break;
5629 case 112: return ((char *) HT_00112
); break;
5630 case 120: return ((char *) HT_00120
); break;
5631 case 121: return ((char *) HT_00121
); break;
5632 case 122: return ((char *) HT_00122
); break;
5633 case 124: return ((char *) HT_00124
); break;
5634 case 130: return ((char *) HT_00130
); break;
5635 case 131: return ((char *) HT_00131
); break;
5636 case 132: return ((char *) HT_00132
); break;
5637 case 133: return ((char *) HT_00133
); break;
5638 case 140: return ((char *) HT_00140
); break;
5639 case 141: return ((char *) HT_00141
); break;
5640 case 150: return ((char *) HT_00150
); break;
5641 case 160: return ((char *) HT_00160
); break;
5642 case 190: return ((char *) HT_00190
); break;
5643 case 200: return ((char *) HT_00200
); break;
5644 case 300: return ((char *) HT_00300
); break;
5645 case 400: return ((char *) HT_00400
); break;
5646 case 500: return ((char *) HT_00500
); break;
5647 case 501: return ((char *) HT_00501
); break;
5648 case 900: return ((char *) HT_00900
); break;
5649 case 910: return ((char *) HT_00910
); break;
5650 case 1000: return ((char *) HT_01000
); break;
5651 case 1100: return ((char *) HT_01100
); break;
5652 case 1400: return ((char *) HT_01400
); break;
5653 case 1410: return ((char *) HT_01410
); break;
5654 case 1420: return ((char *) HT_01420
); break;
5655 case 1421: return ((char *) HT_01421
); break;
5656 case 1430: return ((char *) HT_01430
); break;
5657 case 1440: return ((char *) HT_01440
); break;
5658 case 1441: return ((char *) HT_01441
); break;
5659 case 1450: return ((char *) HT_01450
); break;
5660 case 1460: return ((char *) HT_01460
); break;
5661 case 1500: return ((char *) HT_01500
); break;
5662 case 1600: return ((char *) HT_01600
); break;
5663 case 1700: return ((char *) HT_01700
); break;
5664 case 1710: return ((char *) HT_01710
); break;
5665 case 1711: return ((char *) HT_01711
); break;
5666 case 1720: return ((char *) HT_01720
); break;
5667 case 1722: return ((char *) HT_01722
); break;
5668 case 1730: return ((char *) HT_01730
); break;
5669 case 1731: return ((char *) HT_01731
); break;
5670 case 1740: return ((char *) HT_01740
); break;
5671 case 1750: return ((char *) HT_01750
); break;
5672 case 1760: return ((char *) HT_01760
); break;
5673 case 1800: return ((char *) HT_01800
); break;
5674 case 2100: return ((char *) HT_02100
); break;
5675 case 2400: return ((char *) HT_02400
); break;
5676 case 2410: return ((char *) HT_02410
); break;
5677 case 2500: return ((char *) HT_02500
); break;
5678 case 2600: return ((char *) HT_02600
); break;
5679 case 2611: return ((char *) HT_02611
); break;
5680 case 2612: return ((char *) HT_02612
); break;
5681 case 2711: return ((char *) HT_02711
); break;
5682 case 2811: return ((char *) HT_02811
); break;
5683 case 3000: return ((char *) HT_03000
); break;
5684 case 3100: return ((char *) HT_03100
); break;
5685 case 3200: return ((char *) HT_03200
); break;
5686 case 3710: return ((char *) HT_03710
); break;
5687 case 3711: return ((char *) HT_03711
); break;
5688 case 3800: return ((char *) HT_03800
); break;
5689 case 4300: return ((char *) HT_04300
); break;
5690 case 4400: return ((char *) HT_04400
); break;
5691 case 4500: return ((char *) HT_04500
); break;
5692 case 4700: return ((char *) HT_04700
); break;
5693 case 4800: return ((char *) HT_04800
); break;
5694 case 4900: return ((char *) HT_04900
); break;
5695 case 5000: return ((char *) HT_05000
); break;
5696 case 5100: return ((char *) HT_05100
); break;
5697 case 5200: return ((char *) HT_05200
); break;
5698 case 5300: return ((char *) HT_05300
); break;
5699 case 5400: return ((char *) HT_05400
); break;
5700 case 5500: return ((char *) HT_05500
); break;
5701 case 5600: return ((char *) HT_05600
); break;
5702 case 5700: return ((char *) HT_05700
); break;
5703 case 5800: return ((char *) HT_05800
); break;
5704 case 6000: return ((char *) HT_06000
); break;
5705 case 6100: return ((char *) HT_06100
); break;
5706 case 6211: return ((char *) HT_06211
); break;
5707 case 6212: return ((char *) HT_06212
); break;
5708 case 6213: return ((char *) HT_06213
); break;
5709 case 6221: return ((char *) HT_06221
); break;
5710 case 6222: return ((char *) HT_06222
); break;
5711 case 6223: return ((char *) HT_06223
); break;
5712 case 6231: return ((char *) HT_06231
); break;
5713 case 6232: return ((char *) HT_06232
); break;
5714 case 6233: return ((char *) HT_06233
); break;
5715 case 6241: return ((char *) HT_06241
); break;
5716 case 6242: return ((char *) HT_06242
); break;
5717 case 6243: return ((char *) HT_06243
); break;
5718 case 6300: return ((char *) HT_06300
); break;
5719 case 6400: return ((char *) HT_06400
); break;
5720 case 6500: return ((char *) HT_06500
); break;
5721 case 6600: return ((char *) HT_06600
); break;
5722 case 6700: return ((char *) HT_06700
); break;
5723 case 6800: return ((char *) HT_06800
); break;
5724 case 6900: return ((char *) HT_06900
); break;
5725 case 7100: return ((char *) HT_07100
); break;
5726 case 7200: return ((char *) HT_07200
); break;
5727 case 7300: return ((char *) HT_07300
); break;
5728 case 7400: return ((char *) HT_07400
); break;
5729 case 7500: return ((char *) HT_07500
); break;
5730 case 7600: return ((char *) HT_07600
); break;
5731 case 7700: return ((char *) HT_07700
); break;
5732 case 7800: return ((char *) HT_07800
); break;
5733 case 7900: return ((char *) HT_07900
); break;
5734 case 8000: return ((char *) HT_08000
); break;
5735 case 8100: return ((char *) HT_08100
); break;
5736 case 8200: return ((char *) HT_08200
); break;
5737 case 8300: return ((char *) HT_08300
); break;
5738 case 8400: return ((char *) HT_08400
); break;
5739 case 8500: return ((char *) HT_08500
); break;
5740 case 8600: return ((char *) HT_08600
); break;
5741 case 8700: return ((char *) HT_08700
); break;
5742 case 8800: return ((char *) HT_08800
); break;
5743 case 8900: return ((char *) HT_08900
); break;
5744 case 9000: return ((char *) HT_09000
); break;
5745 case 9100: return ((char *) HT_09100
); break;
5746 case 9200: return ((char *) HT_09200
); break;
5747 case 9300: return ((char *) HT_09300
); break;
5748 case 9400: return ((char *) HT_09400
); break;
5749 case 9500: return ((char *) HT_09500
); break;
5750 case 9600: return ((char *) HT_09600
); break;
5751 case 9700: return ((char *) HT_09700
); break;
5752 case 9710: return ((char *) HT_09710
); break;
5753 case 9720: return ((char *) HT_09720
); break;
5754 case 9800: return ((char *) HT_09800
); break;
5755 case 9810: return ((char *) HT_09810
); break;
5756 case 9820: return ((char *) HT_09820
); break;
5757 case 9900: return ((char *) HT_09900
); break;
5758 case 10000: return ((char *) HT_10000
); break;
5759 case 10100: return ((char *) HT_10100
); break;
5760 case 10200: return ((char *) HT_10200
); break;
5761 case 10300: return ((char *) HT_10300
); break;
5762 case 10400: return ((char *) HT_10400
); break;
5763 case 10410: return ((char *) HT_10410
); break;
5764 case 10420: return ((char *) HT_10420
); break;
5765 case 10500: return ((char *) HT_10500
); break;
5766 case 10600: return ((char *) HT_10600
); break;
5767 case 10700: return ((char *) HT_10700
); break;
5768 case 10800: return ((char *) HT_10800
); break;
5769 case 10900: return ((char *) HT_10900
); break;
5770 case 11000: return ((char *) HT_11000
); break;
5771 case 11100: return ((char *) HT_11100
); break;
5772 case 11200: return ((char *) HT_11200
); break;
5773 case 11300: return ((char *) HT_11300
); break;
5774 case 11400: return ((char *) HT_11400
); break;
5775 case 11500: return ((char *) HT_11500
); break;
5776 case 11600: return ((char *) HT_11600
); break;
5777 case 11700: return ((char *) HT_11700
); break;
5778 case 11800: return ((char *) HT_11800
); break;
5779 case 11900: return ((char *) HT_11900
); break;
5780 case 12000: return ((char *) HT_12000
); break;
5781 case 12100: return ((char *) HT_12100
); break;
5782 case 12200: return ((char *) HT_12200
); break;
5783 case 12300: return ((char *) HT_12300
); break;
5784 case 12400: return ((char *) HT_12400
); break;
5785 case 12500: return ((char *) HT_12500
); break;
5786 case 12600: return ((char *) HT_12600
); break;
5787 case 12700: return ((char *) HT_12700
); break;
5788 case 12800: return ((char *) HT_12800
); break;
5789 case 12900: return ((char *) HT_12900
); break;
5790 case 13000: return ((char *) HT_13000
); break;
5793 return ((char *) "Unknown");
5796 char *strstatus (const uint devices_status
)
5798 switch (devices_status
)
5800 case STATUS_INIT
: return ((char *) ST_0000
); break;
5801 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5802 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5803 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5804 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5805 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5806 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5807 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5808 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5809 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5812 return ((char *) "Unknown");
5815 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5817 uint hash_type
= data
.hash_type
;
5818 uint hash_mode
= data
.hash_mode
;
5819 uint salt_type
= data
.salt_type
;
5820 uint opts_type
= data
.opts_type
;
5821 uint opti_type
= data
.opti_type
;
5822 uint dgst_size
= data
.dgst_size
;
5824 char *hashfile
= data
.hashfile
;
5828 uint digest_buf
[64] = { 0 };
5830 u64
*digest_buf64
= (u64
*) digest_buf
;
5832 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5834 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5836 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5842 case HASH_TYPE_DESCRYPT
:
5843 FP (digest_buf
[1], digest_buf
[0], tt
);
5846 case HASH_TYPE_DESRACF
:
5847 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5848 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5850 FP (digest_buf
[1], digest_buf
[0], tt
);
5854 FP (digest_buf
[1], digest_buf
[0], tt
);
5857 case HASH_TYPE_NETNTLM
:
5858 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5859 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5860 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5861 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5863 FP (digest_buf
[1], digest_buf
[0], tt
);
5864 FP (digest_buf
[3], digest_buf
[2], tt
);
5867 case HASH_TYPE_BSDICRYPT
:
5868 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5869 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5871 FP (digest_buf
[1], digest_buf
[0], tt
);
5876 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5881 digest_buf
[0] += MD4M_A
;
5882 digest_buf
[1] += MD4M_B
;
5883 digest_buf
[2] += MD4M_C
;
5884 digest_buf
[3] += MD4M_D
;
5888 digest_buf
[0] += MD5M_A
;
5889 digest_buf
[1] += MD5M_B
;
5890 digest_buf
[2] += MD5M_C
;
5891 digest_buf
[3] += MD5M_D
;
5894 case HASH_TYPE_SHA1
:
5895 digest_buf
[0] += SHA1M_A
;
5896 digest_buf
[1] += SHA1M_B
;
5897 digest_buf
[2] += SHA1M_C
;
5898 digest_buf
[3] += SHA1M_D
;
5899 digest_buf
[4] += SHA1M_E
;
5902 case HASH_TYPE_SHA256
:
5903 digest_buf
[0] += SHA256M_A
;
5904 digest_buf
[1] += SHA256M_B
;
5905 digest_buf
[2] += SHA256M_C
;
5906 digest_buf
[3] += SHA256M_D
;
5907 digest_buf
[4] += SHA256M_E
;
5908 digest_buf
[5] += SHA256M_F
;
5909 digest_buf
[6] += SHA256M_G
;
5910 digest_buf
[7] += SHA256M_H
;
5913 case HASH_TYPE_SHA384
:
5914 digest_buf64
[0] += SHA384M_A
;
5915 digest_buf64
[1] += SHA384M_B
;
5916 digest_buf64
[2] += SHA384M_C
;
5917 digest_buf64
[3] += SHA384M_D
;
5918 digest_buf64
[4] += SHA384M_E
;
5919 digest_buf64
[5] += SHA384M_F
;
5920 digest_buf64
[6] += 0;
5921 digest_buf64
[7] += 0;
5924 case HASH_TYPE_SHA512
:
5925 digest_buf64
[0] += SHA512M_A
;
5926 digest_buf64
[1] += SHA512M_B
;
5927 digest_buf64
[2] += SHA512M_C
;
5928 digest_buf64
[3] += SHA512M_D
;
5929 digest_buf64
[4] += SHA512M_E
;
5930 digest_buf64
[5] += SHA512M_F
;
5931 digest_buf64
[6] += SHA512M_G
;
5932 digest_buf64
[7] += SHA512M_H
;
5937 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5939 if (dgst_size
== DGST_SIZE_4_2
)
5941 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5943 else if (dgst_size
== DGST_SIZE_4_4
)
5945 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5947 else if (dgst_size
== DGST_SIZE_4_5
)
5949 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5951 else if (dgst_size
== DGST_SIZE_4_6
)
5953 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5955 else if (dgst_size
== DGST_SIZE_4_8
)
5957 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5959 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5961 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5963 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5965 else if (hash_type
== HASH_TYPE_SHA384
)
5967 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5969 else if (hash_type
== HASH_TYPE_SHA512
)
5971 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5973 else if (hash_type
== HASH_TYPE_GOST
)
5975 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5978 else if (dgst_size
== DGST_SIZE_4_64
)
5980 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5982 else if (dgst_size
== DGST_SIZE_8_25
)
5984 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5988 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5989 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5990 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5996 memset (&salt
, 0, sizeof (salt_t
));
5998 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6000 char *ptr
= (char *) salt
.salt_buf
;
6002 uint len
= salt
.salt_len
;
6004 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6010 case HASH_TYPE_NETNTLM
:
6012 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6013 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6015 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6021 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6023 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6031 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6033 uint max
= salt
.salt_len
/ 4;
6037 for (uint i
= 0; i
< max
; i
++)
6039 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6043 if (opts_type
& OPTS_TYPE_ST_HEX
)
6045 char tmp
[64] = { 0 };
6047 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6049 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6054 memcpy (ptr
, tmp
, len
);
6057 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6059 memset (ptr
+ len
, 0, memset_size
);
6061 salt
.salt_len
= len
;
6065 // some modes require special encoding
6068 uint out_buf_plain
[256] = { 0 };
6069 uint out_buf_salt
[256] = { 0 };
6071 char tmp_buf
[1024] = { 0 };
6073 char *ptr_plain
= (char *) out_buf_plain
;
6074 char *ptr_salt
= (char *) out_buf_salt
;
6076 if (hash_mode
== 22)
6078 char username
[30] = { 0 };
6080 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6082 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6084 u16
*ptr
= (u16
*) digest_buf
;
6086 tmp_buf
[ 0] = sig
[0];
6087 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6088 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6089 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6090 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6091 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6092 tmp_buf
[ 6] = sig
[1];
6093 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6094 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6095 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6096 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6097 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6098 tmp_buf
[12] = sig
[2];
6099 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6100 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6101 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6102 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6103 tmp_buf
[17] = sig
[3];
6104 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6105 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6106 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6107 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6108 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6109 tmp_buf
[23] = sig
[4];
6110 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6111 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6112 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6113 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6114 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6115 tmp_buf
[29] = sig
[5];
6117 snprintf (out_buf
, len
-1, "%s:%s",
6121 else if (hash_mode
== 23)
6123 // do not show the \nskyper\n part in output
6125 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6127 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6129 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6136 else if (hash_mode
== 101)
6138 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6140 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6141 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6142 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6143 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6144 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6146 memcpy (tmp_buf
, digest_buf
, 20);
6148 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6150 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6152 else if (hash_mode
== 111)
6154 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6156 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6157 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6158 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6159 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6160 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6162 memcpy (tmp_buf
, digest_buf
, 20);
6163 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6165 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6167 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6169 else if (hash_mode
== 122)
6171 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6172 (char *) salt
.salt_buf
,
6179 else if (hash_mode
== 124)
6181 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6182 (char *) salt
.salt_buf
,
6189 else if (hash_mode
== 131)
6191 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6192 (char *) salt
.salt_buf
,
6200 else if (hash_mode
== 132)
6202 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6203 (char *) salt
.salt_buf
,
6210 else if (hash_mode
== 133)
6212 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6214 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6215 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6216 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6217 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6218 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6220 memcpy (tmp_buf
, digest_buf
, 20);
6222 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6224 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6226 else if (hash_mode
== 141)
6228 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6230 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6232 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6234 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6236 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6237 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6238 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6239 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6240 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6242 memcpy (tmp_buf
, digest_buf
, 20);
6244 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6248 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6250 else if (hash_mode
== 400)
6252 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6254 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6255 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6256 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6257 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6259 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6261 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6263 else if (hash_mode
== 500)
6265 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6267 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6268 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6269 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6270 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6272 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6274 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6276 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6280 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6283 else if (hash_mode
== 501)
6285 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6287 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6288 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6290 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6292 else if (hash_mode
== 1421)
6294 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6296 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6312 else if (hash_mode
== 1441)
6314 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6316 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6318 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6320 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6322 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6323 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6324 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6325 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6326 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6327 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6328 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6329 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6331 memcpy (tmp_buf
, digest_buf
, 32);
6333 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6337 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6339 else if (hash_mode
== 1500)
6341 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6342 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6343 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6344 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6345 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6347 memset (tmp_buf
, 0, sizeof (tmp_buf
));
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]);
6354 memcpy (tmp_buf
, digest_buf
, 8);
6356 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6358 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6362 else if (hash_mode
== 1600)
6364 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6366 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6367 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6368 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6369 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6371 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6373 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6375 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6379 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6382 else if (hash_mode
== 1711)
6384 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6386 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6387 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6388 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6389 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6390 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6391 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6392 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6393 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6395 memcpy (tmp_buf
, digest_buf
, 64);
6396 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6398 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6400 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6402 else if (hash_mode
== 1722)
6404 uint
*ptr
= digest_buf
;
6406 snprintf (out_buf
, len
-1, "%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
== 1731)
6419 uint
*ptr
= digest_buf
;
6421 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6422 (unsigned char *) salt
.salt_buf
,
6432 else if (hash_mode
== 1800)
6436 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6437 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6438 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6439 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6440 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6441 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6442 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6443 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6445 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6447 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6449 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6453 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6456 else if (hash_mode
== 2100)
6460 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6462 salt
.salt_iter
+ 1);
6464 uint signature_len
= strlen (out_buf
);
6466 pos
+= signature_len
;
6467 len
-= signature_len
;
6469 char *salt_ptr
= (char *) salt
.salt_buf
;
6471 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6473 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6474 byte_swap_32 (digest_buf
[0]),
6475 byte_swap_32 (digest_buf
[1]),
6476 byte_swap_32 (digest_buf
[2]),
6477 byte_swap_32 (digest_buf
[3]));
6479 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6481 memcpy (tmp_buf
, digest_buf
, 16);
6483 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6485 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6486 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6487 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6488 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6490 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6491 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6492 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6493 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6495 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6496 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6497 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6498 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6500 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6501 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6502 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6503 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6505 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6506 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6507 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6508 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6512 else if (hash_mode
== 2500)
6514 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6516 wpa_t
*wpa
= &wpas
[salt_pos
];
6518 uint pke
[25] = { 0 };
6520 char *pke_ptr
= (char *) pke
;
6522 for (uint i
= 0; i
< 25; i
++)
6524 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6527 unsigned char mac1
[6] = { 0 };
6528 unsigned char mac2
[6] = { 0 };
6530 memcpy (mac1
, pke_ptr
+ 23, 6);
6531 memcpy (mac2
, pke_ptr
+ 29, 6);
6533 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6534 (char *) salt
.salt_buf
,
6548 else if (hash_mode
== 4400)
6550 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6551 byte_swap_32 (digest_buf
[0]),
6552 byte_swap_32 (digest_buf
[1]),
6553 byte_swap_32 (digest_buf
[2]),
6554 byte_swap_32 (digest_buf
[3]));
6556 else if (hash_mode
== 4700)
6558 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6559 byte_swap_32 (digest_buf
[0]),
6560 byte_swap_32 (digest_buf
[1]),
6561 byte_swap_32 (digest_buf
[2]),
6562 byte_swap_32 (digest_buf
[3]),
6563 byte_swap_32 (digest_buf
[4]));
6565 else if (hash_mode
== 4800)
6567 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6569 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6574 byte_swap_32 (salt
.salt_buf
[0]),
6575 byte_swap_32 (salt
.salt_buf
[1]),
6576 byte_swap_32 (salt
.salt_buf
[2]),
6577 byte_swap_32 (salt
.salt_buf
[3]),
6580 else if (hash_mode
== 4900)
6582 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6583 byte_swap_32 (digest_buf
[0]),
6584 byte_swap_32 (digest_buf
[1]),
6585 byte_swap_32 (digest_buf
[2]),
6586 byte_swap_32 (digest_buf
[3]),
6587 byte_swap_32 (digest_buf
[4]));
6589 else if (hash_mode
== 5100)
6591 snprintf (out_buf
, len
-1, "%08x%08x",
6595 else if (hash_mode
== 5200)
6597 snprintf (out_buf
, len
-1, "%s", hashfile
);
6599 else if (hash_mode
== 5300)
6601 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6603 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6605 int buf_len
= len
-1;
6609 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6611 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6613 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6615 snprintf (out_buf
, buf_len
, ":");
6621 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6629 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6631 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6633 if ((i
== 0) || (i
== 5))
6635 snprintf (out_buf
, buf_len
, ":");
6641 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6649 for (uint i
= 0; i
< 4; i
++)
6653 snprintf (out_buf
, buf_len
, ":");
6659 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6665 else if (hash_mode
== 5400)
6667 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6669 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6671 int buf_len
= len
-1;
6675 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6677 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6679 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6681 snprintf (out_buf
, buf_len
, ":");
6687 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6695 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6697 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6699 if ((i
== 0) || (i
== 5))
6701 snprintf (out_buf
, buf_len
, ":");
6707 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6715 for (uint i
= 0; i
< 5; i
++)
6719 snprintf (out_buf
, buf_len
, ":");
6725 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6731 else if (hash_mode
== 5500)
6733 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6735 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6737 char user_buf
[64] = { 0 };
6738 char domain_buf
[64] = { 0 };
6739 char srvchall_buf
[1024] = { 0 };
6740 char clichall_buf
[1024] = { 0 };
6742 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6744 char *ptr
= (char *) netntlm
->userdomain_buf
;
6746 user_buf
[i
] = ptr
[j
];
6749 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6751 char *ptr
= (char *) netntlm
->userdomain_buf
;
6753 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6756 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6758 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6760 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6763 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6765 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6767 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6770 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6778 byte_swap_32 (salt
.salt_buf_pc
[0]),
6779 byte_swap_32 (salt
.salt_buf_pc
[1]),
6782 else if (hash_mode
== 5600)
6784 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6786 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6788 char user_buf
[64] = { 0 };
6789 char domain_buf
[64] = { 0 };
6790 char srvchall_buf
[1024] = { 0 };
6791 char clichall_buf
[1024] = { 0 };
6793 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6795 char *ptr
= (char *) netntlm
->userdomain_buf
;
6797 user_buf
[i
] = ptr
[j
];
6800 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6802 char *ptr
= (char *) netntlm
->userdomain_buf
;
6804 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6807 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6809 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6811 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6814 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6816 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6818 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6821 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6831 else if (hash_mode
== 5700)
6833 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6835 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6836 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6837 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6838 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6839 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6840 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6841 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6842 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6844 memcpy (tmp_buf
, digest_buf
, 32);
6846 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6850 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6852 else if (hash_mode
== 5800)
6854 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6855 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6856 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6857 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6858 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6860 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6867 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6869 snprintf (out_buf
, len
-1, "%s", hashfile
);
6871 else if (hash_mode
== 6300)
6873 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6875 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6876 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6877 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6878 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6880 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6882 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6884 else if (hash_mode
== 6400)
6886 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6888 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6890 else if (hash_mode
== 6500)
6892 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6894 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6896 else if (hash_mode
== 6600)
6898 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6900 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6902 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6903 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6905 uint buf_len
= len
- 1;
6907 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6910 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6912 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6917 else if (hash_mode
== 6700)
6919 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6921 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6923 else if (hash_mode
== 6800)
6925 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6927 else if (hash_mode
== 7100)
6929 uint
*ptr
= digest_buf
;
6931 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6933 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6935 uint esalt
[8] = { 0 };
6937 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6938 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6939 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6940 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6941 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6942 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6943 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6944 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6946 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",
6947 SIGNATURE_SHA512OSX
,
6949 esalt
[ 0], esalt
[ 1],
6950 esalt
[ 2], esalt
[ 3],
6951 esalt
[ 4], esalt
[ 5],
6952 esalt
[ 6], esalt
[ 7],
6960 ptr
[15], ptr
[14]);
6962 else if (hash_mode
== 7200)
6964 uint
*ptr
= digest_buf
;
6966 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6968 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6972 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6974 len_used
= strlen (out_buf
);
6976 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6978 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6980 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6983 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",
6991 ptr
[15], ptr
[14]);
6993 else if (hash_mode
== 7300)
6995 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6997 rakp_t
*rakp
= &rakps
[salt_pos
];
6999 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7001 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7004 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7011 else if (hash_mode
== 7400)
7013 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7015 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7016 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7017 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7018 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7019 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7020 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7021 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7022 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7024 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7026 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7028 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7032 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7035 else if (hash_mode
== 7500)
7037 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7039 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7041 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7042 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7044 char data
[128] = { 0 };
7046 char *ptr_data
= data
;
7048 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7050 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7053 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7055 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7060 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7062 (char *) krb5pa
->user
,
7063 (char *) krb5pa
->realm
,
7064 (char *) krb5pa
->salt
,
7067 else if (hash_mode
== 7700)
7069 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7070 (char *) salt
.salt_buf
,
7074 else if (hash_mode
== 7800)
7076 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7077 (char *) salt
.salt_buf
,
7084 else if (hash_mode
== 7900)
7086 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7090 char *tmp
= (char *) salt
.salt_buf_pc
;
7092 ptr_plain
[42] = tmp
[0];
7098 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7100 else if (hash_mode
== 8000)
7102 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7103 (unsigned char *) salt
.salt_buf
,
7113 else if (hash_mode
== 8100)
7115 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7116 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7118 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7119 (unsigned char *) salt
.salt_buf
,
7126 else if (hash_mode
== 8200)
7128 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7130 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7132 char data_buf
[4096] = { 0 };
7134 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7136 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7139 data_buf
[cloudkey
->data_len
* 2] = 0;
7141 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7142 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7143 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7144 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7145 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7146 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7147 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7148 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7150 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7151 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7152 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7153 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7155 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7171 else if (hash_mode
== 8300)
7173 char digest_buf_c
[34] = { 0 };
7175 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7177 digest_buf_c
[32] = 0;
7181 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7183 char domain_buf_c
[33] = { 0 };
7185 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7187 for (uint i
= 0; i
< salt_pc_len
; i
++)
7189 const char next
= domain_buf_c
[i
];
7191 domain_buf_c
[i
] = '.';
7196 domain_buf_c
[salt_pc_len
] = 0;
7200 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7202 else if (hash_mode
== 8500)
7204 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7206 else if (hash_mode
== 2612)
7208 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7210 (char *) salt
.salt_buf
,
7216 else if (hash_mode
== 3711)
7218 char *salt_ptr
= (char *) salt
.salt_buf
;
7220 salt_ptr
[salt
.salt_len
- 1] = 0;
7222 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7223 SIGNATURE_MEDIAWIKI_B
,
7230 else if (hash_mode
== 8800)
7232 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7234 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7236 char tmp
[3073] = { 0 };
7238 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7240 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7245 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7246 SIGNATURE_ANDROIDFDE
,
7247 byte_swap_32 (salt
.salt_buf
[0]),
7248 byte_swap_32 (salt
.salt_buf
[1]),
7249 byte_swap_32 (salt
.salt_buf
[2]),
7250 byte_swap_32 (salt
.salt_buf
[3]),
7251 byte_swap_32 (digest_buf
[0]),
7252 byte_swap_32 (digest_buf
[1]),
7253 byte_swap_32 (digest_buf
[2]),
7254 byte_swap_32 (digest_buf
[3]),
7257 else if (hash_mode
== 8900)
7259 uint N
= salt
.scrypt_N
;
7260 uint r
= salt
.scrypt_r
;
7261 uint p
= salt
.scrypt_p
;
7263 char base64_salt
[32] = { 0 };
7265 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7267 memset (tmp_buf
, 0, 46);
7269 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7270 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7271 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7272 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7273 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7274 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7275 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7276 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7277 digest_buf
[8] = 0; // needed for base64_encode ()
7279 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7281 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7289 else if (hash_mode
== 9000)
7291 snprintf (out_buf
, len
-1, "%s", hashfile
);
7293 else if (hash_mode
== 9200)
7297 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7299 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7301 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7305 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7306 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7307 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7308 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7309 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7310 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7311 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7312 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7313 digest_buf
[8] = 0; // needed for base64_encode ()
7315 char tmp_buf
[64] = { 0 };
7317 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7318 tmp_buf
[43] = 0; // cut it here
7322 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7324 else if (hash_mode
== 9300)
7326 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7327 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7328 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7329 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7330 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7331 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7332 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7333 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7334 digest_buf
[8] = 0; // needed for base64_encode ()
7336 char tmp_buf
[64] = { 0 };
7338 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7339 tmp_buf
[43] = 0; // cut it here
7341 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7343 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7345 else if (hash_mode
== 9400)
7347 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7349 office2007_t
*office2007
= &office2007s
[salt_pos
];
7351 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7352 SIGNATURE_OFFICE2007
,
7355 office2007
->keySize
,
7361 office2007
->encryptedVerifier
[0],
7362 office2007
->encryptedVerifier
[1],
7363 office2007
->encryptedVerifier
[2],
7364 office2007
->encryptedVerifier
[3],
7365 office2007
->encryptedVerifierHash
[0],
7366 office2007
->encryptedVerifierHash
[1],
7367 office2007
->encryptedVerifierHash
[2],
7368 office2007
->encryptedVerifierHash
[3],
7369 office2007
->encryptedVerifierHash
[4]);
7371 else if (hash_mode
== 9500)
7373 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7375 office2010_t
*office2010
= &office2010s
[salt_pos
];
7377 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,
7383 office2010
->encryptedVerifier
[0],
7384 office2010
->encryptedVerifier
[1],
7385 office2010
->encryptedVerifier
[2],
7386 office2010
->encryptedVerifier
[3],
7387 office2010
->encryptedVerifierHash
[0],
7388 office2010
->encryptedVerifierHash
[1],
7389 office2010
->encryptedVerifierHash
[2],
7390 office2010
->encryptedVerifierHash
[3],
7391 office2010
->encryptedVerifierHash
[4],
7392 office2010
->encryptedVerifierHash
[5],
7393 office2010
->encryptedVerifierHash
[6],
7394 office2010
->encryptedVerifierHash
[7]);
7396 else if (hash_mode
== 9600)
7398 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7400 office2013_t
*office2013
= &office2013s
[salt_pos
];
7402 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,
7408 office2013
->encryptedVerifier
[0],
7409 office2013
->encryptedVerifier
[1],
7410 office2013
->encryptedVerifier
[2],
7411 office2013
->encryptedVerifier
[3],
7412 office2013
->encryptedVerifierHash
[0],
7413 office2013
->encryptedVerifierHash
[1],
7414 office2013
->encryptedVerifierHash
[2],
7415 office2013
->encryptedVerifierHash
[3],
7416 office2013
->encryptedVerifierHash
[4],
7417 office2013
->encryptedVerifierHash
[5],
7418 office2013
->encryptedVerifierHash
[6],
7419 office2013
->encryptedVerifierHash
[7]);
7421 else if (hash_mode
== 9700)
7423 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7425 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7427 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7428 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7429 byte_swap_32 (salt
.salt_buf
[0]),
7430 byte_swap_32 (salt
.salt_buf
[1]),
7431 byte_swap_32 (salt
.salt_buf
[2]),
7432 byte_swap_32 (salt
.salt_buf
[3]),
7433 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7434 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7435 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7436 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7437 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7438 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7439 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7440 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7442 else if (hash_mode
== 9710)
7444 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7446 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7448 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7449 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7450 byte_swap_32 (salt
.salt_buf
[0]),
7451 byte_swap_32 (salt
.salt_buf
[1]),
7452 byte_swap_32 (salt
.salt_buf
[2]),
7453 byte_swap_32 (salt
.salt_buf
[3]),
7454 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7455 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7456 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7457 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7458 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7459 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7460 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7461 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7463 else if (hash_mode
== 9720)
7465 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7467 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7469 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7471 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7472 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7473 byte_swap_32 (salt
.salt_buf
[0]),
7474 byte_swap_32 (salt
.salt_buf
[1]),
7475 byte_swap_32 (salt
.salt_buf
[2]),
7476 byte_swap_32 (salt
.salt_buf
[3]),
7477 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7478 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7479 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7480 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7481 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7482 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7483 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7484 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7491 else if (hash_mode
== 9800)
7493 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7495 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7497 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7498 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7503 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7504 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7505 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7506 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7507 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7508 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7509 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7510 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7511 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7513 else if (hash_mode
== 9810)
7515 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7517 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7519 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7520 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7525 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7526 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7527 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7528 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7529 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7530 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7531 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7532 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7533 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7535 else if (hash_mode
== 9820)
7537 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7539 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7541 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7543 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7544 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7549 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7550 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7551 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7552 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7553 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7554 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7555 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7556 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7557 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7564 else if (hash_mode
== 10000)
7568 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7570 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7572 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7576 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7577 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7578 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7579 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7580 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7581 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7582 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7583 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7584 digest_buf
[8] = 0; // needed for base64_encode ()
7586 char tmp_buf
[64] = { 0 };
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] = { 0 };
7616 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7620 char tmp_buf
[100] = { 0 };
7622 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7623 (char *) cram_md5
->user
,
7629 char response
[100] = { 0 };
7631 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7633 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7635 else if (hash_mode
== 10300)
7637 char tmp_buf
[100] = { 0 };
7639 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7640 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7642 uint tmp_len
= 20 + salt
.salt_len
;
7646 char base64_encoded
[100] = { 0 };
7648 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7650 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7652 else if (hash_mode
== 10400)
7654 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7656 pdf_t
*pdf
= &pdfs
[salt_pos
];
7658 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",
7666 byte_swap_32 (pdf
->id_buf
[0]),
7667 byte_swap_32 (pdf
->id_buf
[1]),
7668 byte_swap_32 (pdf
->id_buf
[2]),
7669 byte_swap_32 (pdf
->id_buf
[3]),
7671 byte_swap_32 (pdf
->u_buf
[0]),
7672 byte_swap_32 (pdf
->u_buf
[1]),
7673 byte_swap_32 (pdf
->u_buf
[2]),
7674 byte_swap_32 (pdf
->u_buf
[3]),
7675 byte_swap_32 (pdf
->u_buf
[4]),
7676 byte_swap_32 (pdf
->u_buf
[5]),
7677 byte_swap_32 (pdf
->u_buf
[6]),
7678 byte_swap_32 (pdf
->u_buf
[7]),
7680 byte_swap_32 (pdf
->o_buf
[0]),
7681 byte_swap_32 (pdf
->o_buf
[1]),
7682 byte_swap_32 (pdf
->o_buf
[2]),
7683 byte_swap_32 (pdf
->o_buf
[3]),
7684 byte_swap_32 (pdf
->o_buf
[4]),
7685 byte_swap_32 (pdf
->o_buf
[5]),
7686 byte_swap_32 (pdf
->o_buf
[6]),
7687 byte_swap_32 (pdf
->o_buf
[7])
7690 else if (hash_mode
== 10410)
7692 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7694 pdf_t
*pdf
= &pdfs
[salt_pos
];
7696 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",
7704 byte_swap_32 (pdf
->id_buf
[0]),
7705 byte_swap_32 (pdf
->id_buf
[1]),
7706 byte_swap_32 (pdf
->id_buf
[2]),
7707 byte_swap_32 (pdf
->id_buf
[3]),
7709 byte_swap_32 (pdf
->u_buf
[0]),
7710 byte_swap_32 (pdf
->u_buf
[1]),
7711 byte_swap_32 (pdf
->u_buf
[2]),
7712 byte_swap_32 (pdf
->u_buf
[3]),
7713 byte_swap_32 (pdf
->u_buf
[4]),
7714 byte_swap_32 (pdf
->u_buf
[5]),
7715 byte_swap_32 (pdf
->u_buf
[6]),
7716 byte_swap_32 (pdf
->u_buf
[7]),
7718 byte_swap_32 (pdf
->o_buf
[0]),
7719 byte_swap_32 (pdf
->o_buf
[1]),
7720 byte_swap_32 (pdf
->o_buf
[2]),
7721 byte_swap_32 (pdf
->o_buf
[3]),
7722 byte_swap_32 (pdf
->o_buf
[4]),
7723 byte_swap_32 (pdf
->o_buf
[5]),
7724 byte_swap_32 (pdf
->o_buf
[6]),
7725 byte_swap_32 (pdf
->o_buf
[7])
7728 else if (hash_mode
== 10420)
7730 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7732 pdf_t
*pdf
= &pdfs
[salt_pos
];
7734 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7736 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",
7744 byte_swap_32 (pdf
->id_buf
[0]),
7745 byte_swap_32 (pdf
->id_buf
[1]),
7746 byte_swap_32 (pdf
->id_buf
[2]),
7747 byte_swap_32 (pdf
->id_buf
[3]),
7749 byte_swap_32 (pdf
->u_buf
[0]),
7750 byte_swap_32 (pdf
->u_buf
[1]),
7751 byte_swap_32 (pdf
->u_buf
[2]),
7752 byte_swap_32 (pdf
->u_buf
[3]),
7753 byte_swap_32 (pdf
->u_buf
[4]),
7754 byte_swap_32 (pdf
->u_buf
[5]),
7755 byte_swap_32 (pdf
->u_buf
[6]),
7756 byte_swap_32 (pdf
->u_buf
[7]),
7758 byte_swap_32 (pdf
->o_buf
[0]),
7759 byte_swap_32 (pdf
->o_buf
[1]),
7760 byte_swap_32 (pdf
->o_buf
[2]),
7761 byte_swap_32 (pdf
->o_buf
[3]),
7762 byte_swap_32 (pdf
->o_buf
[4]),
7763 byte_swap_32 (pdf
->o_buf
[5]),
7764 byte_swap_32 (pdf
->o_buf
[6]),
7765 byte_swap_32 (pdf
->o_buf
[7]),
7773 else if (hash_mode
== 10500)
7775 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7777 pdf_t
*pdf
= &pdfs
[salt_pos
];
7779 if (pdf
->id_len
== 32)
7781 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",
7789 byte_swap_32 (pdf
->id_buf
[0]),
7790 byte_swap_32 (pdf
->id_buf
[1]),
7791 byte_swap_32 (pdf
->id_buf
[2]),
7792 byte_swap_32 (pdf
->id_buf
[3]),
7793 byte_swap_32 (pdf
->id_buf
[4]),
7794 byte_swap_32 (pdf
->id_buf
[5]),
7795 byte_swap_32 (pdf
->id_buf
[6]),
7796 byte_swap_32 (pdf
->id_buf
[7]),
7798 byte_swap_32 (pdf
->u_buf
[0]),
7799 byte_swap_32 (pdf
->u_buf
[1]),
7800 byte_swap_32 (pdf
->u_buf
[2]),
7801 byte_swap_32 (pdf
->u_buf
[3]),
7802 byte_swap_32 (pdf
->u_buf
[4]),
7803 byte_swap_32 (pdf
->u_buf
[5]),
7804 byte_swap_32 (pdf
->u_buf
[6]),
7805 byte_swap_32 (pdf
->u_buf
[7]),
7807 byte_swap_32 (pdf
->o_buf
[0]),
7808 byte_swap_32 (pdf
->o_buf
[1]),
7809 byte_swap_32 (pdf
->o_buf
[2]),
7810 byte_swap_32 (pdf
->o_buf
[3]),
7811 byte_swap_32 (pdf
->o_buf
[4]),
7812 byte_swap_32 (pdf
->o_buf
[5]),
7813 byte_swap_32 (pdf
->o_buf
[6]),
7814 byte_swap_32 (pdf
->o_buf
[7])
7819 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",
7827 byte_swap_32 (pdf
->id_buf
[0]),
7828 byte_swap_32 (pdf
->id_buf
[1]),
7829 byte_swap_32 (pdf
->id_buf
[2]),
7830 byte_swap_32 (pdf
->id_buf
[3]),
7832 byte_swap_32 (pdf
->u_buf
[0]),
7833 byte_swap_32 (pdf
->u_buf
[1]),
7834 byte_swap_32 (pdf
->u_buf
[2]),
7835 byte_swap_32 (pdf
->u_buf
[3]),
7836 byte_swap_32 (pdf
->u_buf
[4]),
7837 byte_swap_32 (pdf
->u_buf
[5]),
7838 byte_swap_32 (pdf
->u_buf
[6]),
7839 byte_swap_32 (pdf
->u_buf
[7]),
7841 byte_swap_32 (pdf
->o_buf
[0]),
7842 byte_swap_32 (pdf
->o_buf
[1]),
7843 byte_swap_32 (pdf
->o_buf
[2]),
7844 byte_swap_32 (pdf
->o_buf
[3]),
7845 byte_swap_32 (pdf
->o_buf
[4]),
7846 byte_swap_32 (pdf
->o_buf
[5]),
7847 byte_swap_32 (pdf
->o_buf
[6]),
7848 byte_swap_32 (pdf
->o_buf
[7])
7852 else if (hash_mode
== 10600)
7854 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7856 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7857 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7859 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7861 else if (hash_mode
== 10700)
7863 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7865 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7866 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7868 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7870 else if (hash_mode
== 10900)
7872 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7874 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7875 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7877 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7879 else if (hash_mode
== 11100)
7881 u32 salt_challenge
= salt
.salt_buf
[0];
7883 salt_challenge
= byte_swap_32 (salt_challenge
);
7885 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7887 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7888 SIGNATURE_POSTGRESQL_AUTH
,
7896 else if (hash_mode
== 11200)
7898 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7899 SIGNATURE_MYSQL_AUTH
,
7900 (unsigned char *) salt
.salt_buf
,
7907 else if (hash_mode
== 11300)
7909 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7911 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7913 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7914 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7915 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7917 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7918 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7919 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7921 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7923 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7925 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7928 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7930 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7932 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7935 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7937 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7939 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7942 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7943 SIGNATURE_BITCOIN_WALLET
,
7947 (unsigned char *) salt
.salt_buf
,
7955 free (cry_master_buf
);
7957 free (public_key_buf
);
7959 else if (hash_mode
== 11400)
7961 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7963 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7964 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7966 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7968 else if (hash_mode
== 11600)
7970 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7972 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7974 const uint data_len
= seven_zip
->data_len
;
7976 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7978 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7980 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
7982 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7985 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7986 SIGNATURE_SEVEN_ZIP
,
7990 (char *) seven_zip
->salt_buf
,
7992 seven_zip
->iv_buf
[0],
7993 seven_zip
->iv_buf
[1],
7994 seven_zip
->iv_buf
[2],
7995 seven_zip
->iv_buf
[3],
7997 seven_zip
->data_len
,
7998 seven_zip
->unpack_size
,
8003 else if (hash_mode
== 11700)
8005 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8015 else if (hash_mode
== 11800)
8017 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8035 else if (hash_mode
== 11900)
8037 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8039 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8040 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8042 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8044 else if (hash_mode
== 12000)
8046 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8048 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8049 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8051 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8053 else if (hash_mode
== 12100)
8055 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8057 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8058 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8060 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8062 else if (hash_mode
== 12200)
8064 uint
*ptr_digest
= digest_buf
;
8065 uint
*ptr_salt
= salt
.salt_buf
;
8067 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8074 else if (hash_mode
== 12300)
8076 uint
*ptr_digest
= digest_buf
;
8077 uint
*ptr_salt
= salt
.salt_buf
;
8079 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",
8080 ptr_digest
[ 0], ptr_digest
[ 1],
8081 ptr_digest
[ 2], ptr_digest
[ 3],
8082 ptr_digest
[ 4], ptr_digest
[ 5],
8083 ptr_digest
[ 6], ptr_digest
[ 7],
8084 ptr_digest
[ 8], ptr_digest
[ 9],
8085 ptr_digest
[10], ptr_digest
[11],
8086 ptr_digest
[12], ptr_digest
[13],
8087 ptr_digest
[14], ptr_digest
[15],
8093 else if (hash_mode
== 12400)
8095 // encode iteration count
8097 char salt_iter
[5] = { 0 };
8099 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8100 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8101 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8102 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8107 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8108 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8109 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8110 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8115 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8117 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8118 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8120 memcpy (tmp_buf
, digest_buf
, 8);
8122 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8126 // fill the resulting buffer
8128 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8130 else if (hash_mode
== 12500)
8132 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8134 byte_swap_32 (salt
.salt_buf
[0]),
8135 byte_swap_32 (salt
.salt_buf
[1]),
8141 else if (hash_mode
== 12600)
8143 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8144 digest_buf
[0] + salt
.salt_buf_pc
[0],
8145 digest_buf
[1] + salt
.salt_buf_pc
[1],
8146 digest_buf
[2] + salt
.salt_buf_pc
[2],
8147 digest_buf
[3] + salt
.salt_buf_pc
[3],
8148 digest_buf
[4] + salt
.salt_buf_pc
[4],
8149 digest_buf
[5] + salt
.salt_buf_pc
[5],
8150 digest_buf
[6] + salt
.salt_buf_pc
[6],
8151 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8153 else if (hash_mode
== 12700)
8155 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8157 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8158 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8160 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8162 else if (hash_mode
== 12800)
8164 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8166 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",
8179 byte_swap_32 (digest_buf
[0]),
8180 byte_swap_32 (digest_buf
[1]),
8181 byte_swap_32 (digest_buf
[2]),
8182 byte_swap_32 (digest_buf
[3]),
8183 byte_swap_32 (digest_buf
[4]),
8184 byte_swap_32 (digest_buf
[5]),
8185 byte_swap_32 (digest_buf
[6]),
8186 byte_swap_32 (digest_buf
[7])
8189 else if (hash_mode
== 12900)
8191 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",
8200 byte_swap_32 (digest_buf
[0]),
8201 byte_swap_32 (digest_buf
[1]),
8202 byte_swap_32 (digest_buf
[2]),
8203 byte_swap_32 (digest_buf
[3]),
8204 byte_swap_32 (digest_buf
[4]),
8205 byte_swap_32 (digest_buf
[5]),
8206 byte_swap_32 (digest_buf
[6]),
8207 byte_swap_32 (digest_buf
[7]),
8214 else if (hash_mode
== 13000)
8216 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8218 rar5_t
*rar5
= &rar5s
[salt_pos
];
8220 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8230 byte_swap_32 (digest_buf
[0]),
8231 byte_swap_32 (digest_buf
[1])
8236 if (hash_type
== HASH_TYPE_MD4
)
8238 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8244 else if (hash_type
== HASH_TYPE_MD5
)
8246 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8252 else if (hash_type
== HASH_TYPE_SHA1
)
8254 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8261 else if (hash_type
== HASH_TYPE_SHA256
)
8263 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8273 else if (hash_type
== HASH_TYPE_SHA384
)
8275 uint
*ptr
= digest_buf
;
8277 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8285 else if (hash_type
== HASH_TYPE_SHA512
)
8287 uint
*ptr
= digest_buf
;
8289 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8299 else if (hash_type
== HASH_TYPE_LM
)
8301 snprintf (out_buf
, len
-1, "%08x%08x",
8305 else if (hash_type
== HASH_TYPE_ORACLEH
)
8307 snprintf (out_buf
, len
-1, "%08X%08X",
8311 else if (hash_type
== HASH_TYPE_BCRYPT
)
8313 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8314 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8316 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8318 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8320 else if (hash_type
== HASH_TYPE_KECCAK
)
8322 uint
*ptr
= digest_buf
;
8324 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",
8352 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8354 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8356 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8363 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8365 digest_buf
[ 0] = digest_buf
[ 0];
8366 digest_buf
[ 1] = digest_buf
[ 1];
8367 digest_buf
[ 2] = digest_buf
[ 2];
8368 digest_buf
[ 3] = digest_buf
[ 3];
8369 digest_buf
[ 4] = digest_buf
[ 4];
8370 digest_buf
[ 5] = digest_buf
[ 5];
8371 digest_buf
[ 6] = digest_buf
[ 6];
8372 digest_buf
[ 7] = digest_buf
[ 7];
8373 digest_buf
[ 8] = digest_buf
[ 8];
8374 digest_buf
[ 9] = digest_buf
[ 9];
8375 digest_buf
[10] = digest_buf
[10];
8376 digest_buf
[11] = digest_buf
[11];
8377 digest_buf
[12] = digest_buf
[12];
8378 digest_buf
[13] = digest_buf
[13];
8379 digest_buf
[14] = digest_buf
[14];
8380 digest_buf
[15] = digest_buf
[15];
8382 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8400 else if (hash_type
== HASH_TYPE_GOST
)
8402 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8412 else if (hash_type
== HASH_TYPE_MYSQL
)
8414 snprintf (out_buf
, len
-1, "%08x%08x",
8418 else if (hash_type
== HASH_TYPE_LOTUS5
)
8420 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8426 else if (hash_type
== HASH_TYPE_LOTUS6
)
8428 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8429 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8430 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8431 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8433 char buf
[16] = { 0 };
8435 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8436 memcpy (buf
+ 5, digest_buf
, 9);
8440 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8442 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8445 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8447 else if (hash_type
== HASH_TYPE_LOTUS8
)
8449 char buf
[52] = { 0 };
8453 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8459 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8463 buf
[26] = salt
.salt_buf_pc
[0];
8464 buf
[27] = salt
.salt_buf_pc
[1];
8468 memcpy (buf
+ 28, digest_buf
, 8);
8470 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8474 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8476 else if (hash_type
== HASH_TYPE_CRC32
)
8478 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8482 if (salt_type
== SALT_TYPE_INTERN
)
8484 size_t pos
= strlen (out_buf
);
8486 out_buf
[pos
] = data
.separator
;
8488 char *ptr
= (char *) salt
.salt_buf
;
8490 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8492 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8496 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8498 memset (hccap
, 0, sizeof (hccap_t
));
8500 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8502 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8504 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8505 wpa_t
*wpa
= &wpas
[salt_pos
];
8507 hccap
->keyver
= wpa
->keyver
;
8509 hccap
->eapol_size
= wpa
->eapol_size
;
8511 if (wpa
->keyver
!= 1)
8513 uint eapol_tmp
[64] = { 0 };
8515 for (uint i
= 0; i
< 64; i
++)
8517 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8520 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8524 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8527 uint pke_tmp
[25] = { 0 };
8529 for (int i
= 5; i
< 25; i
++)
8531 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8534 char *pke_ptr
= (char *) pke_tmp
;
8536 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8537 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8538 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8539 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8541 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8543 uint dgst_size
= data
.dgst_size
;
8545 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8547 if (wpa
->keyver
!= 1)
8549 uint digest_tmp
[4] = { 0 };
8551 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8552 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8553 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8554 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8556 memcpy (hccap
->keymic
, digest_tmp
, 16);
8560 memcpy (hccap
->keymic
, digest_ptr
, 16);
8564 void SuspendThreads ()
8566 if (data
.devices_status
== STATUS_RUNNING
)
8568 hc_timer_set (&data
.timer_paused
);
8570 data
.devices_status
= STATUS_PAUSED
;
8572 log_info ("Paused");
8576 void ResumeThreads ()
8578 if (data
.devices_status
== STATUS_PAUSED
)
8582 hc_timer_get (data
.timer_paused
, ms_paused
);
8584 data
.ms_paused
+= ms_paused
;
8586 data
.devices_status
= STATUS_RUNNING
;
8588 log_info ("Resumed");
8594 if (data
.devices_status
!= STATUS_RUNNING
) return;
8596 data
.devices_status
= STATUS_BYPASS
;
8598 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8601 void stop_at_checkpoint ()
8603 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8605 if (data
.devices_status
!= STATUS_RUNNING
) return;
8608 // this feature only makes sense if --restore-disable was not specified
8610 if (data
.restore_disable
== 1)
8612 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8617 // check if monitoring of Restore Point updates should be enabled or disabled
8619 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8621 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8623 // save the current restore point value
8625 data
.checkpoint_cur_words
= get_lowest_words_done ();
8627 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8631 data
.devices_status
= STATUS_RUNNING
;
8633 // reset the global value for checkpoint checks
8635 data
.checkpoint_cur_words
= 0;
8637 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8643 if (data
.devices_status
== STATUS_INIT
) return;
8644 if (data
.devices_status
== STATUS_STARTING
) return;
8646 data
.devices_status
= STATUS_ABORTED
;
8651 if (data
.devices_status
== STATUS_INIT
) return;
8652 if (data
.devices_status
== STATUS_STARTING
) return;
8654 data
.devices_status
= STATUS_QUIT
;
8657 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8659 FILE *fp
= fopen (kernel_file
, "rb");
8665 memset (&st
, 0, sizeof (st
));
8667 stat (kernel_file
, &st
);
8669 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8671 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8673 if (num_read
!= (size_t) st
.st_size
)
8675 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8682 buf
[st
.st_size
] = 0;
8684 for (int i
= 0; i
< num_devices
; i
++)
8686 kernel_lengths
[i
] = (size_t) st
.st_size
;
8688 kernel_sources
[i
] = buf
;
8693 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8701 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8703 if (binary_size
> 0)
8705 FILE *fp
= fopen (dst
, "wb");
8708 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8719 restore_data_t
*init_restore (int argc
, char **argv
)
8721 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8723 if (data
.restore_disable
== 0)
8725 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8729 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8733 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8742 char pidbin
[BUFSIZ
] = { 0 };
8744 int pidbin_len
= -1;
8747 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8749 FILE *fd
= fopen (pidbin
, "rb");
8753 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8755 pidbin
[pidbin_len
] = 0;
8759 char *argv0_r
= strrchr (argv
[0], '/');
8761 char *pidbin_r
= strrchr (pidbin
, '/');
8763 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8765 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8767 if (strcmp (argv0_r
, pidbin_r
) == 0)
8769 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8776 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8778 char pidbin2
[BUFSIZ
] = { 0 };
8780 int pidbin2_len
= -1;
8782 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8783 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8785 pidbin
[pidbin_len
] = 0;
8786 pidbin2
[pidbin2_len
] = 0;
8790 if (strcmp (pidbin
, pidbin2
) == 0)
8792 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8800 if (rd
->version_bin
< RESTORE_MIN
)
8802 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8809 memset (rd
, 0, sizeof (restore_data_t
));
8811 rd
->version_bin
= VERSION_BIN
;
8814 rd
->pid
= getpid ();
8816 rd
->pid
= GetCurrentProcessId ();
8819 if (getcwd (rd
->cwd
, 255) == NULL
)
8832 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8834 FILE *fp
= fopen (eff_restore_file
, "rb");
8838 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8843 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8845 log_error ("ERROR: cannot read %s", eff_restore_file
);
8850 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8852 for (uint i
= 0; i
< rd
->argc
; i
++)
8854 char buf
[BUFSIZ
] = { 0 };
8856 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8858 log_error ("ERROR: cannot read %s", eff_restore_file
);
8863 size_t len
= strlen (buf
);
8865 if (len
) buf
[len
- 1] = 0;
8867 rd
->argv
[i
] = mystrdup (buf
);
8872 char new_cwd
[1024] = { 0 };
8874 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8878 log_error ("Restore file is corrupted");
8881 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8883 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8885 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8890 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8893 if (chdir (rd
->cwd
))
8895 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8901 u64
get_lowest_words_done ()
8905 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8907 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8909 if (device_param
->skipped
) continue;
8911 const u64 words_done
= device_param
->words_done
;
8913 if (words_done
< words_cur
) words_cur
= words_done
;
8916 // It's possible that a device's workload isn't finished right after a restore-case.
8917 // In that case, this function would return 0 and overwrite the real restore point
8918 // There's also data.words_cur which is set to rd->words_cur but it changes while
8919 // the attack is running therefore we should stick to rd->words_cur.
8920 // Note that -s influences rd->words_cur we should keep a close look on that.
8922 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8927 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8929 u64 words_cur
= get_lowest_words_done ();
8931 rd
->words_cur
= words_cur
;
8933 FILE *fp
= fopen (new_restore_file
, "wb");
8937 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8942 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8944 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8949 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8951 for (uint i
= 0; i
< rd
->argc
; i
++)
8953 fprintf (fp
, "%s", rd
->argv
[i
]);
8959 fsync (fileno (fp
));
8964 void cycle_restore ()
8966 const char *eff_restore_file
= data
.eff_restore_file
;
8967 const char *new_restore_file
= data
.new_restore_file
;
8969 restore_data_t
*rd
= data
.rd
;
8971 write_restore (new_restore_file
, rd
);
8975 memset (&st
, 0, sizeof(st
));
8977 if (stat (eff_restore_file
, &st
) == 0)
8979 if (unlink (eff_restore_file
))
8981 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8985 if (rename (new_restore_file
, eff_restore_file
))
8987 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8991 void check_checkpoint ()
8993 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8995 u64 words_cur
= get_lowest_words_done ();
8997 if (words_cur
!= data
.checkpoint_cur_words
)
9007 uint
set_kernel_accel (uint hash_mode
)
9011 case 0: return GET_ACCEL (0);
9012 case 10: return GET_ACCEL (10);
9013 case 11: return GET_ACCEL (11);
9014 case 12: return GET_ACCEL (12);
9015 case 20: return GET_ACCEL (20);
9016 case 21: return GET_ACCEL (21);
9017 case 22: return GET_ACCEL (22);
9018 case 23: return GET_ACCEL (23);
9019 case 30: return GET_ACCEL (30);
9020 case 40: return GET_ACCEL (40);
9021 case 50: return GET_ACCEL (50);
9022 case 60: return GET_ACCEL (60);
9023 case 100: return GET_ACCEL (100);
9024 case 101: return GET_ACCEL (101);
9025 case 110: return GET_ACCEL (110);
9026 case 111: return GET_ACCEL (111);
9027 case 112: return GET_ACCEL (112);
9028 case 120: return GET_ACCEL (120);
9029 case 121: return GET_ACCEL (121);
9030 case 122: return GET_ACCEL (122);
9031 case 124: return GET_ACCEL (124);
9032 case 130: return GET_ACCEL (130);
9033 case 131: return GET_ACCEL (131);
9034 case 132: return GET_ACCEL (132);
9035 case 133: return GET_ACCEL (133);
9036 case 140: return GET_ACCEL (140);
9037 case 141: return GET_ACCEL (141);
9038 case 150: return GET_ACCEL (150);
9039 case 160: return GET_ACCEL (160);
9040 case 190: return GET_ACCEL (190);
9041 case 200: return GET_ACCEL (200);
9042 case 300: return GET_ACCEL (300);
9043 case 400: return GET_ACCEL (400);
9044 case 500: return GET_ACCEL (500);
9045 case 501: return GET_ACCEL (501);
9046 case 900: return GET_ACCEL (900);
9047 case 910: return GET_ACCEL (910);
9048 case 1000: return GET_ACCEL (1000);
9049 case 1100: return GET_ACCEL (1100);
9050 case 1400: return GET_ACCEL (1400);
9051 case 1410: return GET_ACCEL (1410);
9052 case 1420: return GET_ACCEL (1420);
9053 case 1421: return GET_ACCEL (1421);
9054 case 1430: return GET_ACCEL (1430);
9055 case 1440: return GET_ACCEL (1440);
9056 case 1441: return GET_ACCEL (1441);
9057 case 1450: return GET_ACCEL (1450);
9058 case 1460: return GET_ACCEL (1460);
9059 case 1500: return GET_ACCEL (1500);
9060 case 1600: return GET_ACCEL (1600);
9061 case 1700: return GET_ACCEL (1700);
9062 case 1710: return GET_ACCEL (1710);
9063 case 1711: return GET_ACCEL (1711);
9064 case 1720: return GET_ACCEL (1720);
9065 case 1722: return GET_ACCEL (1722);
9066 case 1730: return GET_ACCEL (1730);
9067 case 1731: return GET_ACCEL (1731);
9068 case 1740: return GET_ACCEL (1740);
9069 case 1750: return GET_ACCEL (1750);
9070 case 1760: return GET_ACCEL (1760);
9071 case 1800: return GET_ACCEL (1800);
9072 case 2100: return GET_ACCEL (2100);
9073 case 2400: return GET_ACCEL (2400);
9074 case 2410: return GET_ACCEL (2410);
9075 case 2500: return GET_ACCEL (2500);
9076 case 2600: return GET_ACCEL (2600);
9077 case 2611: return GET_ACCEL (2611);
9078 case 2612: return GET_ACCEL (2612);
9079 case 2711: return GET_ACCEL (2711);
9080 case 2811: return GET_ACCEL (2811);
9081 case 3000: return GET_ACCEL (3000);
9082 case 3100: return GET_ACCEL (3100);
9083 case 3200: return GET_ACCEL (3200);
9084 case 3710: return GET_ACCEL (3710);
9085 case 3711: return GET_ACCEL (3711);
9086 case 3800: return GET_ACCEL (3800);
9087 case 4300: return GET_ACCEL (4300);
9088 case 4400: return GET_ACCEL (4400);
9089 case 4500: return GET_ACCEL (4500);
9090 case 4700: return GET_ACCEL (4700);
9091 case 4800: return GET_ACCEL (4800);
9092 case 4900: return GET_ACCEL (4900);
9093 case 5000: return GET_ACCEL (5000);
9094 case 5100: return GET_ACCEL (5100);
9095 case 5200: return GET_ACCEL (5200);
9096 case 5300: return GET_ACCEL (5300);
9097 case 5400: return GET_ACCEL (5400);
9098 case 5500: return GET_ACCEL (5500);
9099 case 5600: return GET_ACCEL (5600);
9100 case 5700: return GET_ACCEL (5700);
9101 case 5800: return GET_ACCEL (5800);
9102 case 6000: return GET_ACCEL (6000);
9103 case 6100: return GET_ACCEL (6100);
9104 case 6211: return GET_ACCEL (6211);
9105 case 6212: return GET_ACCEL (6212);
9106 case 6213: return GET_ACCEL (6213);
9107 case 6221: return GET_ACCEL (6221);
9108 case 6222: return GET_ACCEL (6222);
9109 case 6223: return GET_ACCEL (6223);
9110 case 6231: return GET_ACCEL (6231);
9111 case 6232: return GET_ACCEL (6232);
9112 case 6233: return GET_ACCEL (6233);
9113 case 6241: return GET_ACCEL (6241);
9114 case 6242: return GET_ACCEL (6242);
9115 case 6243: return GET_ACCEL (6243);
9116 case 6300: return GET_ACCEL (6300);
9117 case 6400: return GET_ACCEL (6400);
9118 case 6500: return GET_ACCEL (6500);
9119 case 6600: return GET_ACCEL (6600);
9120 case 6700: return GET_ACCEL (6700);
9121 case 6800: return GET_ACCEL (6800);
9122 case 6900: return GET_ACCEL (6900);
9123 case 7100: return GET_ACCEL (7100);
9124 case 7200: return GET_ACCEL (7200);
9125 case 7300: return GET_ACCEL (7300);
9126 case 7400: return GET_ACCEL (7400);
9127 case 7500: return GET_ACCEL (7500);
9128 case 7600: return GET_ACCEL (7600);
9129 case 7700: return GET_ACCEL (7700);
9130 case 7800: return GET_ACCEL (7800);
9131 case 7900: return GET_ACCEL (7900);
9132 case 8000: return GET_ACCEL (8000);
9133 case 8100: return GET_ACCEL (8100);
9134 case 8200: return GET_ACCEL (8200);
9135 case 8300: return GET_ACCEL (8300);
9136 case 8400: return GET_ACCEL (8400);
9137 case 8500: return GET_ACCEL (8500);
9138 case 8600: return GET_ACCEL (8600);
9139 case 8700: return GET_ACCEL (8700);
9140 case 8800: return GET_ACCEL (8800);
9141 case 8900: return GET_ACCEL (8900);
9142 case 9000: return GET_ACCEL (9000);
9143 case 9100: return GET_ACCEL (9100);
9144 case 9200: return GET_ACCEL (9200);
9145 case 9300: return GET_ACCEL (9300);
9146 case 9400: return GET_ACCEL (9400);
9147 case 9500: return GET_ACCEL (9500);
9148 case 9600: return GET_ACCEL (9600);
9149 case 9700: return GET_ACCEL (9700);
9150 case 9710: return GET_ACCEL (9710);
9151 case 9720: return GET_ACCEL (9720);
9152 case 9800: return GET_ACCEL (9800);
9153 case 9810: return GET_ACCEL (9810);
9154 case 9820: return GET_ACCEL (9820);
9155 case 9900: return GET_ACCEL (9900);
9156 case 10000: return GET_ACCEL (10000);
9157 case 10100: return GET_ACCEL (10100);
9158 case 10200: return GET_ACCEL (10200);
9159 case 10300: return GET_ACCEL (10300);
9160 case 10400: return GET_ACCEL (10400);
9161 case 10410: return GET_ACCEL (10410);
9162 case 10420: return GET_ACCEL (10420);
9163 case 10500: return GET_ACCEL (10500);
9164 case 10600: return GET_ACCEL (10600);
9165 case 10700: return GET_ACCEL (10700);
9166 case 10800: return GET_ACCEL (10800);
9167 case 10900: return GET_ACCEL (10900);
9168 case 11000: return GET_ACCEL (11000);
9169 case 11100: return GET_ACCEL (11100);
9170 case 11200: return GET_ACCEL (11200);
9171 case 11300: return GET_ACCEL (11300);
9172 case 11400: return GET_ACCEL (11400);
9173 case 11500: return GET_ACCEL (11500);
9174 case 11600: return GET_ACCEL (11600);
9175 case 11700: return GET_ACCEL (11700);
9176 case 11800: return GET_ACCEL (11800);
9177 case 11900: return GET_ACCEL (11900);
9178 case 12000: return GET_ACCEL (12000);
9179 case 12100: return GET_ACCEL (12100);
9180 case 12200: return GET_ACCEL (12200);
9181 case 12300: return GET_ACCEL (12300);
9182 case 12400: return GET_ACCEL (12400);
9183 case 12500: return GET_ACCEL (12500);
9184 case 12600: return GET_ACCEL (12600);
9185 case 12700: return GET_ACCEL (12700);
9186 case 12800: return GET_ACCEL (12800);
9187 case 12900: return GET_ACCEL (12900);
9188 case 13000: return GET_ACCEL (13000);
9194 uint
set_kernel_loops (uint hash_mode
)
9198 case 0: return GET_LOOPS (0);
9199 case 10: return GET_LOOPS (10);
9200 case 11: return GET_LOOPS (11);
9201 case 12: return GET_LOOPS (12);
9202 case 20: return GET_LOOPS (20);
9203 case 21: return GET_LOOPS (21);
9204 case 22: return GET_LOOPS (22);
9205 case 23: return GET_LOOPS (23);
9206 case 30: return GET_LOOPS (30);
9207 case 40: return GET_LOOPS (40);
9208 case 50: return GET_LOOPS (50);
9209 case 60: return GET_LOOPS (60);
9210 case 100: return GET_LOOPS (100);
9211 case 101: return GET_LOOPS (101);
9212 case 110: return GET_LOOPS (110);
9213 case 111: return GET_LOOPS (111);
9214 case 112: return GET_LOOPS (112);
9215 case 120: return GET_LOOPS (120);
9216 case 121: return GET_LOOPS (121);
9217 case 122: return GET_LOOPS (122);
9218 case 124: return GET_LOOPS (124);
9219 case 130: return GET_LOOPS (130);
9220 case 131: return GET_LOOPS (131);
9221 case 132: return GET_LOOPS (132);
9222 case 133: return GET_LOOPS (133);
9223 case 140: return GET_LOOPS (140);
9224 case 141: return GET_LOOPS (141);
9225 case 150: return GET_LOOPS (150);
9226 case 160: return GET_LOOPS (160);
9227 case 190: return GET_LOOPS (190);
9228 case 200: return GET_LOOPS (200);
9229 case 300: return GET_LOOPS (300);
9230 case 400: return GET_LOOPS (400);
9231 case 500: return GET_LOOPS (500);
9232 case 501: return GET_LOOPS (501);
9233 case 900: return GET_LOOPS (900);
9234 case 910: return GET_LOOPS (910);
9235 case 1000: return GET_LOOPS (1000);
9236 case 1100: return GET_LOOPS (1100);
9237 case 1400: return GET_LOOPS (1400);
9238 case 1410: return GET_LOOPS (1410);
9239 case 1420: return GET_LOOPS (1420);
9240 case 1421: return GET_LOOPS (1421);
9241 case 1430: return GET_LOOPS (1430);
9242 case 1440: return GET_LOOPS (1440);
9243 case 1441: return GET_LOOPS (1441);
9244 case 1450: return GET_LOOPS (1450);
9245 case 1460: return GET_LOOPS (1460);
9246 case 1500: return GET_LOOPS (1500);
9247 case 1600: return GET_LOOPS (1600);
9248 case 1700: return GET_LOOPS (1700);
9249 case 1710: return GET_LOOPS (1710);
9250 case 1711: return GET_LOOPS (1711);
9251 case 1720: return GET_LOOPS (1720);
9252 case 1722: return GET_LOOPS (1722);
9253 case 1730: return GET_LOOPS (1730);
9254 case 1731: return GET_LOOPS (1731);
9255 case 1740: return GET_LOOPS (1740);
9256 case 1750: return GET_LOOPS (1750);
9257 case 1760: return GET_LOOPS (1760);
9258 case 1800: return GET_LOOPS (1800);
9259 case 2100: return GET_LOOPS (2100);
9260 case 2400: return GET_LOOPS (2400);
9261 case 2410: return GET_LOOPS (2410);
9262 case 2500: return GET_LOOPS (2500);
9263 case 2600: return GET_LOOPS (2600);
9264 case 2611: return GET_LOOPS (2611);
9265 case 2612: return GET_LOOPS (2612);
9266 case 2711: return GET_LOOPS (2711);
9267 case 2811: return GET_LOOPS (2811);
9268 case 3000: return GET_LOOPS (3000);
9269 case 3100: return GET_LOOPS (3100);
9270 case 3200: return GET_LOOPS (3200);
9271 case 3710: return GET_LOOPS (3710);
9272 case 3711: return GET_LOOPS (3711);
9273 case 3800: return GET_LOOPS (3800);
9274 case 4300: return GET_LOOPS (4300);
9275 case 4400: return GET_LOOPS (4400);
9276 case 4500: return GET_LOOPS (4500);
9277 case 4700: return GET_LOOPS (4700);
9278 case 4800: return GET_LOOPS (4800);
9279 case 4900: return GET_LOOPS (4900);
9280 case 5000: return GET_LOOPS (5000);
9281 case 5100: return GET_LOOPS (5100);
9282 case 5200: return GET_LOOPS (5200);
9283 case 5300: return GET_LOOPS (5300);
9284 case 5400: return GET_LOOPS (5400);
9285 case 5500: return GET_LOOPS (5500);
9286 case 5600: return GET_LOOPS (5600);
9287 case 5700: return GET_LOOPS (5700);
9288 case 5800: return GET_LOOPS (5800);
9289 case 6000: return GET_LOOPS (6000);
9290 case 6100: return GET_LOOPS (6100);
9291 case 6211: return GET_LOOPS (6211);
9292 case 6212: return GET_LOOPS (6212);
9293 case 6213: return GET_LOOPS (6213);
9294 case 6221: return GET_LOOPS (6221);
9295 case 6222: return GET_LOOPS (6222);
9296 case 6223: return GET_LOOPS (6223);
9297 case 6231: return GET_LOOPS (6231);
9298 case 6232: return GET_LOOPS (6232);
9299 case 6233: return GET_LOOPS (6233);
9300 case 6241: return GET_LOOPS (6241);
9301 case 6242: return GET_LOOPS (6242);
9302 case 6243: return GET_LOOPS (6243);
9303 case 6300: return GET_LOOPS (6300);
9304 case 6400: return GET_LOOPS (6400);
9305 case 6500: return GET_LOOPS (6500);
9306 case 6600: return GET_LOOPS (6600);
9307 case 6700: return GET_LOOPS (6700);
9308 case 6800: return GET_LOOPS (6800);
9309 case 6900: return GET_LOOPS (6900);
9310 case 7100: return GET_LOOPS (7100);
9311 case 7200: return GET_LOOPS (7200);
9312 case 7300: return GET_LOOPS (7300);
9313 case 7400: return GET_LOOPS (7400);
9314 case 7500: return GET_LOOPS (7500);
9315 case 7600: return GET_LOOPS (7600);
9316 case 7700: return GET_LOOPS (7700);
9317 case 7800: return GET_LOOPS (7800);
9318 case 7900: return GET_LOOPS (7900);
9319 case 8000: return GET_LOOPS (8000);
9320 case 8100: return GET_LOOPS (8100);
9321 case 8200: return GET_LOOPS (8200);
9322 case 8300: return GET_LOOPS (8300);
9323 case 8400: return GET_LOOPS (8400);
9324 case 8500: return GET_LOOPS (8500);
9325 case 8600: return GET_LOOPS (8600);
9326 case 8700: return GET_LOOPS (8700);
9327 case 8800: return GET_LOOPS (8800);
9328 case 8900: return GET_LOOPS (8900);
9329 case 9000: return GET_LOOPS (9000);
9330 case 9100: return GET_LOOPS (9100);
9331 case 9200: return GET_LOOPS (9200);
9332 case 9300: return GET_LOOPS (9300);
9333 case 9400: return GET_LOOPS (9400);
9334 case 9500: return GET_LOOPS (9500);
9335 case 9600: return GET_LOOPS (9600);
9336 case 9700: return GET_LOOPS (9700);
9337 case 9710: return GET_LOOPS (9710);
9338 case 9720: return GET_LOOPS (9720);
9339 case 9800: return GET_LOOPS (9800);
9340 case 9810: return GET_LOOPS (9810);
9341 case 9820: return GET_LOOPS (9820);
9342 case 9900: return GET_LOOPS (9900);
9343 case 10000: return GET_LOOPS (10000);
9344 case 10100: return GET_LOOPS (10100);
9345 case 10200: return GET_LOOPS (10200);
9346 case 10300: return GET_LOOPS (10300);
9347 case 10400: return GET_LOOPS (10400);
9348 case 10410: return GET_LOOPS (10410);
9349 case 10420: return GET_LOOPS (10420);
9350 case 10500: return GET_LOOPS (10500);
9351 case 10600: return GET_LOOPS (10600);
9352 case 10700: return GET_LOOPS (10700);
9353 case 10800: return GET_LOOPS (10800);
9354 case 10900: return GET_LOOPS (10900);
9355 case 11000: return GET_LOOPS (11000);
9356 case 11100: return GET_LOOPS (11100);
9357 case 11200: return GET_LOOPS (11200);
9358 case 11300: return GET_LOOPS (11300);
9359 case 11400: return GET_LOOPS (11400);
9360 case 11500: return GET_LOOPS (11500);
9361 case 11600: return GET_LOOPS (11600);
9362 case 11700: return GET_LOOPS (11700);
9363 case 11800: return GET_LOOPS (11800);
9364 case 11900: return GET_LOOPS (11900);
9365 case 12000: return GET_LOOPS (12000);
9366 case 12100: return GET_LOOPS (12100);
9367 case 12200: return GET_LOOPS (12200);
9368 case 12300: return GET_LOOPS (12300);
9369 case 12400: return GET_LOOPS (12400);
9370 case 12500: return GET_LOOPS (12500);
9371 case 12600: return GET_LOOPS (12600);
9372 case 12700: return GET_LOOPS (12700);
9373 case 12800: return GET_LOOPS (12800);
9374 case 12900: return GET_LOOPS (12900);
9375 case 13000: return GET_LOOPS (13000);
9385 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9387 u8 tmp
[256] = { 0 };
9389 if (salt_len
> sizeof (tmp
))
9394 memcpy (tmp
, in
, salt_len
);
9396 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9398 if ((salt_len
% 2) == 0)
9400 u32 new_salt_len
= salt_len
/ 2;
9402 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9407 tmp
[i
] = hex_convert (p1
) << 0;
9408 tmp
[i
] |= hex_convert (p0
) << 4;
9411 salt_len
= new_salt_len
;
9418 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9420 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9423 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9425 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9429 u32
*tmp_uint
= (u32
*) tmp
;
9431 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9432 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9433 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9434 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9435 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9436 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9437 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9438 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9439 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9440 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9442 salt_len
= salt_len
* 2;
9450 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9452 lowercase (tmp
, salt_len
);
9455 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9457 uppercase (tmp
, salt_len
);
9462 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9467 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9472 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9474 u32
*tmp_uint
= (uint
*) tmp
;
9480 for (u32 i
= 0; i
< max
; i
++)
9482 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9485 // Important: we may need to increase the length of memcpy since
9486 // we don't want to "loose" some swapped bytes (could happen if
9487 // they do not perfectly fit in the 4-byte blocks)
9488 // Memcpy does always copy the bytes in the BE order, but since
9489 // we swapped them, some important bytes could be in positions
9490 // we normally skip with the original len
9492 if (len
% 4) len
+= 4 - (len
% 4);
9495 memcpy (out
, tmp
, len
);
9500 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9502 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9504 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9506 u32
*digest
= (u32
*) hash_buf
->digest
;
9508 salt_t
*salt
= hash_buf
->salt
;
9510 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9512 char *iter_pos
= input_buf
+ 4;
9514 salt
->salt_iter
= 1 << atoi (iter_pos
);
9516 char *salt_pos
= strchr (iter_pos
, '$');
9518 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9524 salt
->salt_len
= salt_len
;
9526 u8 tmp_buf
[100] = { 0 };
9528 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9530 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9532 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9534 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9535 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9536 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9537 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9539 char *hash_pos
= salt_pos
+ 22;
9541 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9543 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9545 memcpy (digest
, tmp_buf
, 24);
9547 digest
[0] = byte_swap_32 (digest
[0]);
9548 digest
[1] = byte_swap_32 (digest
[1]);
9549 digest
[2] = byte_swap_32 (digest
[2]);
9550 digest
[3] = byte_swap_32 (digest
[3]);
9551 digest
[4] = byte_swap_32 (digest
[4]);
9552 digest
[5] = byte_swap_32 (digest
[5]);
9554 digest
[5] &= ~0xff; // its just 23 not 24 !
9559 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9561 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9563 u32
*digest
= (u32
*) hash_buf
->digest
;
9565 u8 tmp_buf
[100] = { 0 };
9567 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9569 memcpy (digest
, tmp_buf
, 32);
9571 digest
[0] = byte_swap_32 (digest
[0]);
9572 digest
[1] = byte_swap_32 (digest
[1]);
9573 digest
[2] = byte_swap_32 (digest
[2]);
9574 digest
[3] = byte_swap_32 (digest
[3]);
9575 digest
[4] = byte_swap_32 (digest
[4]);
9576 digest
[5] = byte_swap_32 (digest
[5]);
9577 digest
[6] = byte_swap_32 (digest
[6]);
9578 digest
[7] = byte_swap_32 (digest
[7]);
9580 digest
[0] -= SHA256M_A
;
9581 digest
[1] -= SHA256M_B
;
9582 digest
[2] -= SHA256M_C
;
9583 digest
[3] -= SHA256M_D
;
9584 digest
[4] -= SHA256M_E
;
9585 digest
[5] -= SHA256M_F
;
9586 digest
[6] -= SHA256M_G
;
9587 digest
[7] -= SHA256M_H
;
9592 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9594 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9596 u32
*digest
= (u32
*) hash_buf
->digest
;
9598 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9599 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9601 digest
[0] = byte_swap_32 (digest
[0]);
9602 digest
[1] = byte_swap_32 (digest
[1]);
9606 IP (digest
[0], digest
[1], tt
);
9608 digest
[0] = digest
[0];
9609 digest
[1] = digest
[1];
9616 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9618 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9620 u32
*digest
= (u32
*) hash_buf
->digest
;
9622 salt_t
*salt
= hash_buf
->salt
;
9624 char *hash_pos
= input_buf
+ 8;
9626 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9627 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9628 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9629 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9630 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9632 digest
[0] -= SHA1M_A
;
9633 digest
[1] -= SHA1M_B
;
9634 digest
[2] -= SHA1M_C
;
9635 digest
[3] -= SHA1M_D
;
9636 digest
[4] -= SHA1M_E
;
9640 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9642 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9644 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9646 salt
->salt_len
= salt_len
;
9651 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9653 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9655 u64
*digest
= (u64
*) hash_buf
->digest
;
9657 salt_t
*salt
= hash_buf
->salt
;
9659 char *hash_pos
= input_buf
+ 8;
9661 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9662 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9663 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9664 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9665 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9666 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9667 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9668 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9670 digest
[0] -= SHA512M_A
;
9671 digest
[1] -= SHA512M_B
;
9672 digest
[2] -= SHA512M_C
;
9673 digest
[3] -= SHA512M_D
;
9674 digest
[4] -= SHA512M_E
;
9675 digest
[5] -= SHA512M_F
;
9676 digest
[6] -= SHA512M_G
;
9677 digest
[7] -= SHA512M_H
;
9681 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9683 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9685 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9687 salt
->salt_len
= salt_len
;
9692 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9694 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9696 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9700 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9703 u32
*digest
= (u32
*) hash_buf
->digest
;
9705 salt_t
*salt
= hash_buf
->salt
;
9707 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9708 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9709 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9710 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9712 digest
[0] = byte_swap_32 (digest
[0]);
9713 digest
[1] = byte_swap_32 (digest
[1]);
9714 digest
[2] = byte_swap_32 (digest
[2]);
9715 digest
[3] = byte_swap_32 (digest
[3]);
9717 digest
[0] -= MD5M_A
;
9718 digest
[1] -= MD5M_B
;
9719 digest
[2] -= MD5M_C
;
9720 digest
[3] -= MD5M_D
;
9722 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9724 uint salt_len
= input_len
- 32 - 1;
9726 char *salt_buf
= input_buf
+ 32 + 1;
9728 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9730 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9732 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9734 salt
->salt_len
= salt_len
;
9739 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9741 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9743 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9747 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9752 char clean_input_buf
[32] = { 0 };
9754 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9755 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9757 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9761 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9767 clean_input_buf
[k
] = input_buf
[i
];
9775 u32
*digest
= (u32
*) hash_buf
->digest
;
9777 salt_t
*salt
= hash_buf
->salt
;
9779 u32 a
, b
, c
, d
, e
, f
;
9781 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9782 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9783 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9784 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9785 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9786 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9788 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9789 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9791 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9792 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9793 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9794 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9795 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9796 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9798 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9799 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9801 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9802 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9803 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9804 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9805 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9806 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9808 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9809 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9811 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9812 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9813 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9814 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9815 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9816 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9818 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9819 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9821 digest
[0] = byte_swap_32 (digest
[0]);
9822 digest
[1] = byte_swap_32 (digest
[1]);
9823 digest
[2] = byte_swap_32 (digest
[2]);
9824 digest
[3] = byte_swap_32 (digest
[3]);
9826 digest
[0] -= MD5M_A
;
9827 digest
[1] -= MD5M_B
;
9828 digest
[2] -= MD5M_C
;
9829 digest
[3] -= MD5M_D
;
9831 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9833 uint salt_len
= input_len
- 30 - 1;
9835 char *salt_buf
= input_buf
+ 30 + 1;
9837 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9839 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9841 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9842 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9844 salt
->salt_len
= salt_len
;
9846 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9848 salt
->salt_len
+= 22;
9853 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9855 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9857 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9861 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9864 u32
*digest
= (u32
*) hash_buf
->digest
;
9866 salt_t
*salt
= hash_buf
->salt
;
9868 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9869 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9870 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9871 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9872 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9874 digest
[0] -= SHA1M_A
;
9875 digest
[1] -= SHA1M_B
;
9876 digest
[2] -= SHA1M_C
;
9877 digest
[3] -= SHA1M_D
;
9878 digest
[4] -= SHA1M_E
;
9880 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9882 uint salt_len
= input_len
- 40 - 1;
9884 char *salt_buf
= input_buf
+ 40 + 1;
9886 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9888 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9890 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9892 salt
->salt_len
= salt_len
;
9897 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9899 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9901 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9905 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9908 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9910 char *iter_pos
= input_buf
+ 6;
9912 salt_t
*salt
= hash_buf
->salt
;
9914 uint iter
= atoi (iter_pos
);
9921 salt
->salt_iter
= iter
- 1;
9923 char *salt_pos
= strchr (iter_pos
, '#');
9925 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9929 char *digest_pos
= strchr (salt_pos
, '#');
9931 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9935 uint salt_len
= digest_pos
- salt_pos
- 1;
9937 u32
*digest
= (u32
*) hash_buf
->digest
;
9939 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9940 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9941 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9942 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9944 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9946 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9948 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9950 salt
->salt_len
= salt_len
;
9955 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9957 u32
*digest
= (u32
*) hash_buf
->digest
;
9959 salt_t
*salt
= hash_buf
->salt
;
9961 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9965 memcpy (&in
, input_buf
, input_len
);
9967 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9969 memcpy (digest
, in
.keymic
, 16);
9972 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9973 The phrase "Pairwise key expansion"
9974 Access Point Address (referred to as Authenticator Address AA)
9975 Supplicant Address (referred to as Supplicant Address SA)
9976 Access Point Nonce (referred to as Authenticator Anonce)
9977 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9980 uint salt_len
= strlen (in
.essid
);
9982 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9984 salt
->salt_len
= salt_len
;
9986 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9988 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9990 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9992 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9994 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9995 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9999 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10000 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10003 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10005 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10006 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10010 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10011 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10014 for (int i
= 0; i
< 25; i
++)
10016 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10019 wpa
->keyver
= in
.keyver
;
10021 if (wpa
->keyver
> 255)
10023 log_info ("ATTENTION!");
10024 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10025 log_info (" This could be due to a recent aircrack-ng bug.");
10026 log_info (" The key version was automatically reset to a reasonable value.");
10029 wpa
->keyver
&= 0xff;
10032 wpa
->eapol_size
= in
.eapol_size
;
10034 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10036 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10038 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10040 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10042 if (wpa
->keyver
== 1)
10048 digest
[0] = byte_swap_32 (digest
[0]);
10049 digest
[1] = byte_swap_32 (digest
[1]);
10050 digest
[2] = byte_swap_32 (digest
[2]);
10051 digest
[3] = byte_swap_32 (digest
[3]);
10053 for (int i
= 0; i
< 64; i
++)
10055 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10059 salt
->salt_buf
[10] = digest
[1];
10060 salt
->salt_buf
[11] = digest
[2];
10062 return (PARSER_OK
);
10065 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10067 u32
*digest
= (u32
*) hash_buf
->digest
;
10069 salt_t
*salt
= hash_buf
->salt
;
10071 if (input_len
== 0)
10073 log_error ("Password Safe v2 container not specified");
10078 FILE *fp
= fopen (input_buf
, "rb");
10082 log_error ("%s: %s", input_buf
, strerror (errno
));
10089 memset (&buf
, 0, sizeof (psafe2_hdr
));
10091 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10095 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10097 salt
->salt_buf
[0] = buf
.random
[0];
10098 salt
->salt_buf
[1] = buf
.random
[1];
10100 salt
->salt_len
= 8;
10101 salt
->salt_iter
= 1000;
10103 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10104 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10105 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10106 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10107 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10109 return (PARSER_OK
);
10112 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10114 u32
*digest
= (u32
*) hash_buf
->digest
;
10116 salt_t
*salt
= hash_buf
->salt
;
10118 if (input_len
== 0)
10120 log_error (".psafe3 not specified");
10125 FILE *fp
= fopen (input_buf
, "rb");
10129 log_error ("%s: %s", input_buf
, strerror (errno
));
10136 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10140 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10142 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10144 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10146 salt
->salt_iter
= in
.iterations
+ 1;
10148 salt
->salt_buf
[0] = in
.salt_buf
[0];
10149 salt
->salt_buf
[1] = in
.salt_buf
[1];
10150 salt
->salt_buf
[2] = in
.salt_buf
[2];
10151 salt
->salt_buf
[3] = in
.salt_buf
[3];
10152 salt
->salt_buf
[4] = in
.salt_buf
[4];
10153 salt
->salt_buf
[5] = in
.salt_buf
[5];
10154 salt
->salt_buf
[6] = in
.salt_buf
[6];
10155 salt
->salt_buf
[7] = in
.salt_buf
[7];
10157 salt
->salt_len
= 32;
10159 digest
[0] = in
.hash_buf
[0];
10160 digest
[1] = in
.hash_buf
[1];
10161 digest
[2] = in
.hash_buf
[2];
10162 digest
[3] = in
.hash_buf
[3];
10163 digest
[4] = in
.hash_buf
[4];
10164 digest
[5] = in
.hash_buf
[5];
10165 digest
[6] = in
.hash_buf
[6];
10166 digest
[7] = in
.hash_buf
[7];
10168 digest
[0] = byte_swap_32 (digest
[0]);
10169 digest
[1] = byte_swap_32 (digest
[1]);
10170 digest
[2] = byte_swap_32 (digest
[2]);
10171 digest
[3] = byte_swap_32 (digest
[3]);
10172 digest
[4] = byte_swap_32 (digest
[4]);
10173 digest
[5] = byte_swap_32 (digest
[5]);
10174 digest
[6] = byte_swap_32 (digest
[6]);
10175 digest
[7] = byte_swap_32 (digest
[7]);
10177 return (PARSER_OK
);
10180 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10182 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10184 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10186 u32
*digest
= (u32
*) hash_buf
->digest
;
10188 salt_t
*salt
= hash_buf
->salt
;
10190 char *iter_pos
= input_buf
+ 3;
10192 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10194 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10196 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10198 salt
->salt_iter
= salt_iter
;
10200 char *salt_pos
= iter_pos
+ 1;
10204 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10206 salt
->salt_len
= salt_len
;
10208 char *hash_pos
= salt_pos
+ salt_len
;
10210 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10212 return (PARSER_OK
);
10215 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10217 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10219 u32
*digest
= (u32
*) hash_buf
->digest
;
10221 salt_t
*salt
= hash_buf
->salt
;
10223 char *salt_pos
= input_buf
+ 3;
10225 uint iterations_len
= 0;
10227 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10231 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10233 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10234 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10238 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10242 iterations_len
+= 8;
10246 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10249 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10251 char *hash_pos
= strchr (salt_pos
, '$');
10253 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10255 uint salt_len
= hash_pos
- salt_pos
;
10257 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10259 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10261 salt
->salt_len
= salt_len
;
10265 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10267 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10269 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10271 return (PARSER_OK
);
10274 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10276 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10278 u32
*digest
= (u32
*) hash_buf
->digest
;
10280 salt_t
*salt
= hash_buf
->salt
;
10282 char *salt_pos
= input_buf
+ 6;
10284 uint iterations_len
= 0;
10286 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10290 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10292 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10293 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10297 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10301 iterations_len
+= 8;
10305 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10308 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10310 char *hash_pos
= strchr (salt_pos
, '$');
10312 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10314 uint salt_len
= hash_pos
- salt_pos
;
10316 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10318 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10320 salt
->salt_len
= salt_len
;
10324 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10326 return (PARSER_OK
);
10329 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10331 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10333 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10335 u32
*digest
= (u32
*) hash_buf
->digest
;
10337 salt_t
*salt
= hash_buf
->salt
;
10339 char *salt_pos
= input_buf
+ 14;
10341 char *hash_pos
= strchr (salt_pos
, '*');
10343 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10347 uint salt_len
= hash_pos
- salt_pos
- 1;
10349 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10351 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10353 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10355 salt
->salt_len
= salt_len
;
10357 u8 tmp_buf
[100] = { 0 };
10359 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10361 memcpy (digest
, tmp_buf
, 20);
10363 digest
[0] = byte_swap_32 (digest
[0]);
10364 digest
[1] = byte_swap_32 (digest
[1]);
10365 digest
[2] = byte_swap_32 (digest
[2]);
10366 digest
[3] = byte_swap_32 (digest
[3]);
10367 digest
[4] = byte_swap_32 (digest
[4]);
10369 digest
[0] -= SHA1M_A
;
10370 digest
[1] -= SHA1M_B
;
10371 digest
[2] -= SHA1M_C
;
10372 digest
[3] -= SHA1M_D
;
10373 digest
[4] -= SHA1M_E
;
10375 return (PARSER_OK
);
10378 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10380 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10382 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10384 if (c12
& 3) return (PARSER_HASH_VALUE
);
10386 u32
*digest
= (u32
*) hash_buf
->digest
;
10388 salt_t
*salt
= hash_buf
->salt
;
10390 // for ascii_digest
10391 salt
->salt_sign
[0] = input_buf
[0];
10392 salt
->salt_sign
[1] = input_buf
[1];
10394 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10395 | itoa64_to_int (input_buf
[1]) << 6;
10397 salt
->salt_len
= 2;
10399 u8 tmp_buf
[100] = { 0 };
10401 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10403 memcpy (digest
, tmp_buf
, 8);
10407 IP (digest
[0], digest
[1], tt
);
10412 return (PARSER_OK
);
10415 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10417 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10419 u32
*digest
= (u32
*) hash_buf
->digest
;
10421 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10422 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10423 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10424 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10426 digest
[0] = byte_swap_32 (digest
[0]);
10427 digest
[1] = byte_swap_32 (digest
[1]);
10428 digest
[2] = byte_swap_32 (digest
[2]);
10429 digest
[3] = byte_swap_32 (digest
[3]);
10431 digest
[0] -= MD4M_A
;
10432 digest
[1] -= MD4M_B
;
10433 digest
[2] -= MD4M_C
;
10434 digest
[3] -= MD4M_D
;
10436 return (PARSER_OK
);
10439 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10441 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10443 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10447 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10450 u32
*digest
= (u32
*) hash_buf
->digest
;
10452 salt_t
*salt
= hash_buf
->salt
;
10454 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10455 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10456 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10457 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10459 digest
[0] = byte_swap_32 (digest
[0]);
10460 digest
[1] = byte_swap_32 (digest
[1]);
10461 digest
[2] = byte_swap_32 (digest
[2]);
10462 digest
[3] = byte_swap_32 (digest
[3]);
10464 digest
[0] -= MD4M_A
;
10465 digest
[1] -= MD4M_B
;
10466 digest
[2] -= MD4M_C
;
10467 digest
[3] -= MD4M_D
;
10469 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10471 uint salt_len
= input_len
- 32 - 1;
10473 char *salt_buf
= input_buf
+ 32 + 1;
10475 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10477 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10479 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10481 salt
->salt_len
= salt_len
;
10483 return (PARSER_OK
);
10486 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10488 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10490 u32
*digest
= (u32
*) hash_buf
->digest
;
10492 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10493 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10494 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10495 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10497 digest
[0] = byte_swap_32 (digest
[0]);
10498 digest
[1] = byte_swap_32 (digest
[1]);
10499 digest
[2] = byte_swap_32 (digest
[2]);
10500 digest
[3] = byte_swap_32 (digest
[3]);
10502 digest
[0] -= MD5M_A
;
10503 digest
[1] -= MD5M_B
;
10504 digest
[2] -= MD5M_C
;
10505 digest
[3] -= MD5M_D
;
10507 return (PARSER_OK
);
10510 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10512 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10514 u32
*digest
= (u32
*) hash_buf
->digest
;
10516 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10517 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10521 digest
[0] = byte_swap_32 (digest
[0]);
10522 digest
[1] = byte_swap_32 (digest
[1]);
10524 return (PARSER_OK
);
10527 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10529 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10531 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10535 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10538 u32
*digest
= (u32
*) hash_buf
->digest
;
10540 salt_t
*salt
= hash_buf
->salt
;
10542 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10543 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10544 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10545 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10547 digest
[0] = byte_swap_32 (digest
[0]);
10548 digest
[1] = byte_swap_32 (digest
[1]);
10549 digest
[2] = byte_swap_32 (digest
[2]);
10550 digest
[3] = byte_swap_32 (digest
[3]);
10552 digest
[0] -= MD5M_A
;
10553 digest
[1] -= MD5M_B
;
10554 digest
[2] -= MD5M_C
;
10555 digest
[3] -= MD5M_D
;
10557 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10559 uint salt_len
= input_len
- 32 - 1;
10561 char *salt_buf
= input_buf
+ 32 + 1;
10563 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10565 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10567 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10569 salt
->salt_len
= salt_len
;
10571 return (PARSER_OK
);
10574 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10576 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10578 u32
*digest
= (u32
*) hash_buf
->digest
;
10580 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10581 | itoa64_to_int (input_buf
[ 1]) << 6
10582 | itoa64_to_int (input_buf
[ 2]) << 12
10583 | itoa64_to_int (input_buf
[ 3]) << 18;
10584 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10585 | itoa64_to_int (input_buf
[ 5]) << 6
10586 | itoa64_to_int (input_buf
[ 6]) << 12
10587 | itoa64_to_int (input_buf
[ 7]) << 18;
10588 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10589 | itoa64_to_int (input_buf
[ 9]) << 6
10590 | itoa64_to_int (input_buf
[10]) << 12
10591 | itoa64_to_int (input_buf
[11]) << 18;
10592 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10593 | itoa64_to_int (input_buf
[13]) << 6
10594 | itoa64_to_int (input_buf
[14]) << 12
10595 | itoa64_to_int (input_buf
[15]) << 18;
10597 digest
[0] -= MD5M_A
;
10598 digest
[1] -= MD5M_B
;
10599 digest
[2] -= MD5M_C
;
10600 digest
[3] -= MD5M_D
;
10602 digest
[0] &= 0x00ffffff;
10603 digest
[1] &= 0x00ffffff;
10604 digest
[2] &= 0x00ffffff;
10605 digest
[3] &= 0x00ffffff;
10607 return (PARSER_OK
);
10610 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10612 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10614 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10618 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10621 u32
*digest
= (u32
*) hash_buf
->digest
;
10623 salt_t
*salt
= hash_buf
->salt
;
10625 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10626 | itoa64_to_int (input_buf
[ 1]) << 6
10627 | itoa64_to_int (input_buf
[ 2]) << 12
10628 | itoa64_to_int (input_buf
[ 3]) << 18;
10629 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10630 | itoa64_to_int (input_buf
[ 5]) << 6
10631 | itoa64_to_int (input_buf
[ 6]) << 12
10632 | itoa64_to_int (input_buf
[ 7]) << 18;
10633 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10634 | itoa64_to_int (input_buf
[ 9]) << 6
10635 | itoa64_to_int (input_buf
[10]) << 12
10636 | itoa64_to_int (input_buf
[11]) << 18;
10637 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10638 | itoa64_to_int (input_buf
[13]) << 6
10639 | itoa64_to_int (input_buf
[14]) << 12
10640 | itoa64_to_int (input_buf
[15]) << 18;
10642 digest
[0] -= MD5M_A
;
10643 digest
[1] -= MD5M_B
;
10644 digest
[2] -= MD5M_C
;
10645 digest
[3] -= MD5M_D
;
10647 digest
[0] &= 0x00ffffff;
10648 digest
[1] &= 0x00ffffff;
10649 digest
[2] &= 0x00ffffff;
10650 digest
[3] &= 0x00ffffff;
10652 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10654 uint salt_len
= input_len
- 16 - 1;
10656 char *salt_buf
= input_buf
+ 16 + 1;
10658 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10660 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10662 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10664 salt
->salt_len
= salt_len
;
10666 return (PARSER_OK
);
10669 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10671 key
[0] = (nthash
[0] >> 0);
10672 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10673 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10674 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10675 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10676 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10677 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10678 key
[7] = (nthash
[6] << 1);
10690 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10692 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10694 u32
*digest
= (u32
*) hash_buf
->digest
;
10696 salt_t
*salt
= hash_buf
->salt
;
10698 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10704 char *user_pos
= input_buf
;
10706 char *unused_pos
= strchr (user_pos
, ':');
10708 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10710 uint user_len
= unused_pos
- user_pos
;
10712 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10716 char *domain_pos
= strchr (unused_pos
, ':');
10718 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10720 uint unused_len
= domain_pos
- unused_pos
;
10722 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10726 char *srvchall_pos
= strchr (domain_pos
, ':');
10728 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10730 uint domain_len
= srvchall_pos
- domain_pos
;
10732 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10736 char *hash_pos
= strchr (srvchall_pos
, ':');
10738 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10740 uint srvchall_len
= hash_pos
- srvchall_pos
;
10742 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10746 char *clichall_pos
= strchr (hash_pos
, ':');
10748 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10750 uint hash_len
= clichall_pos
- hash_pos
;
10752 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10756 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10758 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10761 * store some data for later use
10764 netntlm
->user_len
= user_len
* 2;
10765 netntlm
->domain_len
= domain_len
* 2;
10766 netntlm
->srvchall_len
= srvchall_len
/ 2;
10767 netntlm
->clichall_len
= clichall_len
/ 2;
10769 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10770 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10773 * handle username and domainname
10776 for (uint i
= 0; i
< user_len
; i
++)
10778 *userdomain_ptr
++ = user_pos
[i
];
10779 *userdomain_ptr
++ = 0;
10782 for (uint i
= 0; i
< domain_len
; i
++)
10784 *userdomain_ptr
++ = domain_pos
[i
];
10785 *userdomain_ptr
++ = 0;
10789 * handle server challenge encoding
10792 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10794 const char p0
= srvchall_pos
[i
+ 0];
10795 const char p1
= srvchall_pos
[i
+ 1];
10797 *chall_ptr
++ = hex_convert (p1
) << 0
10798 | hex_convert (p0
) << 4;
10802 * handle client challenge encoding
10805 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10807 const char p0
= clichall_pos
[i
+ 0];
10808 const char p1
= clichall_pos
[i
+ 1];
10810 *chall_ptr
++ = hex_convert (p1
) << 0
10811 | hex_convert (p0
) << 4;
10818 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10820 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10822 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10824 salt
->salt_len
= salt_len
;
10826 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10827 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10828 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10829 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10831 digest
[0] = byte_swap_32 (digest
[0]);
10832 digest
[1] = byte_swap_32 (digest
[1]);
10833 digest
[2] = byte_swap_32 (digest
[2]);
10834 digest
[3] = byte_swap_32 (digest
[3]);
10836 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10838 uint digest_tmp
[2] = { 0 };
10840 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10841 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10843 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10844 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10846 /* special case 2: ESS */
10848 if (srvchall_len
== 48)
10850 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10852 uint w
[16] = { 0 };
10854 w
[ 0] = netntlm
->chall_buf
[6];
10855 w
[ 1] = netntlm
->chall_buf
[7];
10856 w
[ 2] = netntlm
->chall_buf
[0];
10857 w
[ 3] = netntlm
->chall_buf
[1];
10861 uint dgst
[4] = { 0 };
10870 salt
->salt_buf
[0] = dgst
[0];
10871 salt
->salt_buf
[1] = dgst
[1];
10875 /* precompute netntlmv1 exploit start */
10877 for (uint i
= 0; i
< 0x10000; i
++)
10879 uint key_md4
[2] = { i
, 0 };
10880 uint key_des
[2] = { 0, 0 };
10882 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10884 uint Kc
[16] = { 0 };
10885 uint Kd
[16] = { 0 };
10887 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10889 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10891 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10893 if (data3
[0] != digest_tmp
[0]) continue;
10894 if (data3
[1] != digest_tmp
[1]) continue;
10896 salt
->salt_buf
[2] = i
;
10898 salt
->salt_len
= 24;
10903 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10904 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10906 /* precompute netntlmv1 exploit stop */
10910 IP (digest
[0], digest
[1], tt
);
10911 IP (digest
[2], digest
[3], tt
);
10913 digest
[0] = rotr32 (digest
[0], 29);
10914 digest
[1] = rotr32 (digest
[1], 29);
10915 digest
[2] = rotr32 (digest
[2], 29);
10916 digest
[3] = rotr32 (digest
[3], 29);
10918 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10920 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10921 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10923 return (PARSER_OK
);
10926 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10928 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10930 u32
*digest
= (u32
*) hash_buf
->digest
;
10932 salt_t
*salt
= hash_buf
->salt
;
10934 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10940 char *user_pos
= input_buf
;
10942 char *unused_pos
= strchr (user_pos
, ':');
10944 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10946 uint user_len
= unused_pos
- user_pos
;
10948 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10952 char *domain_pos
= strchr (unused_pos
, ':');
10954 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10956 uint unused_len
= domain_pos
- unused_pos
;
10958 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10962 char *srvchall_pos
= strchr (domain_pos
, ':');
10964 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10966 uint domain_len
= srvchall_pos
- domain_pos
;
10968 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10972 char *hash_pos
= strchr (srvchall_pos
, ':');
10974 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10976 uint srvchall_len
= hash_pos
- srvchall_pos
;
10978 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10982 char *clichall_pos
= strchr (hash_pos
, ':');
10984 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10986 uint hash_len
= clichall_pos
- hash_pos
;
10988 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10992 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10994 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10996 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10999 * store some data for later use
11002 netntlm
->user_len
= user_len
* 2;
11003 netntlm
->domain_len
= domain_len
* 2;
11004 netntlm
->srvchall_len
= srvchall_len
/ 2;
11005 netntlm
->clichall_len
= clichall_len
/ 2;
11007 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11008 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11011 * handle username and domainname
11014 for (uint i
= 0; i
< user_len
; i
++)
11016 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11017 *userdomain_ptr
++ = 0;
11020 for (uint i
= 0; i
< domain_len
; i
++)
11022 *userdomain_ptr
++ = domain_pos
[i
];
11023 *userdomain_ptr
++ = 0;
11026 *userdomain_ptr
++ = 0x80;
11029 * handle server challenge encoding
11032 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11034 const char p0
= srvchall_pos
[i
+ 0];
11035 const char p1
= srvchall_pos
[i
+ 1];
11037 *chall_ptr
++ = hex_convert (p1
) << 0
11038 | hex_convert (p0
) << 4;
11042 * handle client challenge encoding
11045 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11047 const char p0
= clichall_pos
[i
+ 0];
11048 const char p1
= clichall_pos
[i
+ 1];
11050 *chall_ptr
++ = hex_convert (p1
) << 0
11051 | hex_convert (p0
) << 4;
11054 *chall_ptr
++ = 0x80;
11057 * handle hash itself
11060 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11061 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11062 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11063 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11065 digest
[0] = byte_swap_32 (digest
[0]);
11066 digest
[1] = byte_swap_32 (digest
[1]);
11067 digest
[2] = byte_swap_32 (digest
[2]);
11068 digest
[3] = byte_swap_32 (digest
[3]);
11071 * reuse challange data as salt_buf, its the buffer that is most likely unique
11074 salt
->salt_buf
[0] = 0;
11075 salt
->salt_buf
[1] = 0;
11076 salt
->salt_buf
[2] = 0;
11077 salt
->salt_buf
[3] = 0;
11078 salt
->salt_buf
[4] = 0;
11079 salt
->salt_buf
[5] = 0;
11080 salt
->salt_buf
[6] = 0;
11081 salt
->salt_buf
[7] = 0;
11085 uptr
= (uint
*) netntlm
->userdomain_buf
;
11087 for (uint i
= 0; i
< 16; i
+= 16)
11089 md5_64 (uptr
, salt
->salt_buf
);
11092 uptr
= (uint
*) netntlm
->chall_buf
;
11094 for (uint i
= 0; i
< 256; i
+= 16)
11096 md5_64 (uptr
, salt
->salt_buf
);
11099 salt
->salt_len
= 16;
11101 return (PARSER_OK
);
11104 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11106 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11108 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11112 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11115 u32
*digest
= (u32
*) hash_buf
->digest
;
11117 salt_t
*salt
= hash_buf
->salt
;
11119 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11120 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11121 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11122 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11124 digest
[0] = byte_swap_32 (digest
[0]);
11125 digest
[1] = byte_swap_32 (digest
[1]);
11126 digest
[2] = byte_swap_32 (digest
[2]);
11127 digest
[3] = byte_swap_32 (digest
[3]);
11129 digest
[0] -= MD5M_A
;
11130 digest
[1] -= MD5M_B
;
11131 digest
[2] -= MD5M_C
;
11132 digest
[3] -= MD5M_D
;
11134 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11136 uint salt_len
= input_len
- 32 - 1;
11138 char *salt_buf
= input_buf
+ 32 + 1;
11140 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11142 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11144 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11146 salt
->salt_len
= salt_len
;
11148 return (PARSER_OK
);
11151 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11153 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11155 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11159 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11162 u32
*digest
= (u32
*) hash_buf
->digest
;
11164 salt_t
*salt
= hash_buf
->salt
;
11166 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11167 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11168 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11169 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11171 digest
[0] = byte_swap_32 (digest
[0]);
11172 digest
[1] = byte_swap_32 (digest
[1]);
11173 digest
[2] = byte_swap_32 (digest
[2]);
11174 digest
[3] = byte_swap_32 (digest
[3]);
11176 digest
[0] -= MD5M_A
;
11177 digest
[1] -= MD5M_B
;
11178 digest
[2] -= MD5M_C
;
11179 digest
[3] -= MD5M_D
;
11181 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11183 uint salt_len
= input_len
- 32 - 1;
11185 char *salt_buf
= input_buf
+ 32 + 1;
11187 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11189 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11191 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11193 salt
->salt_len
= salt_len
;
11195 return (PARSER_OK
);
11198 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11200 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11202 u32
*digest
= (u32
*) hash_buf
->digest
;
11204 salt_t
*salt
= hash_buf
->salt
;
11206 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11207 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11208 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11209 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11211 digest
[0] = byte_swap_32 (digest
[0]);
11212 digest
[1] = byte_swap_32 (digest
[1]);
11213 digest
[2] = byte_swap_32 (digest
[2]);
11214 digest
[3] = byte_swap_32 (digest
[3]);
11216 digest
[0] -= MD5M_A
;
11217 digest
[1] -= MD5M_B
;
11218 digest
[2] -= MD5M_C
;
11219 digest
[3] -= MD5M_D
;
11222 * This is a virtual salt. While the algorithm is basically not salted
11223 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11224 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11227 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11229 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11231 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11233 salt
->salt_len
= salt_len
;
11235 return (PARSER_OK
);
11238 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11240 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11242 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11246 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11249 u32
*digest
= (u32
*) hash_buf
->digest
;
11251 salt_t
*salt
= hash_buf
->salt
;
11253 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11254 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11255 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11256 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11258 digest
[0] = byte_swap_32 (digest
[0]);
11259 digest
[1] = byte_swap_32 (digest
[1]);
11260 digest
[2] = byte_swap_32 (digest
[2]);
11261 digest
[3] = byte_swap_32 (digest
[3]);
11263 digest
[0] -= MD5M_A
;
11264 digest
[1] -= MD5M_B
;
11265 digest
[2] -= MD5M_C
;
11266 digest
[3] -= MD5M_D
;
11268 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11270 uint salt_len
= input_len
- 32 - 1;
11272 char *salt_buf
= input_buf
+ 32 + 1;
11274 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11276 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11278 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11280 salt
->salt_len
= salt_len
;
11282 return (PARSER_OK
);
11285 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11287 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11289 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11293 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11296 u32
*digest
= (u32
*) hash_buf
->digest
;
11298 salt_t
*salt
= hash_buf
->salt
;
11300 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11301 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11302 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11303 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11305 digest
[0] = byte_swap_32 (digest
[0]);
11306 digest
[1] = byte_swap_32 (digest
[1]);
11307 digest
[2] = byte_swap_32 (digest
[2]);
11308 digest
[3] = byte_swap_32 (digest
[3]);
11310 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11312 uint salt_len
= input_len
- 32 - 1;
11314 char *salt_buf
= input_buf
+ 32 + 1;
11316 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11318 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11320 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11322 salt
->salt_len
= salt_len
;
11324 return (PARSER_OK
);
11327 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11329 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11331 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11335 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11338 u32
*digest
= (u32
*) hash_buf
->digest
;
11340 salt_t
*salt
= hash_buf
->salt
;
11342 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11343 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11344 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11345 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11347 digest
[0] = byte_swap_32 (digest
[0]);
11348 digest
[1] = byte_swap_32 (digest
[1]);
11349 digest
[2] = byte_swap_32 (digest
[2]);
11350 digest
[3] = byte_swap_32 (digest
[3]);
11352 digest
[0] -= MD4M_A
;
11353 digest
[1] -= MD4M_B
;
11354 digest
[2] -= MD4M_C
;
11355 digest
[3] -= MD4M_D
;
11357 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11359 uint salt_len
= input_len
- 32 - 1;
11361 char *salt_buf
= input_buf
+ 32 + 1;
11363 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11365 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11367 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11369 salt
->salt_len
= salt_len
;
11371 return (PARSER_OK
);
11374 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11376 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11378 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11382 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11385 u32
*digest
= (u32
*) hash_buf
->digest
;
11387 salt_t
*salt
= hash_buf
->salt
;
11389 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11390 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11391 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11392 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11394 digest
[0] = byte_swap_32 (digest
[0]);
11395 digest
[1] = byte_swap_32 (digest
[1]);
11396 digest
[2] = byte_swap_32 (digest
[2]);
11397 digest
[3] = byte_swap_32 (digest
[3]);
11399 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11401 uint salt_len
= input_len
- 32 - 1;
11403 char *salt_buf
= input_buf
+ 32 + 1;
11405 uint salt_pc_block
[16] = { 0 };
11407 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11409 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11411 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11413 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11415 salt_pc_block
[14] = salt_len
* 8;
11417 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11419 md5_64 (salt_pc_block
, salt_pc_digest
);
11421 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11422 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11423 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11424 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11426 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11428 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11430 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11432 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11433 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11434 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11435 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11437 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11439 return (PARSER_OK
);
11442 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11444 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11446 u32
*digest
= (u32
*) hash_buf
->digest
;
11448 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11449 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11450 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11451 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11452 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11454 digest
[0] -= SHA1M_A
;
11455 digest
[1] -= SHA1M_B
;
11456 digest
[2] -= SHA1M_C
;
11457 digest
[3] -= SHA1M_D
;
11458 digest
[4] -= SHA1M_E
;
11460 return (PARSER_OK
);
11463 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11465 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11467 u32
*digest
= (u32
*) hash_buf
->digest
;
11469 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11470 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11471 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11472 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11473 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11475 return (PARSER_OK
);
11478 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11480 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11482 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11486 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11489 u32
*digest
= (u32
*) hash_buf
->digest
;
11491 salt_t
*salt
= hash_buf
->salt
;
11493 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11494 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11495 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11496 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11497 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11499 digest
[0] -= SHA1M_A
;
11500 digest
[1] -= SHA1M_B
;
11501 digest
[2] -= SHA1M_C
;
11502 digest
[3] -= SHA1M_D
;
11503 digest
[4] -= SHA1M_E
;
11505 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11507 uint salt_len
= input_len
- 40 - 1;
11509 char *salt_buf
= input_buf
+ 40 + 1;
11511 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11513 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11515 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11517 salt
->salt_len
= salt_len
;
11519 return (PARSER_OK
);
11522 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11524 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11526 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11528 u32
*digest
= (u32
*) hash_buf
->digest
;
11530 u8 tmp_buf
[100] = { 0 };
11532 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11534 memcpy (digest
, tmp_buf
, 20);
11536 digest
[0] = byte_swap_32 (digest
[0]);
11537 digest
[1] = byte_swap_32 (digest
[1]);
11538 digest
[2] = byte_swap_32 (digest
[2]);
11539 digest
[3] = byte_swap_32 (digest
[3]);
11540 digest
[4] = byte_swap_32 (digest
[4]);
11542 digest
[0] -= SHA1M_A
;
11543 digest
[1] -= SHA1M_B
;
11544 digest
[2] -= SHA1M_C
;
11545 digest
[3] -= SHA1M_D
;
11546 digest
[4] -= SHA1M_E
;
11548 return (PARSER_OK
);
11551 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11553 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11555 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11557 u32
*digest
= (u32
*) hash_buf
->digest
;
11559 salt_t
*salt
= hash_buf
->salt
;
11561 u8 tmp_buf
[100] = { 0 };
11563 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11565 memcpy (digest
, tmp_buf
, 20);
11567 salt
->salt_len
= tmp_len
- 20;
11569 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11571 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11573 char *ptr
= (char *) salt
->salt_buf
;
11575 ptr
[salt
->salt_len
] = 0x80;
11578 digest
[0] = byte_swap_32 (digest
[0]);
11579 digest
[1] = byte_swap_32 (digest
[1]);
11580 digest
[2] = byte_swap_32 (digest
[2]);
11581 digest
[3] = byte_swap_32 (digest
[3]);
11582 digest
[4] = byte_swap_32 (digest
[4]);
11584 digest
[0] -= SHA1M_A
;
11585 digest
[1] -= SHA1M_B
;
11586 digest
[2] -= SHA1M_C
;
11587 digest
[3] -= SHA1M_D
;
11588 digest
[4] -= SHA1M_E
;
11590 return (PARSER_OK
);
11593 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11595 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11597 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11599 u32
*digest
= (u32
*) hash_buf
->digest
;
11601 salt_t
*salt
= hash_buf
->salt
;
11603 char *salt_buf
= input_buf
+ 6;
11607 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11609 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11611 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11613 salt
->salt_len
= salt_len
;
11615 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11617 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11618 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11619 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11620 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11621 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11623 digest
[0] -= SHA1M_A
;
11624 digest
[1] -= SHA1M_B
;
11625 digest
[2] -= SHA1M_C
;
11626 digest
[3] -= SHA1M_D
;
11627 digest
[4] -= SHA1M_E
;
11629 return (PARSER_OK
);
11632 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11634 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11636 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11638 u32
*digest
= (u32
*) hash_buf
->digest
;
11640 salt_t
*salt
= hash_buf
->salt
;
11642 char *salt_buf
= input_buf
+ 6;
11646 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11648 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11650 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11652 salt
->salt_len
= salt_len
;
11654 char *hash_pos
= input_buf
+ 6 + 8;
11656 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11657 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11658 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11659 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11660 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11662 digest
[0] -= SHA1M_A
;
11663 digest
[1] -= SHA1M_B
;
11664 digest
[2] -= SHA1M_C
;
11665 digest
[3] -= SHA1M_D
;
11666 digest
[4] -= SHA1M_E
;
11668 return (PARSER_OK
);
11671 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11673 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11675 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11677 u64
*digest
= (u64
*) hash_buf
->digest
;
11679 salt_t
*salt
= hash_buf
->salt
;
11681 char *salt_buf
= input_buf
+ 6;
11685 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11687 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11689 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11691 salt
->salt_len
= salt_len
;
11693 char *hash_pos
= input_buf
+ 6 + 8;
11695 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11696 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11697 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11698 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11699 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11700 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11701 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11702 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11704 digest
[0] -= SHA512M_A
;
11705 digest
[1] -= SHA512M_B
;
11706 digest
[2] -= SHA512M_C
;
11707 digest
[3] -= SHA512M_D
;
11708 digest
[4] -= SHA512M_E
;
11709 digest
[5] -= SHA512M_F
;
11710 digest
[6] -= SHA512M_G
;
11711 digest
[7] -= SHA512M_H
;
11713 return (PARSER_OK
);
11716 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11718 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11720 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11724 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11727 u32
*digest
= (u32
*) hash_buf
->digest
;
11729 salt_t
*salt
= hash_buf
->salt
;
11731 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11732 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11736 digest
[0] = byte_swap_32 (digest
[0]);
11737 digest
[1] = byte_swap_32 (digest
[1]);
11739 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11741 uint salt_len
= input_len
- 16 - 1;
11743 char *salt_buf
= input_buf
+ 16 + 1;
11745 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11747 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11749 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11751 salt
->salt_len
= salt_len
;
11753 return (PARSER_OK
);
11756 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11758 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11760 u32
*digest
= (u32
*) hash_buf
->digest
;
11762 salt_t
*salt
= hash_buf
->salt
;
11764 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11765 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11766 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11767 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11768 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11770 digest
[0] -= SHA1M_A
;
11771 digest
[1] -= SHA1M_B
;
11772 digest
[2] -= SHA1M_C
;
11773 digest
[3] -= SHA1M_D
;
11774 digest
[4] -= SHA1M_E
;
11776 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11778 uint salt_len
= input_len
- 40 - 1;
11780 char *salt_buf
= input_buf
+ 40 + 1;
11782 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11784 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11786 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11788 salt
->salt_len
= salt_len
;
11790 return (PARSER_OK
);
11793 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11795 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11797 u32
*digest
= (u32
*) hash_buf
->digest
;
11799 salt_t
*salt
= hash_buf
->salt
;
11801 char *hash_pos
= input_buf
;
11803 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11804 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11805 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11806 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11807 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11808 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11809 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11810 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11811 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11812 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11813 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11814 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11815 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11816 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11817 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11818 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11820 char *salt_pos
= input_buf
+ 128;
11822 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11823 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11824 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11825 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11827 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11828 salt
->salt_len
= 16;
11830 return (PARSER_OK
);
11833 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11835 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11837 u32
*digest
= (u32
*) hash_buf
->digest
;
11839 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11840 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11841 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11842 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11843 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11844 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11845 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11846 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11848 digest
[0] -= SHA256M_A
;
11849 digest
[1] -= SHA256M_B
;
11850 digest
[2] -= SHA256M_C
;
11851 digest
[3] -= SHA256M_D
;
11852 digest
[4] -= SHA256M_E
;
11853 digest
[5] -= SHA256M_F
;
11854 digest
[6] -= SHA256M_G
;
11855 digest
[7] -= SHA256M_H
;
11857 return (PARSER_OK
);
11860 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11862 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11864 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11868 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11871 u32
*digest
= (u32
*) hash_buf
->digest
;
11873 salt_t
*salt
= hash_buf
->salt
;
11875 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11876 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11877 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11878 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11879 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11880 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11881 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11882 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11884 digest
[0] -= SHA256M_A
;
11885 digest
[1] -= SHA256M_B
;
11886 digest
[2] -= SHA256M_C
;
11887 digest
[3] -= SHA256M_D
;
11888 digest
[4] -= SHA256M_E
;
11889 digest
[5] -= SHA256M_F
;
11890 digest
[6] -= SHA256M_G
;
11891 digest
[7] -= SHA256M_H
;
11893 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11895 uint salt_len
= input_len
- 64 - 1;
11897 char *salt_buf
= input_buf
+ 64 + 1;
11899 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11901 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11903 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11905 salt
->salt_len
= salt_len
;
11907 return (PARSER_OK
);
11910 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11912 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11914 u64
*digest
= (u64
*) hash_buf
->digest
;
11916 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11917 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11918 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11919 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11920 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11921 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11925 digest
[0] -= SHA384M_A
;
11926 digest
[1] -= SHA384M_B
;
11927 digest
[2] -= SHA384M_C
;
11928 digest
[3] -= SHA384M_D
;
11929 digest
[4] -= SHA384M_E
;
11930 digest
[5] -= SHA384M_F
;
11934 return (PARSER_OK
);
11937 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11939 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11941 u64
*digest
= (u64
*) hash_buf
->digest
;
11943 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11944 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11945 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11946 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11947 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11948 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11949 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11950 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11952 digest
[0] -= SHA512M_A
;
11953 digest
[1] -= SHA512M_B
;
11954 digest
[2] -= SHA512M_C
;
11955 digest
[3] -= SHA512M_D
;
11956 digest
[4] -= SHA512M_E
;
11957 digest
[5] -= SHA512M_F
;
11958 digest
[6] -= SHA512M_G
;
11959 digest
[7] -= SHA512M_H
;
11961 return (PARSER_OK
);
11964 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11966 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11968 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11972 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11975 u64
*digest
= (u64
*) hash_buf
->digest
;
11977 salt_t
*salt
= hash_buf
->salt
;
11979 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11980 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11981 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11982 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11983 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11984 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11985 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11986 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11988 digest
[0] -= SHA512M_A
;
11989 digest
[1] -= SHA512M_B
;
11990 digest
[2] -= SHA512M_C
;
11991 digest
[3] -= SHA512M_D
;
11992 digest
[4] -= SHA512M_E
;
11993 digest
[5] -= SHA512M_F
;
11994 digest
[6] -= SHA512M_G
;
11995 digest
[7] -= SHA512M_H
;
11997 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11999 uint salt_len
= input_len
- 128 - 1;
12001 char *salt_buf
= input_buf
+ 128 + 1;
12003 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12005 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12007 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12009 salt
->salt_len
= salt_len
;
12011 return (PARSER_OK
);
12014 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12016 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12018 u64
*digest
= (u64
*) hash_buf
->digest
;
12020 salt_t
*salt
= hash_buf
->salt
;
12022 char *salt_pos
= input_buf
+ 3;
12024 uint iterations_len
= 0;
12026 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12030 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12032 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12033 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12037 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12041 iterations_len
+= 8;
12045 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12048 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12050 char *hash_pos
= strchr (salt_pos
, '$');
12052 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12054 uint salt_len
= hash_pos
- salt_pos
;
12056 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12058 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12060 salt
->salt_len
= salt_len
;
12064 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12066 return (PARSER_OK
);
12069 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12071 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12073 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12075 u64
*digest
= (u64
*) hash_buf
->digest
;
12077 salt_t
*salt
= hash_buf
->salt
;
12079 uint keccak_mdlen
= input_len
/ 2;
12081 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12083 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12085 digest
[i
] = byte_swap_64 (digest
[i
]);
12088 salt
->keccak_mdlen
= keccak_mdlen
;
12090 return (PARSER_OK
);
12093 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12095 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12097 u32
*digest
= (u32
*) hash_buf
->digest
;
12099 salt_t
*salt
= hash_buf
->salt
;
12101 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12104 * Parse that strange long line
12109 size_t in_len
[9] = { 0 };
12111 in_off
[0] = strtok (input_buf
, ":");
12113 in_len
[0] = strlen (in_off
[0]);
12117 for (i
= 1; i
< 9; i
++)
12119 in_off
[i
] = strtok (NULL
, ":");
12121 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12123 in_len
[i
] = strlen (in_off
[i
]);
12126 char *ptr
= (char *) ikepsk
->msg_buf
;
12128 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12129 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12130 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12131 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12132 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12133 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12137 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12139 ptr
= (char *) ikepsk
->nr_buf
;
12141 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12142 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12146 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12149 * Store to database
12154 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12155 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12156 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12157 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12159 digest
[0] = byte_swap_32 (digest
[0]);
12160 digest
[1] = byte_swap_32 (digest
[1]);
12161 digest
[2] = byte_swap_32 (digest
[2]);
12162 digest
[3] = byte_swap_32 (digest
[3]);
12164 salt
->salt_len
= 32;
12166 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12167 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12168 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12169 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12170 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12171 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12172 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12173 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12175 return (PARSER_OK
);
12178 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12180 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12182 u32
*digest
= (u32
*) hash_buf
->digest
;
12184 salt_t
*salt
= hash_buf
->salt
;
12186 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12189 * Parse that strange long line
12194 size_t in_len
[9] = { 0 };
12196 in_off
[0] = strtok (input_buf
, ":");
12198 in_len
[0] = strlen (in_off
[0]);
12202 for (i
= 1; i
< 9; i
++)
12204 in_off
[i
] = strtok (NULL
, ":");
12206 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12208 in_len
[i
] = strlen (in_off
[i
]);
12211 char *ptr
= (char *) ikepsk
->msg_buf
;
12213 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12214 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12215 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12216 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12217 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12218 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12222 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12224 ptr
= (char *) ikepsk
->nr_buf
;
12226 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12227 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12231 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12234 * Store to database
12239 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12240 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12241 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12242 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12243 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12245 salt
->salt_len
= 32;
12247 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12248 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12249 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12250 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12251 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12252 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12253 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12254 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12256 return (PARSER_OK
);
12259 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12261 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12263 u32
*digest
= (u32
*) hash_buf
->digest
;
12265 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12266 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12267 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12268 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12269 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12271 digest
[0] = byte_swap_32 (digest
[0]);
12272 digest
[1] = byte_swap_32 (digest
[1]);
12273 digest
[2] = byte_swap_32 (digest
[2]);
12274 digest
[3] = byte_swap_32 (digest
[3]);
12275 digest
[4] = byte_swap_32 (digest
[4]);
12277 return (PARSER_OK
);
12280 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12282 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12284 u32
*digest
= (u32
*) hash_buf
->digest
;
12286 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12287 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12288 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12289 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12290 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12291 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12292 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12293 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12294 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12295 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12296 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12297 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12298 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12299 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12300 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12301 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12303 return (PARSER_OK
);
12306 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12308 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12310 u32
*digest
= (u32
*) hash_buf
->digest
;
12312 salt_t
*salt
= hash_buf
->salt
;
12314 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12315 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12316 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12317 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12318 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12320 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12322 uint salt_len
= input_len
- 40 - 1;
12324 char *salt_buf
= input_buf
+ 40 + 1;
12326 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12328 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12330 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12332 salt
->salt_len
= salt_len
;
12334 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12336 return (PARSER_OK
);
12339 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12341 u32
*digest
= (u32
*) hash_buf
->digest
;
12343 salt_t
*salt
= hash_buf
->salt
;
12345 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12347 if (input_len
== 0)
12349 log_error ("TrueCrypt container not specified");
12354 FILE *fp
= fopen (input_buf
, "rb");
12358 log_error ("%s: %s", input_buf
, strerror (errno
));
12363 char buf
[512] = { 0 };
12365 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12369 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12371 memcpy (tc
->salt_buf
, buf
, 64);
12373 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12375 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12377 salt
->salt_len
= 4;
12379 salt
->salt_iter
= 1000 - 1;
12381 digest
[0] = tc
->data_buf
[0];
12383 return (PARSER_OK
);
12386 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12388 u32
*digest
= (u32
*) hash_buf
->digest
;
12390 salt_t
*salt
= hash_buf
->salt
;
12392 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12394 if (input_len
== 0)
12396 log_error ("TrueCrypt container not specified");
12401 FILE *fp
= fopen (input_buf
, "rb");
12405 log_error ("%s: %s", input_buf
, strerror (errno
));
12410 char buf
[512] = { 0 };
12412 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12416 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12418 memcpy (tc
->salt_buf
, buf
, 64);
12420 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12422 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12424 salt
->salt_len
= 4;
12426 salt
->salt_iter
= 2000 - 1;
12428 digest
[0] = tc
->data_buf
[0];
12430 return (PARSER_OK
);
12433 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12435 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12437 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12439 u32
*digest
= (u32
*) hash_buf
->digest
;
12441 salt_t
*salt
= hash_buf
->salt
;
12443 char *salt_pos
= input_buf
+ 6;
12445 char *hash_pos
= strchr (salt_pos
, '$');
12447 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12449 uint salt_len
= hash_pos
- salt_pos
;
12451 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12453 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12455 salt
->salt_len
= salt_len
;
12457 salt
->salt_iter
= 1000;
12461 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12463 return (PARSER_OK
);
12466 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12468 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12470 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12472 u32
*digest
= (u32
*) hash_buf
->digest
;
12474 salt_t
*salt
= hash_buf
->salt
;
12476 char *iter_pos
= input_buf
+ 7;
12478 char *salt_pos
= strchr (iter_pos
, '$');
12480 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12484 char *hash_pos
= strchr (salt_pos
, '$');
12486 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12488 uint salt_len
= hash_pos
- salt_pos
;
12490 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12492 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12494 salt
->salt_len
= salt_len
;
12496 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12498 salt
->salt_sign
[0] = atoi (salt_iter
);
12500 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12504 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12506 digest
[0] = byte_swap_32 (digest
[0]);
12507 digest
[1] = byte_swap_32 (digest
[1]);
12508 digest
[2] = byte_swap_32 (digest
[2]);
12509 digest
[3] = byte_swap_32 (digest
[3]);
12510 digest
[4] = byte_swap_32 (digest
[4]);
12512 return (PARSER_OK
);
12515 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12517 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12519 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12521 u32
*digest
= (u32
*) hash_buf
->digest
;
12523 salt_t
*salt
= hash_buf
->salt
;
12525 char *iter_pos
= input_buf
+ 9;
12527 char *salt_pos
= strchr (iter_pos
, '$');
12529 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12533 char *hash_pos
= strchr (salt_pos
, '$');
12535 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12537 uint salt_len
= hash_pos
- salt_pos
;
12539 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12541 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12543 salt
->salt_len
= salt_len
;
12545 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12547 salt
->salt_sign
[0] = atoi (salt_iter
);
12549 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12553 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12555 digest
[0] = byte_swap_32 (digest
[0]);
12556 digest
[1] = byte_swap_32 (digest
[1]);
12557 digest
[2] = byte_swap_32 (digest
[2]);
12558 digest
[3] = byte_swap_32 (digest
[3]);
12559 digest
[4] = byte_swap_32 (digest
[4]);
12560 digest
[5] = byte_swap_32 (digest
[5]);
12561 digest
[6] = byte_swap_32 (digest
[6]);
12562 digest
[7] = byte_swap_32 (digest
[7]);
12564 return (PARSER_OK
);
12567 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12569 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12571 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12573 u64
*digest
= (u64
*) hash_buf
->digest
;
12575 salt_t
*salt
= hash_buf
->salt
;
12577 char *iter_pos
= input_buf
+ 9;
12579 char *salt_pos
= strchr (iter_pos
, '$');
12581 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12585 char *hash_pos
= strchr (salt_pos
, '$');
12587 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12589 uint salt_len
= hash_pos
- salt_pos
;
12591 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12593 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12595 salt
->salt_len
= salt_len
;
12597 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12599 salt
->salt_sign
[0] = atoi (salt_iter
);
12601 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12605 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12607 digest
[0] = byte_swap_64 (digest
[0]);
12608 digest
[1] = byte_swap_64 (digest
[1]);
12609 digest
[2] = byte_swap_64 (digest
[2]);
12610 digest
[3] = byte_swap_64 (digest
[3]);
12611 digest
[4] = byte_swap_64 (digest
[4]);
12612 digest
[5] = byte_swap_64 (digest
[5]);
12613 digest
[6] = byte_swap_64 (digest
[6]);
12614 digest
[7] = byte_swap_64 (digest
[7]);
12616 return (PARSER_OK
);
12619 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12621 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12623 u32
*digest
= (u32
*) hash_buf
->digest
;
12625 salt_t
*salt
= hash_buf
->salt
;
12627 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12633 char *iterations_pos
= input_buf
;
12635 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12637 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12639 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12641 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12645 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12647 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12649 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12651 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12653 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12655 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12660 * pbkdf2 iterations
12663 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12666 * handle salt encoding
12669 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12671 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12673 const char p0
= saltbuf_pos
[i
+ 0];
12674 const char p1
= saltbuf_pos
[i
+ 1];
12676 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12677 | hex_convert (p0
) << 4;
12680 salt
->salt_len
= saltbuf_len
/ 2;
12683 * handle cipher encoding
12686 uint
*tmp
= (uint
*) mymalloc (32);
12688 char *cipherbuf_ptr
= (char *) tmp
;
12690 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12692 const char p0
= cipherbuf_pos
[i
+ 0];
12693 const char p1
= cipherbuf_pos
[i
+ 1];
12695 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12696 | hex_convert (p0
) << 4;
12699 // iv is stored at salt_buf 4 (length 16)
12700 // data is stored at salt_buf 8 (length 16)
12702 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12703 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12704 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12705 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12707 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12708 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12709 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12710 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12714 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12716 const char p0
= cipherbuf_pos
[j
+ 0];
12717 const char p1
= cipherbuf_pos
[j
+ 1];
12719 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12720 | hex_convert (p0
) << 4;
12727 digest
[0] = 0x10101010;
12728 digest
[1] = 0x10101010;
12729 digest
[2] = 0x10101010;
12730 digest
[3] = 0x10101010;
12732 return (PARSER_OK
);
12735 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12737 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12739 u32
*digest
= (u32
*) hash_buf
->digest
;
12741 salt_t
*salt
= hash_buf
->salt
;
12743 char *hashbuf_pos
= input_buf
;
12745 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12747 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12749 uint hash_len
= iterations_pos
- hashbuf_pos
;
12751 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12755 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12757 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12759 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12763 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12765 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12767 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12769 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12771 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12773 salt
->salt_len
= salt_len
;
12775 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12777 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12778 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12779 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12780 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12782 return (PARSER_OK
);
12785 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12787 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12789 u32
*digest
= (u32
*) hash_buf
->digest
;
12791 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12792 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12793 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12794 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12795 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12796 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12797 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12798 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12800 digest
[0] = byte_swap_32 (digest
[0]);
12801 digest
[1] = byte_swap_32 (digest
[1]);
12802 digest
[2] = byte_swap_32 (digest
[2]);
12803 digest
[3] = byte_swap_32 (digest
[3]);
12804 digest
[4] = byte_swap_32 (digest
[4]);
12805 digest
[5] = byte_swap_32 (digest
[5]);
12806 digest
[6] = byte_swap_32 (digest
[6]);
12807 digest
[7] = byte_swap_32 (digest
[7]);
12809 return (PARSER_OK
);
12812 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12814 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12816 u32
*digest
= (u32
*) hash_buf
->digest
;
12818 salt_t
*salt
= hash_buf
->salt
;
12820 char *salt_pos
= input_buf
+ 3;
12822 uint iterations_len
= 0;
12824 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12828 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12830 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12831 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12835 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12839 iterations_len
+= 8;
12843 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12846 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12848 char *hash_pos
= strchr (salt_pos
, '$');
12850 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12852 uint salt_len
= hash_pos
- salt_pos
;
12854 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12856 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12858 salt
->salt_len
= salt_len
;
12862 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12864 return (PARSER_OK
);
12867 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12869 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12871 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12873 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12875 u64
*digest
= (u64
*) hash_buf
->digest
;
12877 salt_t
*salt
= hash_buf
->salt
;
12879 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12881 char *iter_pos
= input_buf
+ 4;
12883 char *salt_pos
= strchr (iter_pos
, '$');
12885 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12889 char *hash_pos
= strchr (salt_pos
, '$');
12891 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12893 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12897 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12898 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12899 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12900 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12901 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12902 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12903 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12904 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12906 uint salt_len
= hash_pos
- salt_pos
- 1;
12908 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12910 salt
->salt_len
= salt_len
/ 2;
12912 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12913 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12914 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12915 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12916 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12917 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12918 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12919 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12921 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12922 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12923 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12924 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12925 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12926 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12927 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12928 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12929 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12930 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12932 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12934 salt
->salt_iter
= atoi (iter_pos
) - 1;
12936 return (PARSER_OK
);
12939 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12941 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12943 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12945 u32
*digest
= (u32
*) hash_buf
->digest
;
12947 salt_t
*salt
= hash_buf
->salt
;
12949 char *salt_pos
= input_buf
+ 14;
12951 char *hash_pos
= strchr (salt_pos
, '*');
12953 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12957 uint salt_len
= hash_pos
- salt_pos
- 1;
12959 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12961 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12963 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12965 salt
->salt_len
= salt_len
;
12967 u8 tmp_buf
[100] = { 0 };
12969 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
12971 memcpy (digest
, tmp_buf
, 32);
12973 digest
[0] = byte_swap_32 (digest
[0]);
12974 digest
[1] = byte_swap_32 (digest
[1]);
12975 digest
[2] = byte_swap_32 (digest
[2]);
12976 digest
[3] = byte_swap_32 (digest
[3]);
12977 digest
[4] = byte_swap_32 (digest
[4]);
12978 digest
[5] = byte_swap_32 (digest
[5]);
12979 digest
[6] = byte_swap_32 (digest
[6]);
12980 digest
[7] = byte_swap_32 (digest
[7]);
12982 digest
[0] -= SHA256M_A
;
12983 digest
[1] -= SHA256M_B
;
12984 digest
[2] -= SHA256M_C
;
12985 digest
[3] -= SHA256M_D
;
12986 digest
[4] -= SHA256M_E
;
12987 digest
[5] -= SHA256M_F
;
12988 digest
[6] -= SHA256M_G
;
12989 digest
[7] -= SHA256M_H
;
12991 return (PARSER_OK
);
12994 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12996 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12998 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13000 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13002 u64
*digest
= (u64
*) hash_buf
->digest
;
13004 salt_t
*salt
= hash_buf
->salt
;
13006 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13008 char *iter_pos
= input_buf
+ 19;
13010 char *salt_pos
= strchr (iter_pos
, '.');
13012 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13016 char *hash_pos
= strchr (salt_pos
, '.');
13018 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13020 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13024 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13025 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13026 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13027 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13028 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13029 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13030 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13031 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13033 uint salt_len
= hash_pos
- salt_pos
- 1;
13037 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13041 for (i
= 0; i
< salt_len
; i
++)
13043 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13046 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13047 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13049 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13051 salt
->salt_len
= salt_len
;
13053 salt
->salt_iter
= atoi (iter_pos
) - 1;
13055 return (PARSER_OK
);
13058 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13060 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13062 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13064 u64
*digest
= (u64
*) hash_buf
->digest
;
13066 salt_t
*salt
= hash_buf
->salt
;
13068 u8 tmp_buf
[120] = { 0 };
13070 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13072 memcpy (digest
, tmp_buf
, 64);
13074 digest
[0] = byte_swap_64 (digest
[0]);
13075 digest
[1] = byte_swap_64 (digest
[1]);
13076 digest
[2] = byte_swap_64 (digest
[2]);
13077 digest
[3] = byte_swap_64 (digest
[3]);
13078 digest
[4] = byte_swap_64 (digest
[4]);
13079 digest
[5] = byte_swap_64 (digest
[5]);
13080 digest
[6] = byte_swap_64 (digest
[6]);
13081 digest
[7] = byte_swap_64 (digest
[7]);
13083 digest
[0] -= SHA512M_A
;
13084 digest
[1] -= SHA512M_B
;
13085 digest
[2] -= SHA512M_C
;
13086 digest
[3] -= SHA512M_D
;
13087 digest
[4] -= SHA512M_E
;
13088 digest
[5] -= SHA512M_F
;
13089 digest
[6] -= SHA512M_G
;
13090 digest
[7] -= SHA512M_H
;
13092 salt
->salt_len
= tmp_len
- 64;
13094 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13096 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13098 char *ptr
= (char *) salt
->salt_buf
;
13100 ptr
[salt
->salt_len
] = 0x80;
13103 return (PARSER_OK
);
13106 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13108 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13110 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13114 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13117 u32
*digest
= (u32
*) hash_buf
->digest
;
13119 salt_t
*salt
= hash_buf
->salt
;
13121 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13122 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13123 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13124 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13126 digest
[0] = byte_swap_32 (digest
[0]);
13127 digest
[1] = byte_swap_32 (digest
[1]);
13128 digest
[2] = byte_swap_32 (digest
[2]);
13129 digest
[3] = byte_swap_32 (digest
[3]);
13131 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13133 uint salt_len
= input_len
- 32 - 1;
13135 char *salt_buf
= input_buf
+ 32 + 1;
13137 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13139 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13141 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13143 salt
->salt_len
= salt_len
;
13145 return (PARSER_OK
);
13148 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13150 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13152 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13156 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13159 u32
*digest
= (u32
*) hash_buf
->digest
;
13161 salt_t
*salt
= hash_buf
->salt
;
13163 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13164 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13165 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13166 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13167 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13169 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13171 uint salt_len
= input_len
- 40 - 1;
13173 char *salt_buf
= input_buf
+ 40 + 1;
13175 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13177 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13179 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13181 salt
->salt_len
= salt_len
;
13183 return (PARSER_OK
);
13186 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13188 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13190 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13194 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13197 u32
*digest
= (u32
*) hash_buf
->digest
;
13199 salt_t
*salt
= hash_buf
->salt
;
13201 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13202 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13203 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13204 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13205 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13206 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13207 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13208 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13210 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13212 uint salt_len
= input_len
- 64 - 1;
13214 char *salt_buf
= input_buf
+ 64 + 1;
13216 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13218 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13220 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13222 salt
->salt_len
= salt_len
;
13224 return (PARSER_OK
);
13227 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13229 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13231 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13235 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13238 u64
*digest
= (u64
*) hash_buf
->digest
;
13240 salt_t
*salt
= hash_buf
->salt
;
13242 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13243 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13244 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13245 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13246 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13247 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13248 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13249 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13251 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13253 uint salt_len
= input_len
- 128 - 1;
13255 char *salt_buf
= input_buf
+ 128 + 1;
13257 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13259 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13261 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13263 salt
->salt_len
= salt_len
;
13265 return (PARSER_OK
);
13268 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13270 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13272 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13274 u32
*digest
= (u32
*) hash_buf
->digest
;
13276 salt_t
*salt
= hash_buf
->salt
;
13278 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13284 char *user_pos
= input_buf
+ 10 + 1;
13286 char *realm_pos
= strchr (user_pos
, '$');
13288 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13290 uint user_len
= realm_pos
- user_pos
;
13292 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13296 char *salt_pos
= strchr (realm_pos
, '$');
13298 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13300 uint realm_len
= salt_pos
- realm_pos
;
13302 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13306 char *data_pos
= strchr (salt_pos
, '$');
13308 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13310 uint salt_len
= data_pos
- salt_pos
;
13312 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13316 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13318 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13324 memcpy (krb5pa
->user
, user_pos
, user_len
);
13325 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13326 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13328 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13330 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13332 const char p0
= data_pos
[i
+ 0];
13333 const char p1
= data_pos
[i
+ 1];
13335 *timestamp_ptr
++ = hex_convert (p1
) << 0
13336 | hex_convert (p0
) << 4;
13339 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13341 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13343 const char p0
= data_pos
[i
+ 0];
13344 const char p1
= data_pos
[i
+ 1];
13346 *checksum_ptr
++ = hex_convert (p1
) << 0
13347 | hex_convert (p0
) << 4;
13351 * copy some data to generic buffers to make sorting happy
13354 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13355 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13356 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13357 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13358 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13359 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13360 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13361 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13362 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13364 salt
->salt_len
= 36;
13366 digest
[0] = krb5pa
->checksum
[0];
13367 digest
[1] = krb5pa
->checksum
[1];
13368 digest
[2] = krb5pa
->checksum
[2];
13369 digest
[3] = krb5pa
->checksum
[3];
13371 return (PARSER_OK
);
13374 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13376 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13378 u32
*digest
= (u32
*) hash_buf
->digest
;
13380 salt_t
*salt
= hash_buf
->salt
;
13386 char *salt_pos
= input_buf
;
13388 char *hash_pos
= strchr (salt_pos
, '$');
13390 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13392 uint salt_len
= hash_pos
- salt_pos
;
13394 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13398 uint hash_len
= input_len
- 1 - salt_len
;
13400 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13408 for (uint i
= 0; i
< salt_len
; i
++)
13410 if (salt_pos
[i
] == ' ') continue;
13415 // SAP user names cannot be longer than 12 characters
13416 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13418 // SAP user name cannot start with ! or ?
13419 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13425 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13427 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13429 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13431 salt
->salt_len
= salt_len
;
13433 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13434 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13438 digest
[0] = byte_swap_32 (digest
[0]);
13439 digest
[1] = byte_swap_32 (digest
[1]);
13441 return (PARSER_OK
);
13444 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13446 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13448 u32
*digest
= (u32
*) hash_buf
->digest
;
13450 salt_t
*salt
= hash_buf
->salt
;
13456 char *salt_pos
= input_buf
;
13458 char *hash_pos
= strchr (salt_pos
, '$');
13460 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13462 uint salt_len
= hash_pos
- salt_pos
;
13464 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13468 uint hash_len
= input_len
- 1 - salt_len
;
13470 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13478 for (uint i
= 0; i
< salt_len
; i
++)
13480 if (salt_pos
[i
] == ' ') continue;
13485 // SAP user names cannot be longer than 12 characters
13486 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13487 // so far nobody complained so we stay with this because it helps in optimization
13488 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13490 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13492 // SAP user name cannot start with ! or ?
13493 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13499 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13501 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13503 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13505 salt
->salt_len
= salt_len
;
13507 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13508 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13509 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13510 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13511 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13513 return (PARSER_OK
);
13516 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13518 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13520 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13522 u64
*digest
= (u64
*) hash_buf
->digest
;
13524 salt_t
*salt
= hash_buf
->salt
;
13526 char *iter_pos
= input_buf
+ 3;
13528 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13530 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13532 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13534 salt
->salt_iter
= salt_iter
;
13536 char *salt_pos
= iter_pos
+ 1;
13540 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13542 salt
->salt_len
= salt_len
;
13544 char *hash_pos
= salt_pos
+ salt_len
;
13546 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13550 char *tmp
= (char *) salt
->salt_buf_pc
;
13552 tmp
[0] = hash_pos
[42];
13556 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13557 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13558 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13559 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13565 return (PARSER_OK
);
13568 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13570 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13572 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13574 u32
*digest
= (u32
*) hash_buf
->digest
;
13576 salt_t
*salt
= hash_buf
->salt
;
13578 char *salt_buf
= input_buf
+ 6;
13580 uint salt_len
= 16;
13582 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13584 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13586 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13588 salt
->salt_len
= salt_len
;
13590 char *hash_pos
= input_buf
+ 6 + 16;
13592 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13593 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13594 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13595 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13596 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13597 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13598 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13599 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13601 return (PARSER_OK
);
13604 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13606 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13608 u32
*digest
= (u32
*) hash_buf
->digest
;
13610 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13611 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13615 return (PARSER_OK
);
13618 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13620 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13622 u32
*digest
= (u32
*) hash_buf
->digest
;
13624 salt_t
*salt
= hash_buf
->salt
;
13626 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13628 char *saltbuf_pos
= input_buf
;
13630 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13632 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13634 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13636 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13637 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13639 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13643 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13645 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13647 char *salt_ptr
= (char *) saltbuf_pos
;
13648 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13653 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13655 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13658 rakp_ptr
[j
] = 0x80;
13660 rakp
->salt_len
= j
;
13662 for (i
= 0; i
< 64; i
++)
13664 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13667 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13668 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13669 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13670 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13671 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13672 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13673 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13674 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13676 salt
->salt_len
= 32; // muss min. 32 haben
13678 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13679 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13680 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13681 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13682 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13684 return (PARSER_OK
);
13687 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13689 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13691 u32
*digest
= (u32
*) hash_buf
->digest
;
13693 salt_t
*salt
= hash_buf
->salt
;
13695 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13697 char *salt_pos
= input_buf
+ 1;
13699 memcpy (salt
->salt_buf
, salt_pos
, 8);
13701 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13702 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13704 salt
->salt_len
= 8;
13706 char *hash_pos
= salt_pos
+ 8;
13708 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13709 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13710 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13711 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13712 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13714 digest
[0] -= SHA1M_A
;
13715 digest
[1] -= SHA1M_B
;
13716 digest
[2] -= SHA1M_C
;
13717 digest
[3] -= SHA1M_D
;
13718 digest
[4] -= SHA1M_E
;
13720 return (PARSER_OK
);
13723 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13725 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13727 u32
*digest
= (u32
*) hash_buf
->digest
;
13729 salt_t
*salt
= hash_buf
->salt
;
13731 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13732 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13733 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13734 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13736 digest
[0] = byte_swap_32 (digest
[0]);
13737 digest
[1] = byte_swap_32 (digest
[1]);
13738 digest
[2] = byte_swap_32 (digest
[2]);
13739 digest
[3] = byte_swap_32 (digest
[3]);
13741 digest
[0] -= MD5M_A
;
13742 digest
[1] -= MD5M_B
;
13743 digest
[2] -= MD5M_C
;
13744 digest
[3] -= MD5M_D
;
13746 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13748 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13750 u32
*salt_buf
= salt
->salt_buf
;
13752 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13753 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13754 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13755 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13757 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13758 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13759 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13760 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13762 salt
->salt_len
= 16 + 1;
13764 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13766 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13768 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13770 return (PARSER_OK
);
13773 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13775 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13777 u32
*digest
= (u32
*) hash_buf
->digest
;
13779 salt_t
*salt
= hash_buf
->salt
;
13781 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13787 char *hashbuf_pos
= input_buf
;
13789 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13791 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13793 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13795 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13799 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13801 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13803 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13805 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13809 char *databuf_pos
= strchr (iteration_pos
, ':');
13811 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13813 const uint iteration_len
= databuf_pos
- iteration_pos
;
13815 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13816 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13818 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13820 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13821 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13827 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13828 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13829 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13830 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13831 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13832 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13833 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13834 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13838 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13840 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13842 const char p0
= saltbuf_pos
[i
+ 0];
13843 const char p1
= saltbuf_pos
[i
+ 1];
13845 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13846 | hex_convert (p0
) << 4;
13849 salt
->salt_buf
[4] = 0x01000000;
13850 salt
->salt_buf
[5] = 0x80;
13852 salt
->salt_len
= saltbuf_len
/ 2;
13856 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13860 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13862 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13864 const char p0
= databuf_pos
[i
+ 0];
13865 const char p1
= databuf_pos
[i
+ 1];
13867 *databuf_ptr
++ = hex_convert (p1
) << 0
13868 | hex_convert (p0
) << 4;
13871 *databuf_ptr
++ = 0x80;
13873 for (uint i
= 0; i
< 512; i
++)
13875 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13878 cloudkey
->data_len
= databuf_len
/ 2;
13880 return (PARSER_OK
);
13883 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13885 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13887 u32
*digest
= (u32
*) hash_buf
->digest
;
13889 salt_t
*salt
= hash_buf
->salt
;
13895 char *hashbuf_pos
= input_buf
;
13897 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13899 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13901 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13903 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13907 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13909 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13911 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13913 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13915 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13919 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13921 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13923 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13925 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13927 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13931 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13933 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13934 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13936 // ok, the plan for this algorithm is the following:
13937 // we have 2 salts here, the domain-name and a random salt
13938 // while both are used in the initial transformation,
13939 // only the random salt is used in the following iterations
13940 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13941 // and one that includes only the real salt (stored into salt_buf[]).
13942 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13944 u8 tmp_buf
[100] = { 0 };
13946 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
13948 memcpy (digest
, tmp_buf
, 20);
13950 digest
[0] = byte_swap_32 (digest
[0]);
13951 digest
[1] = byte_swap_32 (digest
[1]);
13952 digest
[2] = byte_swap_32 (digest
[2]);
13953 digest
[3] = byte_swap_32 (digest
[3]);
13954 digest
[4] = byte_swap_32 (digest
[4]);
13958 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13960 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13962 char *len_ptr
= NULL
;
13964 for (uint i
= 0; i
< domainbuf_len
; i
++)
13966 if (salt_buf_pc_ptr
[i
] == '.')
13968 len_ptr
= &salt_buf_pc_ptr
[i
];
13978 salt
->salt_buf_pc
[7] = domainbuf_len
;
13982 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13984 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13986 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13988 salt
->salt_len
= salt_len
;
13992 salt
->salt_iter
= atoi (iteration_pos
);
13994 return (PARSER_OK
);
13997 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13999 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14001 u32
*digest
= (u32
*) hash_buf
->digest
;
14003 salt_t
*salt
= hash_buf
->salt
;
14005 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14006 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14007 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14008 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14009 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14011 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14013 uint salt_len
= input_len
- 40 - 1;
14015 char *salt_buf
= input_buf
+ 40 + 1;
14017 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14019 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14021 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14023 salt
->salt_len
= salt_len
;
14025 return (PARSER_OK
);
14028 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14030 const u8 ascii_to_ebcdic
[] =
14032 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14033 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14034 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14035 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14036 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14037 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14038 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14039 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14040 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14041 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14042 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14043 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14044 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14045 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14046 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14047 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14050 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14052 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14054 u32
*digest
= (u32
*) hash_buf
->digest
;
14056 salt_t
*salt
= hash_buf
->salt
;
14058 char *salt_pos
= input_buf
+ 6 + 1;
14060 char *digest_pos
= strchr (salt_pos
, '*');
14062 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14064 uint salt_len
= digest_pos
- salt_pos
;
14066 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14068 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14070 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14074 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14075 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14077 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14079 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14081 salt
->salt_len
= salt_len
;
14083 for (uint i
= 0; i
< salt_len
; i
++)
14085 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14087 for (uint i
= salt_len
; i
< 8; i
++)
14089 salt_buf_pc_ptr
[i
] = 0x40;
14094 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14096 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14097 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14099 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14100 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14102 digest
[0] = byte_swap_32 (digest
[0]);
14103 digest
[1] = byte_swap_32 (digest
[1]);
14105 IP (digest
[0], digest
[1], tt
);
14107 digest
[0] = rotr32 (digest
[0], 29);
14108 digest
[1] = rotr32 (digest
[1], 29);
14112 return (PARSER_OK
);
14115 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14117 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14119 u32
*digest
= (u32
*) hash_buf
->digest
;
14121 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14122 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14123 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14124 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14126 digest
[0] = byte_swap_32 (digest
[0]);
14127 digest
[1] = byte_swap_32 (digest
[1]);
14128 digest
[2] = byte_swap_32 (digest
[2]);
14129 digest
[3] = byte_swap_32 (digest
[3]);
14131 return (PARSER_OK
);
14134 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14136 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14138 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14140 u32
*digest
= (u32
*) hash_buf
->digest
;
14142 salt_t
*salt
= hash_buf
->salt
;
14144 u8 tmp_buf
[120] = { 0 };
14146 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14148 tmp_buf
[3] += -4; // dont ask!
14150 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14152 salt
->salt_len
= 5;
14154 memcpy (digest
, tmp_buf
+ 5, 9);
14156 // yes, only 9 byte are needed to crack, but 10 to display
14158 salt
->salt_buf_pc
[7] = input_buf
[20];
14160 return (PARSER_OK
);
14163 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14165 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14167 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14169 u32
*digest
= (u32
*) hash_buf
->digest
;
14171 salt_t
*salt
= hash_buf
->salt
;
14173 u8 tmp_buf
[120] = { 0 };
14175 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14177 tmp_buf
[3] += -4; // dont ask!
14181 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14183 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)
14187 char tmp_iter_buf
[11] = { 0 };
14189 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14191 tmp_iter_buf
[10] = 0;
14193 salt
->salt_iter
= atoi (tmp_iter_buf
);
14195 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14197 return (PARSER_SALT_ITERATION
);
14200 salt
->salt_iter
--; // first round in init
14202 // 2 additional bytes for display only
14204 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14205 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14209 memcpy (digest
, tmp_buf
+ 28, 8);
14211 digest
[0] = byte_swap_32 (digest
[0]);
14212 digest
[1] = byte_swap_32 (digest
[1]);
14216 return (PARSER_OK
);
14219 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14221 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14223 u32
*digest
= (u32
*) hash_buf
->digest
;
14225 salt_t
*salt
= hash_buf
->salt
;
14227 char *salt_buf_pos
= input_buf
;
14229 char *hash_buf_pos
= salt_buf_pos
+ 6;
14231 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14232 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14233 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14234 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14235 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14236 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14237 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14238 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14240 digest
[0] -= SHA256M_A
;
14241 digest
[1] -= SHA256M_B
;
14242 digest
[2] -= SHA256M_C
;
14243 digest
[3] -= SHA256M_D
;
14244 digest
[4] -= SHA256M_E
;
14245 digest
[5] -= SHA256M_F
;
14246 digest
[6] -= SHA256M_G
;
14247 digest
[7] -= SHA256M_H
;
14249 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14251 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14253 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14255 salt
->salt_len
= salt_len
;
14257 return (PARSER_OK
);
14260 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14262 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14264 u32
*digest
= (u32
*) hash_buf
->digest
;
14266 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14268 salt_t
*salt
= hash_buf
->salt
;
14270 char *salt_buf
= input_buf
+ 6;
14272 char *digest_buf
= strchr (salt_buf
, '$');
14274 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14276 uint salt_len
= digest_buf
- salt_buf
;
14278 digest_buf
++; // skip the '$' symbol
14280 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14282 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14284 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14286 salt
->salt_len
= salt_len
;
14288 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14289 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14290 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14291 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14293 digest
[0] = byte_swap_32 (digest
[0]);
14294 digest
[1] = byte_swap_32 (digest
[1]);
14295 digest
[2] = byte_swap_32 (digest
[2]);
14296 digest
[3] = byte_swap_32 (digest
[3]);
14298 digest
[0] -= MD5M_A
;
14299 digest
[1] -= MD5M_B
;
14300 digest
[2] -= MD5M_C
;
14301 digest
[3] -= MD5M_D
;
14303 return (PARSER_OK
);
14306 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14308 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14310 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14312 u32
*digest
= (u32
*) hash_buf
->digest
;
14314 salt_t
*salt
= hash_buf
->salt
;
14316 char *salt_buf
= input_buf
+ 3;
14318 char *digest_buf
= strchr (salt_buf
, '$');
14320 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14322 uint salt_len
= digest_buf
- salt_buf
;
14324 digest_buf
++; // skip the '$' symbol
14326 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14328 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14330 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14332 salt_buf_ptr
[salt_len
] = 0x2d;
14334 salt
->salt_len
= salt_len
+ 1;
14336 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14337 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14338 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14339 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14341 digest
[0] = byte_swap_32 (digest
[0]);
14342 digest
[1] = byte_swap_32 (digest
[1]);
14343 digest
[2] = byte_swap_32 (digest
[2]);
14344 digest
[3] = byte_swap_32 (digest
[3]);
14346 digest
[0] -= MD5M_A
;
14347 digest
[1] -= MD5M_B
;
14348 digest
[2] -= MD5M_C
;
14349 digest
[3] -= MD5M_D
;
14351 return (PARSER_OK
);
14354 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14356 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14358 u32
*digest
= (u32
*) hash_buf
->digest
;
14360 u8 tmp_buf
[100] = { 0 };
14362 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14364 memcpy (digest
, tmp_buf
, 20);
14366 digest
[0] = byte_swap_32 (digest
[0]);
14367 digest
[1] = byte_swap_32 (digest
[1]);
14368 digest
[2] = byte_swap_32 (digest
[2]);
14369 digest
[3] = byte_swap_32 (digest
[3]);
14370 digest
[4] = byte_swap_32 (digest
[4]);
14372 digest
[0] -= SHA1M_A
;
14373 digest
[1] -= SHA1M_B
;
14374 digest
[2] -= SHA1M_C
;
14375 digest
[3] -= SHA1M_D
;
14376 digest
[4] -= SHA1M_E
;
14378 return (PARSER_OK
);
14381 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14383 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14385 u32
*digest
= (u32
*) hash_buf
->digest
;
14387 salt_t
*salt
= hash_buf
->salt
;
14389 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14390 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14391 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14392 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14394 digest
[0] = byte_swap_32 (digest
[0]);
14395 digest
[1] = byte_swap_32 (digest
[1]);
14396 digest
[2] = byte_swap_32 (digest
[2]);
14397 digest
[3] = byte_swap_32 (digest
[3]);
14399 digest
[0] -= MD5M_A
;
14400 digest
[1] -= MD5M_B
;
14401 digest
[2] -= MD5M_C
;
14402 digest
[3] -= MD5M_D
;
14404 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14406 uint salt_len
= input_len
- 32 - 1;
14408 char *salt_buf
= input_buf
+ 32 + 1;
14410 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14412 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14414 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14417 * add static "salt" part
14420 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14424 salt
->salt_len
= salt_len
;
14426 return (PARSER_OK
);
14429 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14431 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14433 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14435 u32
*digest
= (u32
*) hash_buf
->digest
;
14437 salt_t
*salt
= hash_buf
->salt
;
14439 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14445 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14447 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14449 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14451 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14453 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14457 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14459 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14461 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14463 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14467 char *keybuf_pos
= strchr (keylen_pos
, '$');
14469 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14471 uint keylen_len
= keybuf_pos
- keylen_pos
;
14473 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14477 char *databuf_pos
= strchr (keybuf_pos
, '$');
14479 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14481 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14483 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14487 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14489 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14495 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14496 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14497 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14498 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14500 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14501 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14502 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14503 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14505 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14506 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14507 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14508 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14510 salt
->salt_len
= 16;
14511 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14513 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14515 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14518 return (PARSER_OK
);
14521 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14523 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14525 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14527 u32
*digest
= (u32
*) hash_buf
->digest
;
14529 salt_t
*salt
= hash_buf
->salt
;
14535 // first is the N salt parameter
14537 char *N_pos
= input_buf
+ 6;
14539 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14543 salt
->scrypt_N
= atoi (N_pos
);
14547 char *r_pos
= strchr (N_pos
, ':');
14549 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14553 salt
->scrypt_r
= atoi (r_pos
);
14557 char *p_pos
= strchr (r_pos
, ':');
14559 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14563 salt
->scrypt_p
= atoi (p_pos
);
14567 char *saltbuf_pos
= strchr (p_pos
, ':');
14569 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14573 char *hash_pos
= strchr (saltbuf_pos
, ':');
14575 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14581 u8 tmp_buf
[33] = { 0 };
14583 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14585 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14587 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14589 salt
->salt_len
= tmp_len
;
14590 salt
->salt_iter
= 1;
14592 // digest - base64 decode
14594 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14596 tmp_len
= input_len
- (hash_pos
- input_buf
);
14598 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14600 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14602 memcpy (digest
, tmp_buf
, 32);
14604 return (PARSER_OK
);
14607 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14609 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14611 u32
*digest
= (u32
*) hash_buf
->digest
;
14613 salt_t
*salt
= hash_buf
->salt
;
14619 char decrypted
[76] = { 0 }; // iv + hash
14621 juniper_decrypt_hash (input_buf
, decrypted
);
14623 char *md5crypt_hash
= decrypted
+ 12;
14625 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14627 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14629 char *salt_pos
= md5crypt_hash
+ 3;
14631 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14633 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14635 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14639 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14641 return (PARSER_OK
);
14644 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14646 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14648 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14650 u32
*digest
= (u32
*) hash_buf
->digest
;
14652 salt_t
*salt
= hash_buf
->salt
;
14654 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14660 // first is *raw* salt
14662 char *salt_pos
= input_buf
+ 3;
14664 char *hash_pos
= strchr (salt_pos
, '$');
14666 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14668 uint salt_len
= hash_pos
- salt_pos
;
14670 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14674 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14676 memcpy (salt_buf_ptr
, salt_pos
, 14);
14678 salt_buf_ptr
[17] = 0x01;
14679 salt_buf_ptr
[18] = 0x80;
14681 // add some stuff to normal salt to make sorted happy
14683 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14684 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14685 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14686 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14688 salt
->salt_len
= salt_len
;
14689 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14691 // base64 decode hash
14693 u8 tmp_buf
[100] = { 0 };
14695 uint hash_len
= input_len
- 3 - salt_len
- 1;
14697 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14699 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14701 memcpy (digest
, tmp_buf
, 32);
14703 digest
[0] = byte_swap_32 (digest
[0]);
14704 digest
[1] = byte_swap_32 (digest
[1]);
14705 digest
[2] = byte_swap_32 (digest
[2]);
14706 digest
[3] = byte_swap_32 (digest
[3]);
14707 digest
[4] = byte_swap_32 (digest
[4]);
14708 digest
[5] = byte_swap_32 (digest
[5]);
14709 digest
[6] = byte_swap_32 (digest
[6]);
14710 digest
[7] = byte_swap_32 (digest
[7]);
14712 return (PARSER_OK
);
14715 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14717 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14719 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14721 u32
*digest
= (u32
*) hash_buf
->digest
;
14723 salt_t
*salt
= hash_buf
->salt
;
14729 // first is *raw* salt
14731 char *salt_pos
= input_buf
+ 3;
14733 char *hash_pos
= strchr (salt_pos
, '$');
14735 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14737 uint salt_len
= hash_pos
- salt_pos
;
14739 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14741 salt
->salt_len
= salt_len
;
14744 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14746 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14747 salt_buf_ptr
[salt_len
] = 0;
14749 // base64 decode hash
14751 u8 tmp_buf
[100] = { 0 };
14753 uint hash_len
= input_len
- 3 - salt_len
- 1;
14755 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14757 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14759 memcpy (digest
, tmp_buf
, 32);
14762 salt
->scrypt_N
= 16384;
14763 salt
->scrypt_r
= 1;
14764 salt
->scrypt_p
= 1;
14765 salt
->salt_iter
= 1;
14767 return (PARSER_OK
);
14770 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14772 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14774 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14776 u32
*digest
= (u32
*) hash_buf
->digest
;
14778 salt_t
*salt
= hash_buf
->salt
;
14780 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14786 char *version_pos
= input_buf
+ 8 + 1;
14788 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14790 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14792 u32 version_len
= verifierHashSize_pos
- version_pos
;
14794 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14796 verifierHashSize_pos
++;
14798 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14800 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14802 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14804 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14808 char *saltSize_pos
= strchr (keySize_pos
, '*');
14810 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14812 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14814 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14818 char *osalt_pos
= strchr (saltSize_pos
, '*');
14820 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14822 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14824 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14828 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14830 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14832 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14834 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14836 encryptedVerifier_pos
++;
14838 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14840 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14842 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14844 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14846 encryptedVerifierHash_pos
++;
14848 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;
14850 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14852 const uint version
= atoi (version_pos
);
14854 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14856 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14858 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14860 const uint keySize
= atoi (keySize_pos
);
14862 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14864 office2007
->keySize
= keySize
;
14866 const uint saltSize
= atoi (saltSize_pos
);
14868 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14874 salt
->salt_len
= 16;
14875 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14877 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14878 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14879 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14880 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14886 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14887 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14888 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14889 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14891 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14892 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14893 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14894 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14895 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14901 digest
[0] = office2007
->encryptedVerifierHash
[0];
14902 digest
[1] = office2007
->encryptedVerifierHash
[1];
14903 digest
[2] = office2007
->encryptedVerifierHash
[2];
14904 digest
[3] = office2007
->encryptedVerifierHash
[3];
14906 return (PARSER_OK
);
14909 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14911 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14913 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14915 u32
*digest
= (u32
*) hash_buf
->digest
;
14917 salt_t
*salt
= hash_buf
->salt
;
14919 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14925 char *version_pos
= input_buf
+ 8 + 1;
14927 char *spinCount_pos
= strchr (version_pos
, '*');
14929 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14931 u32 version_len
= spinCount_pos
- version_pos
;
14933 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14937 char *keySize_pos
= strchr (spinCount_pos
, '*');
14939 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14941 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
14943 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14947 char *saltSize_pos
= strchr (keySize_pos
, '*');
14949 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14951 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14953 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14957 char *osalt_pos
= strchr (saltSize_pos
, '*');
14959 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14961 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14963 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14967 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14969 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14971 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14973 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14975 encryptedVerifier_pos
++;
14977 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14979 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14981 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14983 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14985 encryptedVerifierHash_pos
++;
14987 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;
14989 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14991 const uint version
= atoi (version_pos
);
14993 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14995 const uint spinCount
= atoi (spinCount_pos
);
14997 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14999 const uint keySize
= atoi (keySize_pos
);
15001 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15003 const uint saltSize
= atoi (saltSize_pos
);
15005 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15011 salt
->salt_len
= 16;
15012 salt
->salt_iter
= spinCount
;
15014 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15015 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15016 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15017 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15023 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15024 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15025 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15026 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15028 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15029 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15030 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15031 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15032 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15033 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15034 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15035 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15041 digest
[0] = office2010
->encryptedVerifierHash
[0];
15042 digest
[1] = office2010
->encryptedVerifierHash
[1];
15043 digest
[2] = office2010
->encryptedVerifierHash
[2];
15044 digest
[3] = office2010
->encryptedVerifierHash
[3];
15046 return (PARSER_OK
);
15049 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15051 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15053 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15055 u32
*digest
= (u32
*) hash_buf
->digest
;
15057 salt_t
*salt
= hash_buf
->salt
;
15059 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15065 char *version_pos
= input_buf
+ 8 + 1;
15067 char *spinCount_pos
= strchr (version_pos
, '*');
15069 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15071 u32 version_len
= spinCount_pos
- version_pos
;
15073 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15077 char *keySize_pos
= strchr (spinCount_pos
, '*');
15079 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15081 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15083 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15087 char *saltSize_pos
= strchr (keySize_pos
, '*');
15089 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15091 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15093 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15097 char *osalt_pos
= strchr (saltSize_pos
, '*');
15099 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15101 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15103 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15107 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15109 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15111 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15113 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15115 encryptedVerifier_pos
++;
15117 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15119 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15121 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15123 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15125 encryptedVerifierHash_pos
++;
15127 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;
15129 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15131 const uint version
= atoi (version_pos
);
15133 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15135 const uint spinCount
= atoi (spinCount_pos
);
15137 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15139 const uint keySize
= atoi (keySize_pos
);
15141 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15143 const uint saltSize
= atoi (saltSize_pos
);
15145 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15151 salt
->salt_len
= 16;
15152 salt
->salt_iter
= spinCount
;
15154 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15155 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15156 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15157 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15163 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15164 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15165 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15166 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15168 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15169 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15170 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15171 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15172 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15173 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15174 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15175 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15181 digest
[0] = office2013
->encryptedVerifierHash
[0];
15182 digest
[1] = office2013
->encryptedVerifierHash
[1];
15183 digest
[2] = office2013
->encryptedVerifierHash
[2];
15184 digest
[3] = office2013
->encryptedVerifierHash
[3];
15186 return (PARSER_OK
);
15189 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15191 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15193 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15195 u32
*digest
= (u32
*) hash_buf
->digest
;
15197 salt_t
*salt
= hash_buf
->salt
;
15199 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15205 char *version_pos
= input_buf
+ 11;
15207 char *osalt_pos
= strchr (version_pos
, '*');
15209 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15211 u32 version_len
= osalt_pos
- version_pos
;
15213 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15217 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15219 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15221 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15223 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15225 encryptedVerifier_pos
++;
15227 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15229 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15231 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15233 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15235 encryptedVerifierHash_pos
++;
15237 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15239 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15241 const uint version
= *version_pos
- 0x30;
15243 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15249 oldoffice01
->version
= version
;
15251 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15252 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15253 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15254 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15256 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15257 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15258 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15259 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15261 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15262 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15263 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15264 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15266 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15267 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15268 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15269 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15275 salt
->salt_len
= 16;
15277 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15278 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15279 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15280 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15282 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15283 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15284 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15285 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15287 // this is a workaround as office produces multiple documents with the same salt
15289 salt
->salt_len
+= 32;
15291 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15292 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15293 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15294 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15295 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15296 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15297 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15298 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15304 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15305 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15306 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15307 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15309 return (PARSER_OK
);
15312 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15314 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15317 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15319 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15321 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15323 u32
*digest
= (u32
*) hash_buf
->digest
;
15325 salt_t
*salt
= hash_buf
->salt
;
15327 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15333 char *version_pos
= input_buf
+ 11;
15335 char *osalt_pos
= strchr (version_pos
, '*');
15337 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15339 u32 version_len
= osalt_pos
- version_pos
;
15341 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15345 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15347 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15349 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15351 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15353 encryptedVerifier_pos
++;
15355 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15357 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15359 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15361 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15363 encryptedVerifierHash_pos
++;
15365 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15367 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15369 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15371 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15375 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15377 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15379 const uint version
= *version_pos
- 0x30;
15381 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15387 oldoffice01
->version
= version
;
15389 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15390 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15391 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15392 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15394 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15395 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15396 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15397 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15399 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15400 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15401 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15402 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15404 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15405 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15406 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15407 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15409 oldoffice01
->rc4key
[1] = 0;
15410 oldoffice01
->rc4key
[0] = 0;
15412 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15413 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15414 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15415 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15416 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15417 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15418 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15419 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15420 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15421 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15423 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15424 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15430 salt
->salt_len
= 16;
15432 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15433 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15434 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15435 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15437 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15438 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15439 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15440 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15442 // this is a workaround as office produces multiple documents with the same salt
15444 salt
->salt_len
+= 32;
15446 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15447 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15448 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15449 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15450 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15451 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15452 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15453 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15459 digest
[0] = oldoffice01
->rc4key
[0];
15460 digest
[1] = oldoffice01
->rc4key
[1];
15464 return (PARSER_OK
);
15467 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15469 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15471 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15473 u32
*digest
= (u32
*) hash_buf
->digest
;
15475 salt_t
*salt
= hash_buf
->salt
;
15477 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15483 char *version_pos
= input_buf
+ 11;
15485 char *osalt_pos
= strchr (version_pos
, '*');
15487 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15489 u32 version_len
= osalt_pos
- version_pos
;
15491 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15495 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15497 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15499 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15501 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15503 encryptedVerifier_pos
++;
15505 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15507 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15509 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15511 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15513 encryptedVerifierHash_pos
++;
15515 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15517 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15519 const uint version
= *version_pos
- 0x30;
15521 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15527 oldoffice34
->version
= version
;
15529 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15530 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15531 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15532 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15534 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15535 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15536 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15537 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15539 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15540 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15541 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15542 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15543 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15545 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15546 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15547 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15548 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15549 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15555 salt
->salt_len
= 16;
15557 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15558 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15559 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15560 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15562 // this is a workaround as office produces multiple documents with the same salt
15564 salt
->salt_len
+= 32;
15566 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15567 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15568 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15569 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15570 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15571 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15572 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15573 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15579 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15580 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15581 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15582 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15584 return (PARSER_OK
);
15587 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15589 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15591 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15594 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15596 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15598 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15600 u32
*digest
= (u32
*) hash_buf
->digest
;
15602 salt_t
*salt
= hash_buf
->salt
;
15604 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15610 char *version_pos
= input_buf
+ 11;
15612 char *osalt_pos
= strchr (version_pos
, '*');
15614 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15616 u32 version_len
= osalt_pos
- version_pos
;
15618 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15622 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15624 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15626 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15628 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15630 encryptedVerifier_pos
++;
15632 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15634 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15636 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15638 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15640 encryptedVerifierHash_pos
++;
15642 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15644 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15646 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15648 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15652 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15654 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15656 const uint version
= *version_pos
- 0x30;
15658 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15664 oldoffice34
->version
= version
;
15666 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15667 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15668 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15669 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15671 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15672 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15673 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15674 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15676 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15677 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15678 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15679 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15680 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15682 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15683 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15684 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15685 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15686 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15688 oldoffice34
->rc4key
[1] = 0;
15689 oldoffice34
->rc4key
[0] = 0;
15691 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15692 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15693 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15694 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15695 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15696 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15697 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15698 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15699 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15700 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15702 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15703 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15709 salt
->salt_len
= 16;
15711 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15712 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15713 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15714 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15716 // this is a workaround as office produces multiple documents with the same salt
15718 salt
->salt_len
+= 32;
15720 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15721 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15722 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15723 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15724 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15725 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15726 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15727 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15733 digest
[0] = oldoffice34
->rc4key
[0];
15734 digest
[1] = oldoffice34
->rc4key
[1];
15738 return (PARSER_OK
);
15741 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15743 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15745 u32
*digest
= (u32
*) hash_buf
->digest
;
15747 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15748 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15749 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15750 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15752 digest
[0] = byte_swap_32 (digest
[0]);
15753 digest
[1] = byte_swap_32 (digest
[1]);
15754 digest
[2] = byte_swap_32 (digest
[2]);
15755 digest
[3] = byte_swap_32 (digest
[3]);
15757 return (PARSER_OK
);
15760 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15762 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15764 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15766 u32
*digest
= (u32
*) hash_buf
->digest
;
15768 salt_t
*salt
= hash_buf
->salt
;
15770 char *signature_pos
= input_buf
;
15772 char *salt_pos
= strchr (signature_pos
, '$');
15774 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15776 u32 signature_len
= salt_pos
- signature_pos
;
15778 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15782 char *hash_pos
= strchr (salt_pos
, '$');
15784 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15786 u32 salt_len
= hash_pos
- salt_pos
;
15788 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15792 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15794 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15796 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15797 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15798 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15799 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15800 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15802 digest
[0] -= SHA1M_A
;
15803 digest
[1] -= SHA1M_B
;
15804 digest
[2] -= SHA1M_C
;
15805 digest
[3] -= SHA1M_D
;
15806 digest
[4] -= SHA1M_E
;
15808 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15810 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15812 salt
->salt_len
= salt_len
;
15814 return (PARSER_OK
);
15817 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15819 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15821 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15823 u32
*digest
= (u32
*) hash_buf
->digest
;
15825 salt_t
*salt
= hash_buf
->salt
;
15827 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15833 char *iter_pos
= input_buf
+ 14;
15835 const int iter
= atoi (iter_pos
);
15837 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15839 salt
->salt_iter
= iter
- 1;
15841 char *salt_pos
= strchr (iter_pos
, '$');
15843 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15847 char *hash_pos
= strchr (salt_pos
, '$');
15849 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15851 const uint salt_len
= hash_pos
- salt_pos
;
15855 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15857 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15859 salt
->salt_len
= salt_len
;
15861 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15862 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15864 // add some stuff to normal salt to make sorted happy
15866 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15867 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15868 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15869 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15870 salt
->salt_buf
[4] = salt
->salt_iter
;
15872 // base64 decode hash
15874 u8 tmp_buf
[100] = { 0 };
15876 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15878 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15880 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15882 memcpy (digest
, tmp_buf
, 32);
15884 digest
[0] = byte_swap_32 (digest
[0]);
15885 digest
[1] = byte_swap_32 (digest
[1]);
15886 digest
[2] = byte_swap_32 (digest
[2]);
15887 digest
[3] = byte_swap_32 (digest
[3]);
15888 digest
[4] = byte_swap_32 (digest
[4]);
15889 digest
[5] = byte_swap_32 (digest
[5]);
15890 digest
[6] = byte_swap_32 (digest
[6]);
15891 digest
[7] = byte_swap_32 (digest
[7]);
15893 return (PARSER_OK
);
15896 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15898 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15900 u32
*digest
= (u32
*) hash_buf
->digest
;
15902 salt_t
*salt
= hash_buf
->salt
;
15904 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15905 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15909 digest
[0] = byte_swap_32 (digest
[0]);
15910 digest
[1] = byte_swap_32 (digest
[1]);
15912 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15913 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15914 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15916 char iter_c
= input_buf
[17];
15917 char iter_d
= input_buf
[19];
15919 // atm only defaults, let's see if there's more request
15920 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15921 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15923 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15925 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15926 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15927 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15928 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15930 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15931 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15932 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15933 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15935 salt
->salt_len
= 16;
15937 return (PARSER_OK
);
15940 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15942 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15944 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15946 u32
*digest
= (u32
*) hash_buf
->digest
;
15948 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15950 salt_t
*salt
= hash_buf
->salt
;
15952 char *salt_pos
= input_buf
+ 10;
15954 char *hash_pos
= strchr (salt_pos
, '$');
15956 uint salt_len
= hash_pos
- salt_pos
;
15958 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15962 uint hash_len
= input_len
- 10 - salt_len
- 1;
15964 // base64 decode salt
15966 u8 tmp_buf
[100] = { 0 };
15968 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
15970 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15972 tmp_buf
[salt_len
] = 0x80;
15974 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15976 salt
->salt_len
= salt_len
;
15978 // base64 decode salt
15980 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15982 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15984 uint user_len
= hash_len
- 32;
15986 const u8
*tmp_hash
= tmp_buf
+ user_len
;
15988 user_len
--; // skip the trailing space
15990 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
15991 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
15992 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
15993 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
15995 digest
[0] = byte_swap_32 (digest
[0]);
15996 digest
[1] = byte_swap_32 (digest
[1]);
15997 digest
[2] = byte_swap_32 (digest
[2]);
15998 digest
[3] = byte_swap_32 (digest
[3]);
16000 // store username for host only (output hash if cracked)
16002 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16003 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16005 return (PARSER_OK
);
16008 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16010 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16012 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16014 u32
*digest
= (u32
*) hash_buf
->digest
;
16016 salt_t
*salt
= hash_buf
->salt
;
16018 char *iter_pos
= input_buf
+ 10;
16020 u32 iter
= atoi (iter_pos
);
16024 return (PARSER_SALT_ITERATION
);
16027 iter
--; // first iteration is special
16029 salt
->salt_iter
= iter
;
16031 char *base64_pos
= strchr (iter_pos
, '}');
16033 if (base64_pos
== NULL
)
16035 return (PARSER_SIGNATURE_UNMATCHED
);
16040 // base64 decode salt
16042 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16044 u8 tmp_buf
[100] = { 0 };
16046 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16048 if (decoded_len
< 24)
16050 return (PARSER_SALT_LENGTH
);
16055 uint salt_len
= decoded_len
- 20;
16057 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16058 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16060 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16062 salt
->salt_len
= salt_len
;
16066 u32
*digest_ptr
= (u32
*) tmp_buf
;
16068 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16069 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16070 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16071 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16072 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16074 return (PARSER_OK
);
16077 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16079 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16081 u32
*digest
= (u32
*) hash_buf
->digest
;
16083 salt_t
*salt
= hash_buf
->salt
;
16085 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16086 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16087 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16088 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16089 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16091 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16093 uint salt_len
= input_len
- 40 - 1;
16095 char *salt_buf
= input_buf
+ 40 + 1;
16097 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16099 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16101 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16103 salt
->salt_len
= salt_len
;
16105 return (PARSER_OK
);
16108 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16110 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16112 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16114 u32
*digest
= (u32
*) hash_buf
->digest
;
16116 salt_t
*salt
= hash_buf
->salt
;
16118 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16124 char *V_pos
= input_buf
+ 5;
16126 char *R_pos
= strchr (V_pos
, '*');
16128 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16130 u32 V_len
= R_pos
- V_pos
;
16134 char *bits_pos
= strchr (R_pos
, '*');
16136 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16138 u32 R_len
= bits_pos
- R_pos
;
16142 char *P_pos
= strchr (bits_pos
, '*');
16144 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16146 u32 bits_len
= P_pos
- bits_pos
;
16150 char *enc_md_pos
= strchr (P_pos
, '*');
16152 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16154 u32 P_len
= enc_md_pos
- P_pos
;
16158 char *id_len_pos
= strchr (enc_md_pos
, '*');
16160 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16162 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16166 char *id_buf_pos
= strchr (id_len_pos
, '*');
16168 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16170 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16174 char *u_len_pos
= strchr (id_buf_pos
, '*');
16176 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16178 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16180 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16184 char *u_buf_pos
= strchr (u_len_pos
, '*');
16186 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16188 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16192 char *o_len_pos
= strchr (u_buf_pos
, '*');
16194 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16196 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16198 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16202 char *o_buf_pos
= strchr (o_len_pos
, '*');
16204 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16206 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16210 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;
16212 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16216 const int V
= atoi (V_pos
);
16217 const int R
= atoi (R_pos
);
16218 const int P
= atoi (P_pos
);
16220 if (V
!= 1) return (PARSER_SALT_VALUE
);
16221 if (R
!= 2) return (PARSER_SALT_VALUE
);
16223 const int enc_md
= atoi (enc_md_pos
);
16225 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16227 const int id_len
= atoi (id_len_pos
);
16228 const int u_len
= atoi (u_len_pos
);
16229 const int o_len
= atoi (o_len_pos
);
16231 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16232 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16233 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16235 const int bits
= atoi (bits_pos
);
16237 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16239 // copy data to esalt
16245 pdf
->enc_md
= enc_md
;
16247 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16248 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16249 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16250 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16251 pdf
->id_len
= id_len
;
16253 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16254 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16255 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16256 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16257 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16258 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16259 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16260 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16261 pdf
->u_len
= u_len
;
16263 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16264 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16265 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16266 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16267 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16268 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16269 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16270 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16271 pdf
->o_len
= o_len
;
16273 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16274 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16275 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16276 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16278 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16279 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16280 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16281 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16282 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16283 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16284 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16285 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16287 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16288 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16289 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16290 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16291 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16292 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16293 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16294 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16296 // we use ID for salt, maybe needs to change, we will see...
16298 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16299 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16300 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16301 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16302 salt
->salt_len
= pdf
->id_len
;
16304 digest
[0] = pdf
->u_buf
[0];
16305 digest
[1] = pdf
->u_buf
[1];
16306 digest
[2] = pdf
->u_buf
[2];
16307 digest
[3] = pdf
->u_buf
[3];
16309 return (PARSER_OK
);
16312 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16314 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16317 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16319 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16321 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16323 u32
*digest
= (u32
*) hash_buf
->digest
;
16325 salt_t
*salt
= hash_buf
->salt
;
16327 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16333 char *V_pos
= input_buf
+ 5;
16335 char *R_pos
= strchr (V_pos
, '*');
16337 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16339 u32 V_len
= R_pos
- V_pos
;
16343 char *bits_pos
= strchr (R_pos
, '*');
16345 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16347 u32 R_len
= bits_pos
- R_pos
;
16351 char *P_pos
= strchr (bits_pos
, '*');
16353 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16355 u32 bits_len
= P_pos
- bits_pos
;
16359 char *enc_md_pos
= strchr (P_pos
, '*');
16361 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16363 u32 P_len
= enc_md_pos
- P_pos
;
16367 char *id_len_pos
= strchr (enc_md_pos
, '*');
16369 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16371 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16375 char *id_buf_pos
= strchr (id_len_pos
, '*');
16377 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16379 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16383 char *u_len_pos
= strchr (id_buf_pos
, '*');
16385 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16387 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16389 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16393 char *u_buf_pos
= strchr (u_len_pos
, '*');
16395 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16397 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16401 char *o_len_pos
= strchr (u_buf_pos
, '*');
16403 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16405 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16407 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16411 char *o_buf_pos
= strchr (o_len_pos
, '*');
16413 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16415 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16419 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16421 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16423 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16425 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16429 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;
16431 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16435 const int V
= atoi (V_pos
);
16436 const int R
= atoi (R_pos
);
16437 const int P
= atoi (P_pos
);
16439 if (V
!= 1) return (PARSER_SALT_VALUE
);
16440 if (R
!= 2) return (PARSER_SALT_VALUE
);
16442 const int enc_md
= atoi (enc_md_pos
);
16444 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16446 const int id_len
= atoi (id_len_pos
);
16447 const int u_len
= atoi (u_len_pos
);
16448 const int o_len
= atoi (o_len_pos
);
16450 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16451 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16452 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16454 const int bits
= atoi (bits_pos
);
16456 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16458 // copy data to esalt
16464 pdf
->enc_md
= enc_md
;
16466 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16467 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16468 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16469 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16470 pdf
->id_len
= id_len
;
16472 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16473 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16474 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16475 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16476 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16477 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16478 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16479 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16480 pdf
->u_len
= u_len
;
16482 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16483 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16484 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16485 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16486 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16487 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16488 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16489 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16490 pdf
->o_len
= o_len
;
16492 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16493 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16494 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16495 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16497 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16498 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16499 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16500 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16501 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16502 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16503 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16504 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16506 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16507 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16508 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16509 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16510 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16511 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16512 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16513 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16515 pdf
->rc4key
[1] = 0;
16516 pdf
->rc4key
[0] = 0;
16518 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16519 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16520 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16521 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16522 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16523 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16524 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16525 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16526 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16527 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16529 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16530 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16532 // we use ID for salt, maybe needs to change, we will see...
16534 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16535 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16536 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16537 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16538 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16539 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16540 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16541 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16542 salt
->salt_len
= pdf
->id_len
+ 16;
16544 digest
[0] = pdf
->rc4key
[0];
16545 digest
[1] = pdf
->rc4key
[1];
16549 return (PARSER_OK
);
16552 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16554 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16556 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16558 u32
*digest
= (u32
*) hash_buf
->digest
;
16560 salt_t
*salt
= hash_buf
->salt
;
16562 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16568 char *V_pos
= input_buf
+ 5;
16570 char *R_pos
= strchr (V_pos
, '*');
16572 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16574 u32 V_len
= R_pos
- V_pos
;
16578 char *bits_pos
= strchr (R_pos
, '*');
16580 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16582 u32 R_len
= bits_pos
- R_pos
;
16586 char *P_pos
= strchr (bits_pos
, '*');
16588 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16590 u32 bits_len
= P_pos
- bits_pos
;
16594 char *enc_md_pos
= strchr (P_pos
, '*');
16596 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16598 u32 P_len
= enc_md_pos
- P_pos
;
16602 char *id_len_pos
= strchr (enc_md_pos
, '*');
16604 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16606 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16610 char *id_buf_pos
= strchr (id_len_pos
, '*');
16612 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16614 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16618 char *u_len_pos
= strchr (id_buf_pos
, '*');
16620 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16622 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16624 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16628 char *u_buf_pos
= strchr (u_len_pos
, '*');
16630 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16632 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16636 char *o_len_pos
= strchr (u_buf_pos
, '*');
16638 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16640 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16642 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16646 char *o_buf_pos
= strchr (o_len_pos
, '*');
16648 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16650 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16654 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;
16656 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16660 const int V
= atoi (V_pos
);
16661 const int R
= atoi (R_pos
);
16662 const int P
= atoi (P_pos
);
16666 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16667 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16669 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16671 const int id_len
= atoi (id_len_pos
);
16672 const int u_len
= atoi (u_len_pos
);
16673 const int o_len
= atoi (o_len_pos
);
16675 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16677 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16678 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16680 const int bits
= atoi (bits_pos
);
16682 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16688 enc_md
= atoi (enc_md_pos
);
16691 // copy data to esalt
16697 pdf
->enc_md
= enc_md
;
16699 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16700 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16701 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16702 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16706 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16707 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16708 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16709 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16712 pdf
->id_len
= id_len
;
16714 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16715 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16716 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16717 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16718 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16719 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16720 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16721 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16722 pdf
->u_len
= u_len
;
16724 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16725 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16726 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16727 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16728 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16729 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16730 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16731 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16732 pdf
->o_len
= o_len
;
16734 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16735 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16736 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16737 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16741 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16742 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16743 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16744 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16747 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16748 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16749 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16750 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16751 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16752 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16753 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16754 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16756 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16757 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16758 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16759 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16760 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16761 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16762 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16763 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16765 // precompute rc4 data for later use
16781 uint salt_pc_block
[32] = { 0 };
16783 char *salt_pc_ptr
= (char *) salt_pc_block
;
16785 memcpy (salt_pc_ptr
, padding
, 32);
16786 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16788 uint salt_pc_digest
[4] = { 0 };
16790 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16792 pdf
->rc4data
[0] = salt_pc_digest
[0];
16793 pdf
->rc4data
[1] = salt_pc_digest
[1];
16795 // we use ID for salt, maybe needs to change, we will see...
16797 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16798 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16799 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16800 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16801 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16802 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16803 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16804 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16805 salt
->salt_len
= pdf
->id_len
+ 16;
16807 salt
->salt_iter
= ROUNDS_PDF14
;
16809 digest
[0] = pdf
->u_buf
[0];
16810 digest
[1] = pdf
->u_buf
[1];
16814 return (PARSER_OK
);
16817 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16819 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16821 if (ret
!= PARSER_OK
)
16826 u32
*digest
= (u32
*) hash_buf
->digest
;
16828 salt_t
*salt
= hash_buf
->salt
;
16830 digest
[0] -= SHA256M_A
;
16831 digest
[1] -= SHA256M_B
;
16832 digest
[2] -= SHA256M_C
;
16833 digest
[3] -= SHA256M_D
;
16834 digest
[4] -= SHA256M_E
;
16835 digest
[5] -= SHA256M_F
;
16836 digest
[6] -= SHA256M_G
;
16837 digest
[7] -= SHA256M_H
;
16839 salt
->salt_buf
[2] = 0x80;
16841 return (PARSER_OK
);
16844 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16846 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16848 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16850 u32
*digest
= (u32
*) hash_buf
->digest
;
16852 salt_t
*salt
= hash_buf
->salt
;
16854 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16860 char *V_pos
= input_buf
+ 5;
16862 char *R_pos
= strchr (V_pos
, '*');
16864 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16866 u32 V_len
= R_pos
- V_pos
;
16870 char *bits_pos
= strchr (R_pos
, '*');
16872 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16874 u32 R_len
= bits_pos
- R_pos
;
16878 char *P_pos
= strchr (bits_pos
, '*');
16880 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16882 u32 bits_len
= P_pos
- bits_pos
;
16886 char *enc_md_pos
= strchr (P_pos
, '*');
16888 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16890 u32 P_len
= enc_md_pos
- P_pos
;
16894 char *id_len_pos
= strchr (enc_md_pos
, '*');
16896 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16898 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16902 char *id_buf_pos
= strchr (id_len_pos
, '*');
16904 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16906 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16910 char *u_len_pos
= strchr (id_buf_pos
, '*');
16912 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16914 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16918 char *u_buf_pos
= strchr (u_len_pos
, '*');
16920 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16922 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16926 char *o_len_pos
= strchr (u_buf_pos
, '*');
16928 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16930 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16934 char *o_buf_pos
= strchr (o_len_pos
, '*');
16936 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16938 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16942 char *last
= strchr (o_buf_pos
, '*');
16944 if (last
== NULL
) last
= input_buf
+ input_len
;
16946 u32 o_buf_len
= last
- o_buf_pos
;
16950 const int V
= atoi (V_pos
);
16951 const int R
= atoi (R_pos
);
16955 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16956 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16958 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16960 const int bits
= atoi (bits_pos
);
16962 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16964 int enc_md
= atoi (enc_md_pos
);
16966 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16968 const uint id_len
= atoi (id_len_pos
);
16969 const uint u_len
= atoi (u_len_pos
);
16970 const uint o_len
= atoi (o_len_pos
);
16972 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16973 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16974 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16975 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16976 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16977 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16978 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16979 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16981 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16982 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16983 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16985 // copy data to esalt
16987 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16989 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16991 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
16994 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16995 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16997 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16998 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17000 salt
->salt_len
= 8;
17001 salt
->salt_iter
= ROUNDS_PDF17L8
;
17003 digest
[0] = pdf
->u_buf
[0];
17004 digest
[1] = pdf
->u_buf
[1];
17005 digest
[2] = pdf
->u_buf
[2];
17006 digest
[3] = pdf
->u_buf
[3];
17007 digest
[4] = pdf
->u_buf
[4];
17008 digest
[5] = pdf
->u_buf
[5];
17009 digest
[6] = pdf
->u_buf
[6];
17010 digest
[7] = pdf
->u_buf
[7];
17012 return (PARSER_OK
);
17015 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17017 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17019 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17021 u32
*digest
= (u32
*) hash_buf
->digest
;
17023 salt_t
*salt
= hash_buf
->salt
;
17025 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17033 char *iter_pos
= input_buf
+ 7;
17035 u32 iter
= atoi (iter_pos
);
17037 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17038 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17040 // first is *raw* salt
17042 char *salt_pos
= strchr (iter_pos
, ':');
17044 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17048 char *hash_pos
= strchr (salt_pos
, ':');
17050 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17052 u32 salt_len
= hash_pos
- salt_pos
;
17054 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17058 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17060 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17064 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17066 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17068 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17070 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17071 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17073 salt
->salt_len
= salt_len
;
17074 salt
->salt_iter
= iter
- 1;
17078 u8 tmp_buf
[100] = { 0 };
17080 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17082 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17084 memcpy (digest
, tmp_buf
, 16);
17086 digest
[0] = byte_swap_32 (digest
[0]);
17087 digest
[1] = byte_swap_32 (digest
[1]);
17088 digest
[2] = byte_swap_32 (digest
[2]);
17089 digest
[3] = byte_swap_32 (digest
[3]);
17091 // add some stuff to normal salt to make sorted happy
17093 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17094 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17095 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17096 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17097 salt
->salt_buf
[4] = salt
->salt_iter
;
17099 return (PARSER_OK
);
17102 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17104 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17106 u32
*digest
= (u32
*) hash_buf
->digest
;
17108 salt_t
*salt
= hash_buf
->salt
;
17110 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17111 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17112 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17113 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17115 digest
[0] = byte_swap_32 (digest
[0]);
17116 digest
[1] = byte_swap_32 (digest
[1]);
17117 digest
[2] = byte_swap_32 (digest
[2]);
17118 digest
[3] = byte_swap_32 (digest
[3]);
17120 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17122 uint salt_len
= input_len
- 32 - 1;
17124 char *salt_buf
= input_buf
+ 32 + 1;
17126 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17128 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17130 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17132 salt
->salt_len
= salt_len
;
17134 return (PARSER_OK
);
17137 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17139 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17141 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17143 u32
*digest
= (u32
*) hash_buf
->digest
;
17145 salt_t
*salt
= hash_buf
->salt
;
17147 char *user_pos
= input_buf
+ 10;
17149 char *salt_pos
= strchr (user_pos
, '*');
17151 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17155 char *hash_pos
= strchr (salt_pos
, '*');
17159 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17161 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17163 uint user_len
= salt_pos
- user_pos
- 1;
17165 uint salt_len
= hash_pos
- salt_pos
- 1;
17167 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17173 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17174 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17175 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17176 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17178 digest
[0] = byte_swap_32 (digest
[0]);
17179 digest
[1] = byte_swap_32 (digest
[1]);
17180 digest
[2] = byte_swap_32 (digest
[2]);
17181 digest
[3] = byte_swap_32 (digest
[3]);
17183 digest
[0] -= MD5M_A
;
17184 digest
[1] -= MD5M_B
;
17185 digest
[2] -= MD5M_C
;
17186 digest
[3] -= MD5M_D
;
17192 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17194 // first 4 bytes are the "challenge"
17196 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17197 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17198 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17199 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17201 // append the user name
17203 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17205 salt
->salt_len
= 4 + user_len
;
17207 return (PARSER_OK
);
17210 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17212 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17214 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17216 u32
*digest
= (u32
*) hash_buf
->digest
;
17218 salt_t
*salt
= hash_buf
->salt
;
17220 char *salt_pos
= input_buf
+ 9;
17222 char *hash_pos
= strchr (salt_pos
, '*');
17224 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17228 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17230 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17232 uint salt_len
= hash_pos
- salt_pos
- 1;
17234 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17240 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17241 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17242 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17243 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17244 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17250 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17252 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17254 salt
->salt_len
= salt_len
;
17256 return (PARSER_OK
);
17259 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17261 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17263 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17265 u32
*digest
= (u32
*) hash_buf
->digest
;
17267 salt_t
*salt
= hash_buf
->salt
;
17269 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17275 char *cry_master_len_pos
= input_buf
+ 9;
17277 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17279 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17281 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17283 cry_master_buf_pos
++;
17285 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17287 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17289 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17291 cry_salt_len_pos
++;
17293 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17295 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17297 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17299 cry_salt_buf_pos
++;
17301 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17303 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17305 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17309 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17311 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17313 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17317 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17319 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17321 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17325 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17327 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17329 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17331 public_key_len_pos
++;
17333 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17335 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17337 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17339 public_key_buf_pos
++;
17341 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;
17343 const uint cry_master_len
= atoi (cry_master_len_pos
);
17344 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17345 const uint ckey_len
= atoi (ckey_len_pos
);
17346 const uint public_key_len
= atoi (public_key_len_pos
);
17348 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17349 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17350 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17351 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17353 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17355 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17357 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17360 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17362 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17364 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17367 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17369 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17371 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17374 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17375 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17376 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17379 * store digest (should be unique enought, hopefully)
17382 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17383 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17384 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17385 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17391 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17393 const uint cry_rounds
= atoi (cry_rounds_pos
);
17395 salt
->salt_iter
= cry_rounds
- 1;
17397 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17399 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17401 salt
->salt_len
= salt_len
;
17403 return (PARSER_OK
);
17406 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17408 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17410 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17412 u32
*digest
= (u32
*) hash_buf
->digest
;
17414 salt_t
*salt
= hash_buf
->salt
;
17416 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17418 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17420 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17422 memcpy (temp_input_buf
, input_buf
, input_len
);
17426 char *URI_server_pos
= temp_input_buf
+ 6;
17428 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17430 if (URI_client_pos
== NULL
)
17432 myfree (temp_input_buf
);
17434 return (PARSER_SEPARATOR_UNMATCHED
);
17437 URI_client_pos
[0] = 0;
17440 uint URI_server_len
= strlen (URI_server_pos
);
17442 if (URI_server_len
> 512)
17444 myfree (temp_input_buf
);
17446 return (PARSER_SALT_LENGTH
);
17451 char *user_pos
= strchr (URI_client_pos
, '*');
17453 if (user_pos
== NULL
)
17455 myfree (temp_input_buf
);
17457 return (PARSER_SEPARATOR_UNMATCHED
);
17463 uint URI_client_len
= strlen (URI_client_pos
);
17465 if (URI_client_len
> 512)
17467 myfree (temp_input_buf
);
17469 return (PARSER_SALT_LENGTH
);
17474 char *realm_pos
= strchr (user_pos
, '*');
17476 if (realm_pos
== NULL
)
17478 myfree (temp_input_buf
);
17480 return (PARSER_SEPARATOR_UNMATCHED
);
17486 uint user_len
= strlen (user_pos
);
17488 if (user_len
> 116)
17490 myfree (temp_input_buf
);
17492 return (PARSER_SALT_LENGTH
);
17497 char *method_pos
= strchr (realm_pos
, '*');
17499 if (method_pos
== NULL
)
17501 myfree (temp_input_buf
);
17503 return (PARSER_SEPARATOR_UNMATCHED
);
17509 uint realm_len
= strlen (realm_pos
);
17511 if (realm_len
> 116)
17513 myfree (temp_input_buf
);
17515 return (PARSER_SALT_LENGTH
);
17520 char *URI_prefix_pos
= strchr (method_pos
, '*');
17522 if (URI_prefix_pos
== NULL
)
17524 myfree (temp_input_buf
);
17526 return (PARSER_SEPARATOR_UNMATCHED
);
17529 URI_prefix_pos
[0] = 0;
17532 uint method_len
= strlen (method_pos
);
17534 if (method_len
> 246)
17536 myfree (temp_input_buf
);
17538 return (PARSER_SALT_LENGTH
);
17543 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17545 if (URI_resource_pos
== NULL
)
17547 myfree (temp_input_buf
);
17549 return (PARSER_SEPARATOR_UNMATCHED
);
17552 URI_resource_pos
[0] = 0;
17553 URI_resource_pos
++;
17555 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17557 if (URI_prefix_len
> 245)
17559 myfree (temp_input_buf
);
17561 return (PARSER_SALT_LENGTH
);
17566 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17568 if (URI_suffix_pos
== NULL
)
17570 myfree (temp_input_buf
);
17572 return (PARSER_SEPARATOR_UNMATCHED
);
17575 URI_suffix_pos
[0] = 0;
17578 uint URI_resource_len
= strlen (URI_resource_pos
);
17580 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17582 myfree (temp_input_buf
);
17584 return (PARSER_SALT_LENGTH
);
17589 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17591 if (nonce_pos
== NULL
)
17593 myfree (temp_input_buf
);
17595 return (PARSER_SEPARATOR_UNMATCHED
);
17601 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17603 if (URI_suffix_len
> 245)
17605 myfree (temp_input_buf
);
17607 return (PARSER_SALT_LENGTH
);
17612 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17614 if (nonce_client_pos
== NULL
)
17616 myfree (temp_input_buf
);
17618 return (PARSER_SEPARATOR_UNMATCHED
);
17621 nonce_client_pos
[0] = 0;
17622 nonce_client_pos
++;
17624 uint nonce_len
= strlen (nonce_pos
);
17626 if (nonce_len
< 1 || nonce_len
> 50)
17628 myfree (temp_input_buf
);
17630 return (PARSER_SALT_LENGTH
);
17635 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17637 if (nonce_count_pos
== NULL
)
17639 myfree (temp_input_buf
);
17641 return (PARSER_SEPARATOR_UNMATCHED
);
17644 nonce_count_pos
[0] = 0;
17647 uint nonce_client_len
= strlen (nonce_client_pos
);
17649 if (nonce_client_len
> 50)
17651 myfree (temp_input_buf
);
17653 return (PARSER_SALT_LENGTH
);
17658 char *qop_pos
= strchr (nonce_count_pos
, '*');
17660 if (qop_pos
== NULL
)
17662 myfree (temp_input_buf
);
17664 return (PARSER_SEPARATOR_UNMATCHED
);
17670 uint nonce_count_len
= strlen (nonce_count_pos
);
17672 if (nonce_count_len
> 50)
17674 myfree (temp_input_buf
);
17676 return (PARSER_SALT_LENGTH
);
17681 char *directive_pos
= strchr (qop_pos
, '*');
17683 if (directive_pos
== NULL
)
17685 myfree (temp_input_buf
);
17687 return (PARSER_SEPARATOR_UNMATCHED
);
17690 directive_pos
[0] = 0;
17693 uint qop_len
= strlen (qop_pos
);
17697 myfree (temp_input_buf
);
17699 return (PARSER_SALT_LENGTH
);
17704 char *digest_pos
= strchr (directive_pos
, '*');
17706 if (digest_pos
== NULL
)
17708 myfree (temp_input_buf
);
17710 return (PARSER_SEPARATOR_UNMATCHED
);
17716 uint directive_len
= strlen (directive_pos
);
17718 if (directive_len
!= 3)
17720 myfree (temp_input_buf
);
17722 return (PARSER_SALT_LENGTH
);
17725 if (memcmp (directive_pos
, "MD5", 3))
17727 log_info ("ERROR: only the MD5 directive is currently supported\n");
17729 myfree (temp_input_buf
);
17731 return (PARSER_SIP_AUTH_DIRECTIVE
);
17735 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17740 uint md5_max_len
= 4 * 64;
17742 uint md5_remaining_len
= md5_max_len
;
17744 uint tmp_md5_buf
[64] = { 0 };
17746 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17748 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17750 md5_len
+= method_len
+ 1;
17751 tmp_md5_ptr
+= method_len
+ 1;
17753 if (URI_prefix_len
> 0)
17755 md5_remaining_len
= md5_max_len
- md5_len
;
17757 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17759 md5_len
+= URI_prefix_len
+ 1;
17760 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17763 md5_remaining_len
= md5_max_len
- md5_len
;
17765 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17767 md5_len
+= URI_resource_len
;
17768 tmp_md5_ptr
+= URI_resource_len
;
17770 if (URI_suffix_len
> 0)
17772 md5_remaining_len
= md5_max_len
- md5_len
;
17774 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17776 md5_len
+= 1 + URI_suffix_len
;
17779 uint tmp_digest
[4] = { 0 };
17781 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17783 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17784 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17785 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17786 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17792 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17794 uint esalt_len
= 0;
17796 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17798 // there are 2 possibilities for the esalt:
17800 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17802 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17804 if (esalt_len
> max_esalt_len
)
17806 myfree (temp_input_buf
);
17808 return (PARSER_SALT_LENGTH
);
17811 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17823 esalt_len
= 1 + nonce_len
+ 1 + 32;
17825 if (esalt_len
> max_esalt_len
)
17827 myfree (temp_input_buf
);
17829 return (PARSER_SALT_LENGTH
);
17832 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17840 // add 0x80 to esalt
17842 esalt_buf_ptr
[esalt_len
] = 0x80;
17844 sip
->esalt_len
= esalt_len
;
17850 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17852 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17854 uint max_salt_len
= 119;
17856 if (salt_len
> max_salt_len
)
17858 myfree (temp_input_buf
);
17860 return (PARSER_SALT_LENGTH
);
17863 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17865 sip
->salt_len
= salt_len
;
17868 * fake salt (for sorting)
17871 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17875 uint fake_salt_len
= salt_len
;
17877 if (fake_salt_len
> max_salt_len
)
17879 fake_salt_len
= max_salt_len
;
17882 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17884 salt
->salt_len
= fake_salt_len
;
17890 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17891 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17892 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17893 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17895 digest
[0] = byte_swap_32 (digest
[0]);
17896 digest
[1] = byte_swap_32 (digest
[1]);
17897 digest
[2] = byte_swap_32 (digest
[2]);
17898 digest
[3] = byte_swap_32 (digest
[3]);
17900 myfree (temp_input_buf
);
17902 return (PARSER_OK
);
17905 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17907 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17909 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17911 u32
*digest
= (u32
*) hash_buf
->digest
;
17913 salt_t
*salt
= hash_buf
->salt
;
17917 char *digest_pos
= input_buf
;
17919 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17926 char *salt_buf
= input_buf
+ 8 + 1;
17930 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17932 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17934 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17936 salt
->salt_len
= salt_len
;
17938 return (PARSER_OK
);
17941 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17943 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17945 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17947 u32
*digest
= (u32
*) hash_buf
->digest
;
17949 salt_t
*salt
= hash_buf
->salt
;
17951 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17957 char *p_buf_pos
= input_buf
+ 4;
17959 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17961 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17963 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17965 NumCyclesPower_pos
++;
17967 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17969 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17971 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17975 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17977 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17979 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
17983 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17985 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17987 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17991 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17993 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17995 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
17999 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18001 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18003 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18007 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18009 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18011 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18015 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18017 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18019 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18023 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18025 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18027 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18031 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;
18033 const uint iter
= atoi (NumCyclesPower_pos
);
18034 const uint crc
= atoi (crc_buf_pos
);
18035 const uint p_buf
= atoi (p_buf_pos
);
18036 const uint salt_len
= atoi (salt_len_pos
);
18037 const uint iv_len
= atoi (iv_len_pos
);
18038 const uint unpack_size
= atoi (unpack_size_pos
);
18039 const uint data_len
= atoi (data_len_pos
);
18045 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18046 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18048 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18050 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18052 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18058 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18059 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18060 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18061 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18063 seven_zip
->iv_len
= iv_len
;
18065 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18067 seven_zip
->salt_len
= 0;
18069 seven_zip
->crc
= crc
;
18071 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18073 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18075 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18078 seven_zip
->data_len
= data_len
;
18080 seven_zip
->unpack_size
= unpack_size
;
18084 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18085 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18086 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18087 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18089 salt
->salt_len
= 16;
18091 salt
->salt_sign
[0] = iter
;
18093 salt
->salt_iter
= 1 << iter
;
18104 return (PARSER_OK
);
18107 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18109 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18111 u32
*digest
= (u32
*) hash_buf
->digest
;
18113 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18114 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18115 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18116 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18117 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18118 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18119 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18120 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18122 digest
[0] = byte_swap_32 (digest
[0]);
18123 digest
[1] = byte_swap_32 (digest
[1]);
18124 digest
[2] = byte_swap_32 (digest
[2]);
18125 digest
[3] = byte_swap_32 (digest
[3]);
18126 digest
[4] = byte_swap_32 (digest
[4]);
18127 digest
[5] = byte_swap_32 (digest
[5]);
18128 digest
[6] = byte_swap_32 (digest
[6]);
18129 digest
[7] = byte_swap_32 (digest
[7]);
18131 return (PARSER_OK
);
18134 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18136 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18138 u32
*digest
= (u32
*) hash_buf
->digest
;
18140 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18141 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18142 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18143 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18144 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18145 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18146 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18147 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18148 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18149 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18150 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18151 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18152 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18153 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18154 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18155 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18157 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18158 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18159 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18160 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18161 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18162 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18163 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18164 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18165 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18166 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18167 digest
[10] = byte_swap_32 (digest
[10]);
18168 digest
[11] = byte_swap_32 (digest
[11]);
18169 digest
[12] = byte_swap_32 (digest
[12]);
18170 digest
[13] = byte_swap_32 (digest
[13]);
18171 digest
[14] = byte_swap_32 (digest
[14]);
18172 digest
[15] = byte_swap_32 (digest
[15]);
18174 return (PARSER_OK
);
18177 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18179 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18181 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18183 u32
*digest
= (u32
*) hash_buf
->digest
;
18185 salt_t
*salt
= hash_buf
->salt
;
18187 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18195 char *iter_pos
= input_buf
+ 4;
18197 u32 iter
= atoi (iter_pos
);
18199 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18200 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18202 // first is *raw* salt
18204 char *salt_pos
= strchr (iter_pos
, ':');
18206 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18210 char *hash_pos
= strchr (salt_pos
, ':');
18212 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18214 u32 salt_len
= hash_pos
- salt_pos
;
18216 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18220 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18222 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18226 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18228 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18230 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18232 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18233 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18235 salt
->salt_len
= salt_len
;
18236 salt
->salt_iter
= iter
- 1;
18240 u8 tmp_buf
[100] = { 0 };
18242 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18244 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18246 memcpy (digest
, tmp_buf
, 16);
18248 // add some stuff to normal salt to make sorted happy
18250 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18251 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18252 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18253 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18254 salt
->salt_buf
[4] = salt
->salt_iter
;
18256 return (PARSER_OK
);
18259 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18261 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18263 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18265 u32
*digest
= (u32
*) hash_buf
->digest
;
18267 salt_t
*salt
= hash_buf
->salt
;
18269 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18277 char *iter_pos
= input_buf
+ 5;
18279 u32 iter
= atoi (iter_pos
);
18281 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18282 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18284 // first is *raw* salt
18286 char *salt_pos
= strchr (iter_pos
, ':');
18288 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18292 char *hash_pos
= strchr (salt_pos
, ':');
18294 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18296 u32 salt_len
= hash_pos
- salt_pos
;
18298 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18302 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18304 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18308 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18310 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18312 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18314 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18315 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18317 salt
->salt_len
= salt_len
;
18318 salt
->salt_iter
= iter
- 1;
18322 u8 tmp_buf
[100] = { 0 };
18324 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18326 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18328 memcpy (digest
, tmp_buf
, 16);
18330 digest
[0] = byte_swap_32 (digest
[0]);
18331 digest
[1] = byte_swap_32 (digest
[1]);
18332 digest
[2] = byte_swap_32 (digest
[2]);
18333 digest
[3] = byte_swap_32 (digest
[3]);
18335 // add some stuff to normal salt to make sorted happy
18337 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18338 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18339 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18340 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18341 salt
->salt_buf
[4] = salt
->salt_iter
;
18343 return (PARSER_OK
);
18346 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18348 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18350 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18352 u64
*digest
= (u64
*) hash_buf
->digest
;
18354 salt_t
*salt
= hash_buf
->salt
;
18356 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18364 char *iter_pos
= input_buf
+ 7;
18366 u32 iter
= atoi (iter_pos
);
18368 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18369 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18371 // first is *raw* salt
18373 char *salt_pos
= strchr (iter_pos
, ':');
18375 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18379 char *hash_pos
= strchr (salt_pos
, ':');
18381 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18383 u32 salt_len
= hash_pos
- salt_pos
;
18385 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18389 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18391 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18395 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18397 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18399 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18401 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18402 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18404 salt
->salt_len
= salt_len
;
18405 salt
->salt_iter
= iter
- 1;
18409 u8 tmp_buf
[100] = { 0 };
18411 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18413 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18415 memcpy (digest
, tmp_buf
, 64);
18417 digest
[0] = byte_swap_64 (digest
[0]);
18418 digest
[1] = byte_swap_64 (digest
[1]);
18419 digest
[2] = byte_swap_64 (digest
[2]);
18420 digest
[3] = byte_swap_64 (digest
[3]);
18421 digest
[4] = byte_swap_64 (digest
[4]);
18422 digest
[5] = byte_swap_64 (digest
[5]);
18423 digest
[6] = byte_swap_64 (digest
[6]);
18424 digest
[7] = byte_swap_64 (digest
[7]);
18426 // add some stuff to normal salt to make sorted happy
18428 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18429 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18430 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18431 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18432 salt
->salt_buf
[4] = salt
->salt_iter
;
18434 return (PARSER_OK
);
18437 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18439 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18441 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18443 uint
*digest
= (uint
*) hash_buf
->digest
;
18445 salt_t
*salt
= hash_buf
->salt
;
18451 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18453 char *hash_pos
= strchr (salt_pos
, '$');
18455 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18457 u32 salt_len
= hash_pos
- salt_pos
;
18459 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18463 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18465 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18469 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18470 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18488 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18489 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18491 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18492 salt
->salt_len
= 8;
18494 return (PARSER_OK
);
18497 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18499 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18501 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18503 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18505 if (c19
& 3) return (PARSER_HASH_VALUE
);
18507 salt_t
*salt
= hash_buf
->salt
;
18509 u32
*digest
= (u32
*) hash_buf
->digest
;
18513 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18514 | itoa64_to_int (input_buf
[2]) << 6
18515 | itoa64_to_int (input_buf
[3]) << 12
18516 | itoa64_to_int (input_buf
[4]) << 18;
18520 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18521 | itoa64_to_int (input_buf
[6]) << 6
18522 | itoa64_to_int (input_buf
[7]) << 12
18523 | itoa64_to_int (input_buf
[8]) << 18;
18525 salt
->salt_len
= 4;
18527 u8 tmp_buf
[100] = { 0 };
18529 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18531 memcpy (digest
, tmp_buf
, 8);
18535 IP (digest
[0], digest
[1], tt
);
18537 digest
[0] = rotr32 (digest
[0], 31);
18538 digest
[1] = rotr32 (digest
[1], 31);
18542 return (PARSER_OK
);
18545 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18547 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18549 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18551 u32
*digest
= (u32
*) hash_buf
->digest
;
18553 salt_t
*salt
= hash_buf
->salt
;
18559 char *type_pos
= input_buf
+ 6 + 1;
18561 char *salt_pos
= strchr (type_pos
, '*');
18563 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18565 u32 type_len
= salt_pos
- type_pos
;
18567 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18571 char *crypted_pos
= strchr (salt_pos
, '*');
18573 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18575 u32 salt_len
= crypted_pos
- salt_pos
;
18577 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18581 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18583 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18589 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18590 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18592 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18593 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18595 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18596 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18597 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18598 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18600 salt
->salt_len
= 24;
18601 salt
->salt_iter
= ROUNDS_RAR3
;
18603 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18604 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18606 digest
[0] = 0xc43d7b00;
18607 digest
[1] = 0x40070000;
18611 return (PARSER_OK
);
18614 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18616 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18618 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18620 u32
*digest
= (u32
*) hash_buf
->digest
;
18622 salt_t
*salt
= hash_buf
->salt
;
18624 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18630 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18632 char *param1_pos
= strchr (param0_pos
, '$');
18634 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18636 u32 param0_len
= param1_pos
- param0_pos
;
18640 char *param2_pos
= strchr (param1_pos
, '$');
18642 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18644 u32 param1_len
= param2_pos
- param1_pos
;
18648 char *param3_pos
= strchr (param2_pos
, '$');
18650 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18652 u32 param2_len
= param3_pos
- param2_pos
;
18656 char *param4_pos
= strchr (param3_pos
, '$');
18658 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18660 u32 param3_len
= param4_pos
- param3_pos
;
18664 char *param5_pos
= strchr (param4_pos
, '$');
18666 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18668 u32 param4_len
= param5_pos
- param4_pos
;
18672 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18674 char *salt_buf
= param1_pos
;
18675 char *iv
= param3_pos
;
18676 char *pswcheck
= param5_pos
;
18678 const uint salt_len
= atoi (param0_pos
);
18679 const uint iterations
= atoi (param2_pos
);
18680 const uint pswcheck_len
= atoi (param4_pos
);
18686 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18687 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18688 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18690 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18691 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18692 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18698 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18699 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18700 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18701 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18703 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18704 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18705 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18706 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18708 salt
->salt_len
= 16;
18710 salt
->salt_sign
[0] = iterations
;
18712 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18718 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18719 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18723 return (PARSER_OK
);
18726 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18728 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18730 u32
*digest
= (u32
*) hash_buf
->digest
;
18732 salt_t
*salt
= hash_buf
->salt
;
18734 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18735 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18736 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18737 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18738 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18739 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18740 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18741 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18743 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18745 uint salt_len
= input_len
- 64 - 1;
18747 char *salt_buf
= input_buf
+ 64 + 1;
18749 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18751 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18753 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18755 salt
->salt_len
= salt_len
;
18758 * we can precompute the first sha256 transform
18761 uint w
[16] = { 0 };
18763 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18764 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18765 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18766 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18767 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18768 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18769 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18770 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18771 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18772 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18773 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18774 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18775 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18776 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18777 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18778 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18780 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
18782 sha256_64 (w
, pc256
);
18784 salt
->salt_buf_pc
[0] = pc256
[0];
18785 salt
->salt_buf_pc
[1] = pc256
[1];
18786 salt
->salt_buf_pc
[2] = pc256
[2];
18787 salt
->salt_buf_pc
[3] = pc256
[3];
18788 salt
->salt_buf_pc
[4] = pc256
[4];
18789 salt
->salt_buf_pc
[5] = pc256
[5];
18790 salt
->salt_buf_pc
[6] = pc256
[6];
18791 salt
->salt_buf_pc
[7] = pc256
[7];
18793 digest
[0] -= pc256
[0];
18794 digest
[1] -= pc256
[1];
18795 digest
[2] -= pc256
[2];
18796 digest
[3] -= pc256
[3];
18797 digest
[4] -= pc256
[4];
18798 digest
[5] -= pc256
[5];
18799 digest
[6] -= pc256
[6];
18800 digest
[7] -= pc256
[7];
18802 return (PARSER_OK
);
18805 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18807 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18809 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18811 u32
*digest
= (u32
*) hash_buf
->digest
;
18813 salt_t
*salt
= hash_buf
->salt
;
18819 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18821 char *data_buf_pos
= strchr (data_len_pos
, '$');
18823 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18825 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18827 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18828 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18832 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18834 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18836 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18838 u32 data_len
= atoi (data_len_pos
);
18840 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18846 char *salt_pos
= data_buf_pos
;
18848 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18849 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18850 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
18851 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
18853 // this is actually the CT, which is also the hash later (if matched)
18855 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
18856 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
18857 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
18858 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
18860 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18862 salt
->salt_iter
= 10 - 1;
18868 digest
[0] = salt
->salt_buf
[4];
18869 digest
[1] = salt
->salt_buf
[5];
18870 digest
[2] = salt
->salt_buf
[6];
18871 digest
[3] = salt
->salt_buf
[7];
18873 return (PARSER_OK
);
18876 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18878 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18880 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18882 u32
*digest
= (u32
*) hash_buf
->digest
;
18884 salt_t
*salt
= hash_buf
->salt
;
18890 char *salt_pos
= input_buf
+ 11 + 1;
18892 char *iter_pos
= strchr (salt_pos
, ',');
18894 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18896 u32 salt_len
= iter_pos
- salt_pos
;
18898 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18902 char *hash_pos
= strchr (iter_pos
, ',');
18904 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18906 u32 iter_len
= hash_pos
- iter_pos
;
18908 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18912 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18914 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18920 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18921 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18922 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
18923 salt
->salt_buf
[3] = 0x00018000;
18925 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18926 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18927 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18928 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18930 salt
->salt_len
= salt_len
/ 2;
18932 salt
->salt_iter
= atoi (iter_pos
) - 1;
18938 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18939 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18940 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18941 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18942 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18943 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18944 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18945 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18947 return (PARSER_OK
);
18950 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18952 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
18954 u32
*digest
= (u32
*) hash_buf
->digest
;
18956 salt_t
*salt
= hash_buf
->salt
;
18962 char *hash_pos
= input_buf
+ 64;
18963 char *salt1_pos
= input_buf
+ 128;
18964 char *salt2_pos
= input_buf
;
18970 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
18971 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
18972 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
18973 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
18975 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
18976 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
18977 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
18978 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
18980 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
18981 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
18982 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
18983 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
18985 salt
->salt_len
= 48;
18987 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
18993 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18994 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18995 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18996 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18997 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18998 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18999 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19000 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19002 return (PARSER_OK
);
19006 * parallel running threads
19011 BOOL WINAPI
sigHandler_default (DWORD sig
)
19015 case CTRL_CLOSE_EVENT
:
19018 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19019 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19020 * function otherwise it is too late (e.g. after returning from this function)
19025 SetConsoleCtrlHandler (NULL
, TRUE
);
19032 case CTRL_LOGOFF_EVENT
:
19033 case CTRL_SHUTDOWN_EVENT
:
19037 SetConsoleCtrlHandler (NULL
, TRUE
);
19045 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19049 case CTRL_CLOSE_EVENT
:
19053 SetConsoleCtrlHandler (NULL
, TRUE
);
19060 case CTRL_LOGOFF_EVENT
:
19061 case CTRL_SHUTDOWN_EVENT
:
19065 SetConsoleCtrlHandler (NULL
, TRUE
);
19073 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19075 if (callback
== NULL
)
19077 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19081 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19087 void sigHandler_default (int sig
)
19091 signal (sig
, NULL
);
19094 void sigHandler_benchmark (int sig
)
19098 signal (sig
, NULL
);
19101 void hc_signal (void (callback
) (int))
19103 if (callback
== NULL
) callback
= SIG_DFL
;
19105 signal (SIGINT
, callback
);
19106 signal (SIGTERM
, callback
);
19107 signal (SIGABRT
, callback
);
19112 void status_display ();
19114 void *thread_keypress (void *p
)
19116 int benchmark
= *((int *) p
);
19118 uint quiet
= data
.quiet
;
19122 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19124 int ch
= tty_getchar();
19126 if (ch
== -1) break;
19128 if (ch
== 0) continue;
19134 hc_thread_mutex_lock (mux_display
);
19149 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19150 if (quiet
== 0) fflush (stdout
);
19162 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19163 if (quiet
== 0) fflush (stdout
);
19175 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19176 if (quiet
== 0) fflush (stdout
);
19188 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19189 if (quiet
== 0) fflush (stdout
);
19197 if (benchmark
== 1) break;
19199 stop_at_checkpoint ();
19203 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19204 if (quiet
== 0) fflush (stdout
);
19212 if (benchmark
== 1)
19224 hc_thread_mutex_unlock (mux_display
);
19236 bool class_num (const u8 c
)
19238 return ((c
>= '0') && (c
<= '9'));
19241 bool class_lower (const u8 c
)
19243 return ((c
>= 'a') && (c
<= 'z'));
19246 bool class_upper (const u8 c
)
19248 return ((c
>= 'A') && (c
<= 'Z'));
19251 bool class_alpha (const u8 c
)
19253 return (class_lower (c
) || class_upper (c
));
19256 int conv_ctoi (const u8 c
)
19262 else if (class_upper (c
))
19264 return c
- 'A' + 10;
19270 int conv_itoc (const u8 c
)
19278 return c
+ 'A' - 10;
19288 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19289 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19290 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19291 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19292 #define MAX_KERNEL_RULES 255
19293 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19294 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19295 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19297 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19298 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19299 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19300 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19302 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19307 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19309 switch (rule_buf
[rule_pos
])
19315 case RULE_OP_MANGLE_NOOP
:
19316 SET_NAME (rule
, rule_buf
[rule_pos
]);
19319 case RULE_OP_MANGLE_LREST
:
19320 SET_NAME (rule
, rule_buf
[rule_pos
]);
19323 case RULE_OP_MANGLE_UREST
:
19324 SET_NAME (rule
, rule_buf
[rule_pos
]);
19327 case RULE_OP_MANGLE_LREST_UFIRST
:
19328 SET_NAME (rule
, rule_buf
[rule_pos
]);
19331 case RULE_OP_MANGLE_UREST_LFIRST
:
19332 SET_NAME (rule
, rule_buf
[rule_pos
]);
19335 case RULE_OP_MANGLE_TREST
:
19336 SET_NAME (rule
, rule_buf
[rule_pos
]);
19339 case RULE_OP_MANGLE_TOGGLE_AT
:
19340 SET_NAME (rule
, rule_buf
[rule_pos
]);
19341 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19344 case RULE_OP_MANGLE_REVERSE
:
19345 SET_NAME (rule
, rule_buf
[rule_pos
]);
19348 case RULE_OP_MANGLE_DUPEWORD
:
19349 SET_NAME (rule
, rule_buf
[rule_pos
]);
19352 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19353 SET_NAME (rule
, rule_buf
[rule_pos
]);
19354 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19357 case RULE_OP_MANGLE_REFLECT
:
19358 SET_NAME (rule
, rule_buf
[rule_pos
]);
19361 case RULE_OP_MANGLE_ROTATE_LEFT
:
19362 SET_NAME (rule
, rule_buf
[rule_pos
]);
19365 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19366 SET_NAME (rule
, rule_buf
[rule_pos
]);
19369 case RULE_OP_MANGLE_APPEND
:
19370 SET_NAME (rule
, rule_buf
[rule_pos
]);
19371 SET_P0 (rule
, rule_buf
[rule_pos
]);
19374 case RULE_OP_MANGLE_PREPEND
:
19375 SET_NAME (rule
, rule_buf
[rule_pos
]);
19376 SET_P0 (rule
, rule_buf
[rule_pos
]);
19379 case RULE_OP_MANGLE_DELETE_FIRST
:
19380 SET_NAME (rule
, rule_buf
[rule_pos
]);
19383 case RULE_OP_MANGLE_DELETE_LAST
:
19384 SET_NAME (rule
, rule_buf
[rule_pos
]);
19387 case RULE_OP_MANGLE_DELETE_AT
:
19388 SET_NAME (rule
, rule_buf
[rule_pos
]);
19389 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19392 case RULE_OP_MANGLE_EXTRACT
:
19393 SET_NAME (rule
, rule_buf
[rule_pos
]);
19394 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19395 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19398 case RULE_OP_MANGLE_OMIT
:
19399 SET_NAME (rule
, rule_buf
[rule_pos
]);
19400 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19401 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19404 case RULE_OP_MANGLE_INSERT
:
19405 SET_NAME (rule
, rule_buf
[rule_pos
]);
19406 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19407 SET_P1 (rule
, rule_buf
[rule_pos
]);
19410 case RULE_OP_MANGLE_OVERSTRIKE
:
19411 SET_NAME (rule
, rule_buf
[rule_pos
]);
19412 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19413 SET_P1 (rule
, rule_buf
[rule_pos
]);
19416 case RULE_OP_MANGLE_TRUNCATE_AT
:
19417 SET_NAME (rule
, rule_buf
[rule_pos
]);
19418 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19421 case RULE_OP_MANGLE_REPLACE
:
19422 SET_NAME (rule
, rule_buf
[rule_pos
]);
19423 SET_P0 (rule
, rule_buf
[rule_pos
]);
19424 SET_P1 (rule
, rule_buf
[rule_pos
]);
19427 case RULE_OP_MANGLE_PURGECHAR
:
19431 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19435 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19436 SET_NAME (rule
, rule_buf
[rule_pos
]);
19437 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19440 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19441 SET_NAME (rule
, rule_buf
[rule_pos
]);
19442 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19445 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19446 SET_NAME (rule
, rule_buf
[rule_pos
]);
19449 case RULE_OP_MANGLE_SWITCH_FIRST
:
19450 SET_NAME (rule
, rule_buf
[rule_pos
]);
19453 case RULE_OP_MANGLE_SWITCH_LAST
:
19454 SET_NAME (rule
, rule_buf
[rule_pos
]);
19457 case RULE_OP_MANGLE_SWITCH_AT
:
19458 SET_NAME (rule
, rule_buf
[rule_pos
]);
19459 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19460 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19463 case RULE_OP_MANGLE_CHR_SHIFTL
:
19464 SET_NAME (rule
, rule_buf
[rule_pos
]);
19465 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19468 case RULE_OP_MANGLE_CHR_SHIFTR
:
19469 SET_NAME (rule
, rule_buf
[rule_pos
]);
19470 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19473 case RULE_OP_MANGLE_CHR_INCR
:
19474 SET_NAME (rule
, rule_buf
[rule_pos
]);
19475 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19478 case RULE_OP_MANGLE_CHR_DECR
:
19479 SET_NAME (rule
, rule_buf
[rule_pos
]);
19480 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19483 case RULE_OP_MANGLE_REPLACE_NP1
:
19484 SET_NAME (rule
, rule_buf
[rule_pos
]);
19485 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19488 case RULE_OP_MANGLE_REPLACE_NM1
:
19489 SET_NAME (rule
, rule_buf
[rule_pos
]);
19490 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19493 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19494 SET_NAME (rule
, rule_buf
[rule_pos
]);
19495 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19498 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19499 SET_NAME (rule
, rule_buf
[rule_pos
]);
19500 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19503 case RULE_OP_MANGLE_TITLE
:
19504 SET_NAME (rule
, rule_buf
[rule_pos
]);
19513 if (rule_pos
< rule_len
) return (-1);
19518 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19522 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19526 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19530 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19534 case RULE_OP_MANGLE_NOOP
:
19535 rule_buf
[rule_pos
] = rule_cmd
;
19538 case RULE_OP_MANGLE_LREST
:
19539 rule_buf
[rule_pos
] = rule_cmd
;
19542 case RULE_OP_MANGLE_UREST
:
19543 rule_buf
[rule_pos
] = rule_cmd
;
19546 case RULE_OP_MANGLE_LREST_UFIRST
:
19547 rule_buf
[rule_pos
] = rule_cmd
;
19550 case RULE_OP_MANGLE_UREST_LFIRST
:
19551 rule_buf
[rule_pos
] = rule_cmd
;
19554 case RULE_OP_MANGLE_TREST
:
19555 rule_buf
[rule_pos
] = rule_cmd
;
19558 case RULE_OP_MANGLE_TOGGLE_AT
:
19559 rule_buf
[rule_pos
] = rule_cmd
;
19560 GET_P0_CONV (rule
);
19563 case RULE_OP_MANGLE_REVERSE
:
19564 rule_buf
[rule_pos
] = rule_cmd
;
19567 case RULE_OP_MANGLE_DUPEWORD
:
19568 rule_buf
[rule_pos
] = rule_cmd
;
19571 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19572 rule_buf
[rule_pos
] = rule_cmd
;
19573 GET_P0_CONV (rule
);
19576 case RULE_OP_MANGLE_REFLECT
:
19577 rule_buf
[rule_pos
] = rule_cmd
;
19580 case RULE_OP_MANGLE_ROTATE_LEFT
:
19581 rule_buf
[rule_pos
] = rule_cmd
;
19584 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19585 rule_buf
[rule_pos
] = rule_cmd
;
19588 case RULE_OP_MANGLE_APPEND
:
19589 rule_buf
[rule_pos
] = rule_cmd
;
19593 case RULE_OP_MANGLE_PREPEND
:
19594 rule_buf
[rule_pos
] = rule_cmd
;
19598 case RULE_OP_MANGLE_DELETE_FIRST
:
19599 rule_buf
[rule_pos
] = rule_cmd
;
19602 case RULE_OP_MANGLE_DELETE_LAST
:
19603 rule_buf
[rule_pos
] = rule_cmd
;
19606 case RULE_OP_MANGLE_DELETE_AT
:
19607 rule_buf
[rule_pos
] = rule_cmd
;
19608 GET_P0_CONV (rule
);
19611 case RULE_OP_MANGLE_EXTRACT
:
19612 rule_buf
[rule_pos
] = rule_cmd
;
19613 GET_P0_CONV (rule
);
19614 GET_P1_CONV (rule
);
19617 case RULE_OP_MANGLE_OMIT
:
19618 rule_buf
[rule_pos
] = rule_cmd
;
19619 GET_P0_CONV (rule
);
19620 GET_P1_CONV (rule
);
19623 case RULE_OP_MANGLE_INSERT
:
19624 rule_buf
[rule_pos
] = rule_cmd
;
19625 GET_P0_CONV (rule
);
19629 case RULE_OP_MANGLE_OVERSTRIKE
:
19630 rule_buf
[rule_pos
] = rule_cmd
;
19631 GET_P0_CONV (rule
);
19635 case RULE_OP_MANGLE_TRUNCATE_AT
:
19636 rule_buf
[rule_pos
] = rule_cmd
;
19637 GET_P0_CONV (rule
);
19640 case RULE_OP_MANGLE_REPLACE
:
19641 rule_buf
[rule_pos
] = rule_cmd
;
19646 case RULE_OP_MANGLE_PURGECHAR
:
19650 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19654 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19655 rule_buf
[rule_pos
] = rule_cmd
;
19656 GET_P0_CONV (rule
);
19659 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19660 rule_buf
[rule_pos
] = rule_cmd
;
19661 GET_P0_CONV (rule
);
19664 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19665 rule_buf
[rule_pos
] = rule_cmd
;
19668 case RULE_OP_MANGLE_SWITCH_FIRST
:
19669 rule_buf
[rule_pos
] = rule_cmd
;
19672 case RULE_OP_MANGLE_SWITCH_LAST
:
19673 rule_buf
[rule_pos
] = rule_cmd
;
19676 case RULE_OP_MANGLE_SWITCH_AT
:
19677 rule_buf
[rule_pos
] = rule_cmd
;
19678 GET_P0_CONV (rule
);
19679 GET_P1_CONV (rule
);
19682 case RULE_OP_MANGLE_CHR_SHIFTL
:
19683 rule_buf
[rule_pos
] = rule_cmd
;
19684 GET_P0_CONV (rule
);
19687 case RULE_OP_MANGLE_CHR_SHIFTR
:
19688 rule_buf
[rule_pos
] = rule_cmd
;
19689 GET_P0_CONV (rule
);
19692 case RULE_OP_MANGLE_CHR_INCR
:
19693 rule_buf
[rule_pos
] = rule_cmd
;
19694 GET_P0_CONV (rule
);
19697 case RULE_OP_MANGLE_CHR_DECR
:
19698 rule_buf
[rule_pos
] = rule_cmd
;
19699 GET_P0_CONV (rule
);
19702 case RULE_OP_MANGLE_REPLACE_NP1
:
19703 rule_buf
[rule_pos
] = rule_cmd
;
19704 GET_P0_CONV (rule
);
19707 case RULE_OP_MANGLE_REPLACE_NM1
:
19708 rule_buf
[rule_pos
] = rule_cmd
;
19709 GET_P0_CONV (rule
);
19712 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19713 rule_buf
[rule_pos
] = rule_cmd
;
19714 GET_P0_CONV (rule
);
19717 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19718 rule_buf
[rule_pos
] = rule_cmd
;
19719 GET_P0_CONV (rule
);
19722 case RULE_OP_MANGLE_TITLE
:
19723 rule_buf
[rule_pos
] = rule_cmd
;
19727 return rule_pos
- 1;
19745 * CPU rules : this is from hashcat sources, cpu based rules
19748 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19749 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19751 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19752 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19753 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19755 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19756 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19757 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19759 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19763 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19768 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19772 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19777 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19781 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19786 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19791 for (l
= 0; l
< arr_len
; l
++)
19793 r
= arr_len
- 1 - l
;
19797 MANGLE_SWITCH (arr
, l
, r
);
19803 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19805 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19807 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19809 return (arr_len
* 2);
19812 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19814 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19816 int orig_len
= arr_len
;
19820 for (i
= 0; i
< times
; i
++)
19822 memcpy (&arr
[arr_len
], arr
, orig_len
);
19824 arr_len
+= orig_len
;
19830 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19832 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19834 mangle_double (arr
, arr_len
);
19836 mangle_reverse (arr
+ arr_len
, arr_len
);
19838 return (arr_len
* 2);
19841 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19846 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19848 MANGLE_SWITCH (arr
, l
, r
);
19854 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19859 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19861 MANGLE_SWITCH (arr
, l
, r
);
19867 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19869 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19873 return (arr_len
+ 1);
19876 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19878 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19882 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19884 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19889 return (arr_len
+ 1);
19892 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19894 if (upos
>= arr_len
) return (arr_len
);
19898 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19900 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19903 return (arr_len
- 1);
19906 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19908 if (upos
>= arr_len
) return (arr_len
);
19910 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19914 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19916 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19922 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19924 if (upos
>= arr_len
) return (arr_len
);
19926 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19930 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19932 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19935 return (arr_len
- ulen
);
19938 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19940 if (upos
>= arr_len
) return (arr_len
);
19942 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19946 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19948 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19953 return (arr_len
+ 1);
19956 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
)
19958 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19960 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19962 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19964 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19966 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19968 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19970 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19972 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19974 return (arr_len
+ arr2_cpy
);
19977 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19979 if (upos
>= arr_len
) return (arr_len
);
19986 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19988 if (upos
>= arr_len
) return (arr_len
);
19990 memset (arr
+ upos
, 0, arr_len
- upos
);
19995 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19999 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20001 if (arr
[arr_pos
] != oldc
) continue;
20003 arr
[arr_pos
] = newc
;
20009 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20015 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20017 if (arr
[arr_pos
] == c
) continue;
20019 arr
[ret_len
] = arr
[arr_pos
];
20027 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20029 if (ulen
> arr_len
) return (arr_len
);
20031 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20033 char cs
[100] = { 0 };
20035 memcpy (cs
, arr
, ulen
);
20039 for (i
= 0; i
< ulen
; i
++)
20043 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20049 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20051 if (ulen
> arr_len
) return (arr_len
);
20053 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20055 int upos
= arr_len
- ulen
;
20059 for (i
= 0; i
< ulen
; i
++)
20061 char c
= arr
[upos
+ i
];
20063 arr_len
= mangle_append (arr
, arr_len
, c
);
20069 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20071 if ( arr_len
== 0) return (arr_len
);
20072 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20074 char c
= arr
[upos
];
20078 for (i
= 0; i
< ulen
; i
++)
20080 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20086 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20088 if ( arr_len
== 0) return (arr_len
);
20089 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20093 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20095 int new_pos
= arr_pos
* 2;
20097 arr
[new_pos
] = arr
[arr_pos
];
20099 arr
[new_pos
+ 1] = arr
[arr_pos
];
20102 return (arr_len
* 2);
20105 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20107 if (upos
>= arr_len
) return (arr_len
);
20108 if (upos2
>= arr_len
) return (arr_len
);
20110 MANGLE_SWITCH (arr
, upos
, upos2
);
20115 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20117 MANGLE_SWITCH (arr
, upos
, upos2
);
20122 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20124 if (upos
>= arr_len
) return (arr_len
);
20131 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20133 if (upos
>= arr_len
) return (arr_len
);
20140 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20142 if (upos
>= arr_len
) return (arr_len
);
20149 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20151 if (upos
>= arr_len
) return (arr_len
);
20158 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20160 int upper_next
= 1;
20164 for (pos
= 0; pos
< arr_len
; pos
++)
20166 if (arr
[pos
] == ' ')
20177 MANGLE_UPPER_AT (arr
, pos
);
20181 MANGLE_LOWER_AT (arr
, pos
);
20188 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20190 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20196 for (j
= 0; j
< rp_gen_num
; j
++)
20203 switch ((char) get_random_num (0, 9))
20206 r
= get_random_num (0, sizeof (grp_op_nop
));
20207 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20211 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20212 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20213 p1
= get_random_num (0, sizeof (grp_pos
));
20214 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20218 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20219 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20220 p1
= get_random_num (1, 6);
20221 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20225 r
= get_random_num (0, sizeof (grp_op_chr
));
20226 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20227 p1
= get_random_num (0x20, 0x7e);
20228 rule_buf
[rule_pos
++] = (char) p1
;
20232 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20233 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20234 p1
= get_random_num (0x20, 0x7e);
20235 rule_buf
[rule_pos
++] = (char) p1
;
20236 p2
= get_random_num (0x20, 0x7e);
20238 p2
= get_random_num (0x20, 0x7e);
20239 rule_buf
[rule_pos
++] = (char) p2
;
20243 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20244 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20245 p1
= get_random_num (0, sizeof (grp_pos
));
20246 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20247 p2
= get_random_num (0x20, 0x7e);
20248 rule_buf
[rule_pos
++] = (char) p2
;
20252 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20253 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20254 p1
= get_random_num (0, sizeof (grp_pos
));
20255 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20256 p2
= get_random_num (0, sizeof (grp_pos
));
20258 p2
= get_random_num (0, sizeof (grp_pos
));
20259 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20263 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20264 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20265 p1
= get_random_num (0, sizeof (grp_pos
));
20266 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20267 p2
= get_random_num (1, sizeof (grp_pos
));
20269 p2
= get_random_num (1, sizeof (grp_pos
));
20270 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20274 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20275 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20276 p1
= get_random_num (0, sizeof (grp_pos
));
20277 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20278 p2
= get_random_num (1, sizeof (grp_pos
));
20279 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20280 p3
= get_random_num (0, sizeof (grp_pos
));
20281 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20289 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20291 char mem
[BLOCK_SIZE
] = { 0 };
20293 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20295 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20297 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20299 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20301 int out_len
= in_len
;
20302 int mem_len
= in_len
;
20304 memcpy (out
, in
, out_len
);
20308 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20313 switch (rule
[rule_pos
])
20318 case RULE_OP_MANGLE_NOOP
:
20321 case RULE_OP_MANGLE_LREST
:
20322 out_len
= mangle_lrest (out
, out_len
);
20325 case RULE_OP_MANGLE_UREST
:
20326 out_len
= mangle_urest (out
, out_len
);
20329 case RULE_OP_MANGLE_LREST_UFIRST
:
20330 out_len
= mangle_lrest (out
, out_len
);
20331 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20334 case RULE_OP_MANGLE_UREST_LFIRST
:
20335 out_len
= mangle_urest (out
, out_len
);
20336 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20339 case RULE_OP_MANGLE_TREST
:
20340 out_len
= mangle_trest (out
, out_len
);
20343 case RULE_OP_MANGLE_TOGGLE_AT
:
20344 NEXT_RULEPOS (rule_pos
);
20345 NEXT_RPTOI (rule
, rule_pos
, upos
);
20346 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20349 case RULE_OP_MANGLE_REVERSE
:
20350 out_len
= mangle_reverse (out
, out_len
);
20353 case RULE_OP_MANGLE_DUPEWORD
:
20354 out_len
= mangle_double (out
, out_len
);
20357 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20358 NEXT_RULEPOS (rule_pos
);
20359 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20360 out_len
= mangle_double_times (out
, out_len
, ulen
);
20363 case RULE_OP_MANGLE_REFLECT
:
20364 out_len
= mangle_reflect (out
, out_len
);
20367 case RULE_OP_MANGLE_ROTATE_LEFT
:
20368 mangle_rotate_left (out
, out_len
);
20371 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20372 mangle_rotate_right (out
, out_len
);
20375 case RULE_OP_MANGLE_APPEND
:
20376 NEXT_RULEPOS (rule_pos
);
20377 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20380 case RULE_OP_MANGLE_PREPEND
:
20381 NEXT_RULEPOS (rule_pos
);
20382 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20385 case RULE_OP_MANGLE_DELETE_FIRST
:
20386 out_len
= mangle_delete_at (out
, out_len
, 0);
20389 case RULE_OP_MANGLE_DELETE_LAST
:
20390 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20393 case RULE_OP_MANGLE_DELETE_AT
:
20394 NEXT_RULEPOS (rule_pos
);
20395 NEXT_RPTOI (rule
, rule_pos
, upos
);
20396 out_len
= mangle_delete_at (out
, out_len
, upos
);
20399 case RULE_OP_MANGLE_EXTRACT
:
20400 NEXT_RULEPOS (rule_pos
);
20401 NEXT_RPTOI (rule
, rule_pos
, upos
);
20402 NEXT_RULEPOS (rule_pos
);
20403 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20404 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20407 case RULE_OP_MANGLE_OMIT
:
20408 NEXT_RULEPOS (rule_pos
);
20409 NEXT_RPTOI (rule
, rule_pos
, upos
);
20410 NEXT_RULEPOS (rule_pos
);
20411 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20412 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20415 case RULE_OP_MANGLE_INSERT
:
20416 NEXT_RULEPOS (rule_pos
);
20417 NEXT_RPTOI (rule
, rule_pos
, upos
);
20418 NEXT_RULEPOS (rule_pos
);
20419 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20422 case RULE_OP_MANGLE_OVERSTRIKE
:
20423 NEXT_RULEPOS (rule_pos
);
20424 NEXT_RPTOI (rule
, rule_pos
, upos
);
20425 NEXT_RULEPOS (rule_pos
);
20426 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20429 case RULE_OP_MANGLE_TRUNCATE_AT
:
20430 NEXT_RULEPOS (rule_pos
);
20431 NEXT_RPTOI (rule
, rule_pos
, upos
);
20432 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20435 case RULE_OP_MANGLE_REPLACE
:
20436 NEXT_RULEPOS (rule_pos
);
20437 NEXT_RULEPOS (rule_pos
);
20438 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20441 case RULE_OP_MANGLE_PURGECHAR
:
20442 NEXT_RULEPOS (rule_pos
);
20443 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20446 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20450 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20451 NEXT_RULEPOS (rule_pos
);
20452 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20453 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20456 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20457 NEXT_RULEPOS (rule_pos
);
20458 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20459 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20462 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20463 out_len
= mangle_dupechar (out
, out_len
);
20466 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20467 NEXT_RULEPOS (rule_pos
);
20468 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20469 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20472 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20473 NEXT_RULEPOS (rule_pos
);
20474 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20475 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20478 case RULE_OP_MANGLE_SWITCH_FIRST
:
20479 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20482 case RULE_OP_MANGLE_SWITCH_LAST
:
20483 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20486 case RULE_OP_MANGLE_SWITCH_AT
:
20487 NEXT_RULEPOS (rule_pos
);
20488 NEXT_RPTOI (rule
, rule_pos
, upos
);
20489 NEXT_RULEPOS (rule_pos
);
20490 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20491 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20494 case RULE_OP_MANGLE_CHR_SHIFTL
:
20495 NEXT_RULEPOS (rule_pos
);
20496 NEXT_RPTOI (rule
, rule_pos
, upos
);
20497 mangle_chr_shiftl (out
, out_len
, upos
);
20500 case RULE_OP_MANGLE_CHR_SHIFTR
:
20501 NEXT_RULEPOS (rule_pos
);
20502 NEXT_RPTOI (rule
, rule_pos
, upos
);
20503 mangle_chr_shiftr (out
, out_len
, upos
);
20506 case RULE_OP_MANGLE_CHR_INCR
:
20507 NEXT_RULEPOS (rule_pos
);
20508 NEXT_RPTOI (rule
, rule_pos
, upos
);
20509 mangle_chr_incr (out
, out_len
, upos
);
20512 case RULE_OP_MANGLE_CHR_DECR
:
20513 NEXT_RULEPOS (rule_pos
);
20514 NEXT_RPTOI (rule
, rule_pos
, upos
);
20515 mangle_chr_decr (out
, out_len
, upos
);
20518 case RULE_OP_MANGLE_REPLACE_NP1
:
20519 NEXT_RULEPOS (rule_pos
);
20520 NEXT_RPTOI (rule
, rule_pos
, upos
);
20521 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20524 case RULE_OP_MANGLE_REPLACE_NM1
:
20525 NEXT_RULEPOS (rule_pos
);
20526 NEXT_RPTOI (rule
, rule_pos
, upos
);
20527 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20530 case RULE_OP_MANGLE_TITLE
:
20531 out_len
= mangle_title (out
, out_len
);
20534 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20535 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20536 NEXT_RULEPOS (rule_pos
);
20537 NEXT_RPTOI (rule
, rule_pos
, upos
);
20538 NEXT_RULEPOS (rule_pos
);
20539 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20540 NEXT_RULEPOS (rule_pos
);
20541 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20542 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20545 case RULE_OP_MANGLE_APPEND_MEMORY
:
20546 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20547 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20548 memcpy (out
+ out_len
, mem
, mem_len
);
20549 out_len
+= mem_len
;
20552 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20553 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20554 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20555 memcpy (mem
+ mem_len
, out
, out_len
);
20556 out_len
+= mem_len
;
20557 memcpy (out
, mem
, out_len
);
20560 case RULE_OP_MEMORIZE_WORD
:
20561 memcpy (mem
, out
, out_len
);
20565 case RULE_OP_REJECT_LESS
:
20566 NEXT_RULEPOS (rule_pos
);
20567 NEXT_RPTOI (rule
, rule_pos
, upos
);
20568 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20571 case RULE_OP_REJECT_GREATER
:
20572 NEXT_RULEPOS (rule_pos
);
20573 NEXT_RPTOI (rule
, rule_pos
, upos
);
20574 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20577 case RULE_OP_REJECT_CONTAIN
:
20578 NEXT_RULEPOS (rule_pos
);
20579 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20582 case RULE_OP_REJECT_NOT_CONTAIN
:
20583 NEXT_RULEPOS (rule_pos
);
20584 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20587 case RULE_OP_REJECT_EQUAL_FIRST
:
20588 NEXT_RULEPOS (rule_pos
);
20589 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20592 case RULE_OP_REJECT_EQUAL_LAST
:
20593 NEXT_RULEPOS (rule_pos
);
20594 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20597 case RULE_OP_REJECT_EQUAL_AT
:
20598 NEXT_RULEPOS (rule_pos
);
20599 NEXT_RPTOI (rule
, rule_pos
, upos
);
20600 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20601 NEXT_RULEPOS (rule_pos
);
20602 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20605 case RULE_OP_REJECT_CONTAINS
:
20606 NEXT_RULEPOS (rule_pos
);
20607 NEXT_RPTOI (rule
, rule_pos
, upos
);
20608 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20609 NEXT_RULEPOS (rule_pos
);
20610 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20611 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20614 case RULE_OP_REJECT_MEMORY
:
20615 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20619 return (RULE_RC_SYNTAX_ERROR
);
20624 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);