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] = { 0 };
2453 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2455 FlushConsoleInputBuffer (stdinHandle
);
2457 for (uint i
= 0; i
< num
; i
++)
2459 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2461 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2463 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2465 return KeyEvent
.uChar
.AsciiChar
;
2473 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2475 SetConsoleMode (stdinHandle
, saveMode
);
2485 #define MSG_ENOMEM "Insufficient memory available"
2487 void *mycalloc (size_t nmemb
, size_t size
)
2489 void *p
= calloc (nmemb
, size
);
2493 log_error ("ERROR: %s", MSG_ENOMEM
);
2501 void *mymalloc (size_t size
)
2503 void *p
= malloc (size
);
2507 log_error ("ERROR: %s", MSG_ENOMEM
);
2512 memset (p
, 0, size
);
2517 void myfree (void *ptr
)
2519 if (ptr
== NULL
) return;
2524 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2526 void *p
= realloc (ptr
, oldsz
+ add
);
2530 log_error ("ERROR: %s", MSG_ENOMEM
);
2535 memset ((char *) p
+ oldsz
, 0, add
);
2540 char *mystrdup (const char *s
)
2542 const size_t len
= strlen (s
);
2544 char *b
= (char *) mymalloc (len
+ 1);
2551 FILE *logfile_open (char *logfile
)
2553 FILE *fp
= fopen (logfile
, "ab");
2563 void logfile_close (FILE *fp
)
2565 if (fp
== stdout
) return;
2570 void logfile_append (const char *fmt
, ...)
2572 if (data
.logfile_disable
== 1) return;
2574 FILE *fp
= logfile_open (data
.logfile
);
2580 vfprintf (fp
, fmt
, ap
);
2591 int logfile_generate_id ()
2593 const int n
= rand ();
2602 char *logfile_generate_topid ()
2604 const int id
= logfile_generate_id ();
2606 char *topid
= (char *) mymalloc (1 + 16 + 1);
2608 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2613 char *logfile_generate_subid ()
2615 const int id
= logfile_generate_id ();
2617 char *subid
= (char *) mymalloc (1 + 16 + 1);
2619 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2631 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2633 FlushFileBuffers (h
);
2642 #if defined(_WIN) && defined(HAVE_NVAPI)
2643 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2647 if (hc_NvAPI_EnumPhysicalGPUs (nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2651 log_info ("WARN: No NvAPI adapters found");
2658 #endif // _WIN && HAVE_NVAPI
2660 #if defined(LINUX) && defined(HAVE_NVML)
2661 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2665 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2667 if (hc_NVML_nvmlDeviceGetHandleByIndex (data
.hm_dll_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2669 // can be used to determine if the device by index matches the cuda device by index
2670 // char name[100]; memset (name, 0, sizeof (name));
2671 // hc_NVML_nvmlDeviceGetName (data.hm_dll_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2678 log_info ("WARN: No NVML adapters found");
2685 #endif // LINUX && HAVE_NVML
2687 #if defined(HAVE_ADL) || defined(HAVE_NVML)
2688 void hm_close (HM_LIB hm_dll
)
2694 FreeLibrary (hm_dll
);
2699 HM_LIB
hm_init (const cl_uint vendor_id
)
2701 HM_LIB hm_dll
= NULL
;
2704 if (vendor_id
== VENDOR_ID_AMD
)
2707 hm_dll
= dlopen ("libatiadlxx.so", RTLD_LAZY
| RTLD_GLOBAL
);
2710 hm_dll
= LoadLibrary ("atiadlxx.dll");
2714 hm_dll
= LoadLibrary ("atiadlxy.dll");
2721 #if defined(LINUX) && defined(HAVE_NVML)
2722 if (vendor_id
== VENDOR_ID_NV
)
2724 hm_dll
= dlopen ("libnvidia-ml.so", RTLD_LAZY
| RTLD_GLOBAL
);
2730 #endif // HAVE_ADL || HAVE_NVML
2733 int get_adapters_num_amd (HM_LIB hm_dll_amd
, int *iNumberAdapters
)
2735 if (hc_ADL_Adapter_NumberOfAdapters_Get (hm_dll_amd
, iNumberAdapters
) != ADL_OK
) return -1;
2737 if (iNumberAdapters
== 0)
2739 log_info ("WARN: No ADL adapters found.");
2748 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2750 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2751 ADLODParameters lpOdParameters;
2753 lpOdParameters.iSize = sizeof (ADLODParameters);
2754 size_t plevels_size = 0;
2756 if (hc_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2758 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2759 __func__, iAdapterIndex,
2760 lpOdParameters.iNumberOfPerformanceLevels,
2761 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2762 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2764 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2766 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2768 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2770 if (hc_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2772 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2773 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2774 __func__, iAdapterIndex, j,
2775 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2777 myfree (lpOdPerformanceLevels);
2783 LPAdapterInfo
hm_get_adapter_info_amd (HM_LIB hm_dll_amd
, int iNumberAdapters
)
2785 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2787 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2789 if (hc_ADL_Adapter_AdapterInfo_Get (hm_dll_amd
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2791 return lpAdapterInfo
;
2796 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2799 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2803 for (uint i = 0; i < num_adl_adapters; i++)
2805 int opencl_bus_num = hm_device[i].busid;
2806 int opencl_dev_num = hm_device[i].devid;
2808 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2816 if (idx >= DEVICES_MAX) return -1;
2821 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2823 for (uint i = 0; i < opencl_num_devices; i++)
2825 cl_device_topology_amd device_topology;
2827 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2829 hm_device[i].busid = device_topology.pcie.bus;
2830 hm_device[i].devid = device_topology.pcie.device;
2835 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2837 // basically bubble sort
2839 for (int i
= 0; i
< num_adl_adapters
; i
++)
2841 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2843 // get info of adapter [x]
2845 u32 adapter_index_x
= valid_adl_device_list
[j
];
2846 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2848 u32 bus_num_x
= info_x
.iBusNumber
;
2849 u32 dev_num_x
= info_x
.iDeviceNumber
;
2851 // get info of adapter [y]
2853 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2854 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2856 u32 bus_num_y
= info_y
.iBusNumber
;
2857 u32 dev_num_y
= info_y
.iDeviceNumber
;
2861 if (bus_num_y
< bus_num_x
)
2865 else if (bus_num_y
== bus_num_x
)
2867 if (dev_num_y
< dev_num_x
)
2875 u32 temp
= valid_adl_device_list
[j
+ 1];
2877 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2878 valid_adl_device_list
[j
+ 0] = temp
;
2884 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2886 *num_adl_adapters
= 0;
2888 u32
*adl_adapters
= NULL
;
2890 int *bus_numbers
= NULL
;
2891 int *device_numbers
= NULL
;
2893 for (int i
= 0; i
< iNumberAdapters
; i
++)
2895 AdapterInfo info
= lpAdapterInfo
[i
];
2897 if (strlen (info
.strUDID
) < 1) continue;
2900 if (info
.iVendorID
!= 1002) continue;
2902 if (info
.iVendorID
!= 0x1002) continue;
2905 if (info
.iBusNumber
< 0) continue;
2906 if (info
.iDeviceNumber
< 0) continue;
2910 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2912 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2919 if (found
) continue;
2921 // add it to the list
2923 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2925 adl_adapters
[*num_adl_adapters
] = i
;
2927 // rest is just bookkeeping
2929 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2930 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2932 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2933 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2935 (*num_adl_adapters
)++;
2938 myfree (bus_numbers
);
2939 myfree (device_numbers
);
2941 // sort the list by increasing bus id, device id number
2943 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2945 return adl_adapters
;
2948 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
)
2950 // loop through all valid devices
2952 for (int i
= 0; i
< num_adl_adapters
; i
++)
2954 u32 adapter_index
= valid_adl_device_list
[i
];
2958 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2960 // unfortunately this doesn't work since bus id and dev id are not unique
2961 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2962 // if (opencl_device_index == -1) continue;
2964 int opencl_device_index
= i
;
2966 // if (hm_show_performance_level (hm_dll_amd, info.iAdapterIndex) != 0) return -1;
2968 // get fanspeed info
2970 if (hm_device
[opencl_device_index
].od_version
== 5)
2972 ADLFanSpeedInfo FanSpeedInfo
;
2974 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2976 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2978 if (hc_ADL_Overdrive5_FanSpeedInfo_Get (hm_dll_amd
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2980 // check read and write capability in fanspeedinfo
2982 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2983 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2985 hm_device
[opencl_device_index
].fan_supported
= 1;
2989 hm_device
[opencl_device_index
].fan_supported
= 0;
2992 else // od_version == 6
2994 ADLOD6FanSpeedInfo faninfo
;
2996 memset (&faninfo
, 0, sizeof (faninfo
));
2998 if (hc_ADL_Overdrive6_FanSpeed_Get (hm_dll_amd
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
3000 // check read capability in fanspeedinfo
3002 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
3004 hm_device
[opencl_device_index
].fan_supported
= 1;
3008 hm_device
[opencl_device_index
].fan_supported
= 0;
3016 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
)
3018 for (int i
= 0; i
< num_adl_adapters
; i
++)
3020 u32 adapter_index
= valid_adl_device_list
[i
];
3024 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3026 // get overdrive version
3028 int od_supported
= 0;
3032 if (hc_ADL_Overdrive_Caps (hm_dll_amd
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3034 // store the overdrive version in hm_device
3036 // unfortunately this doesn't work since bus id and dev id are not unique
3037 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3038 // if (opencl_device_index == -1) continue;
3040 int opencl_device_index
= i
;
3042 hm_device
[opencl_device_index
].od_version
= od_version
;
3048 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3050 for (int i
= 0; i
< num_adl_adapters
; i
++)
3052 u32 adapter_index
= valid_adl_device_list
[i
];
3056 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3058 // store the iAdapterIndex in hm_device
3060 // unfortunately this doesn't work since bus id and dev id are not unique
3061 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3062 // if (opencl_device_index == -1) continue;
3064 int opencl_device_index
= i
;
3066 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3069 return num_adl_adapters
;
3073 int hm_get_temperature_with_device_id (const uint device_id
)
3075 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3078 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3080 if (data
.hm_dll_amd
)
3082 if (data
.hm_device
[device_id
].od_version
== 5)
3084 ADLTemperature Temperature
;
3086 Temperature
.iSize
= sizeof (ADLTemperature
);
3088 if (hc_ADL_Overdrive5_Temperature_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3090 return Temperature
.iTemperature
/ 1000;
3092 else if (data
.hm_device
[device_id
].od_version
== 6)
3094 int Temperature
= 0;
3096 if (hc_ADL_Overdrive6_Temperature_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3098 return Temperature
/ 1000;
3104 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3105 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3107 #if defined(LINUX) && defined(HAVE_NVML)
3108 int temperature
= 0;
3110 hc_NVML_nvmlDeviceGetTemperature (data
.hm_dll_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3115 #if defined(WIN) && defined(HAVE_NVAPI)
3116 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3118 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3119 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3120 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3121 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3123 if (hc_NvAPI_GPU_GetThermalSettings (data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3125 return pThermalSettings
.sensor
[0].currentTemp
;
3126 #endif // WIN && HAVE_NVAPI
3128 #endif // HAVE_NVML || HAVE_NVAPI
3133 int hm_get_fanspeed_with_device_id (const uint device_id
)
3135 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3136 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3138 if (data
.hm_device
[device_id
].fan_supported
== 1)
3141 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3143 if (data
.hm_dll_amd
)
3145 if (data
.hm_device
[device_id
].od_version
== 5)
3147 ADLFanSpeedValue lpFanSpeedValue
;
3149 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3151 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3152 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3153 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3155 if (hc_ADL_Overdrive5_FanSpeed_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3157 return lpFanSpeedValue
.iFanSpeed
;
3159 else // od_version == 6
3161 ADLOD6FanSpeedInfo faninfo
;
3163 memset (&faninfo
, 0, sizeof (faninfo
));
3165 if (hc_ADL_Overdrive6_FanSpeed_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3167 return faninfo
.iFanSpeedPercent
;
3173 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3174 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3176 #if defined(LINUX) && defined(HAVE_NVML)
3179 hc_NVML_nvmlDeviceGetFanSpeed (data
.hm_dll_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3184 #if defined(WIN) && defined(HAVE_NVAPI)
3187 hc_NvAPI_GPU_GetTachReading (data
.hm_device
[device_id
].adapter_index
.nv
, &speed
);
3192 #endif // HAVE_NVML || HAVE_NVAPI
3198 int hm_get_utilization_with_device_id (const uint device_id
)
3200 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3203 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3205 if (data
.hm_dll_amd
)
3207 ADLPMActivity PMActivity
;
3209 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3211 if (hc_ADL_Overdrive_CurrentActivity_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3213 return PMActivity
.iActivityPercent
;
3218 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3219 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3221 #if defined(LINUX) && defined(HAVE_NVML)
3222 nvmlUtilization_t utilization
;
3224 hc_NVML_nvmlDeviceGetUtilizationRates (data
.hm_dll_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3226 return utilization
.gpu
;
3229 #if defined(WIN) && defined(HAVE_NVAPI)
3230 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3232 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3234 if (hc_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3236 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3239 #endif // HAVE_NVML || HAVE_NVAPI
3245 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3247 if (data
.hm_device
[device_id
].fan_supported
== 1)
3249 if (data
.hm_dll_amd
)
3251 if (data
.hm_device
[device_id
].od_version
== 5)
3253 ADLFanSpeedValue lpFanSpeedValue
;
3255 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3257 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3258 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3259 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3260 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3262 if (hc_ADL_Overdrive5_FanSpeed_Set (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3266 else // od_version == 6
3268 ADLOD6FanSpeedValue fan_speed_value
;
3270 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3272 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3273 fan_speed_value
.iFanSpeed
= fanspeed
;
3275 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;
3286 // helper function for status display
3288 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3290 #define VALUE_NOT_AVAILABLE "N/A"
3294 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3298 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3301 #endif // HAVE_HWMON
3307 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3309 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3311 if (css_cnt
> SP_PW_MAX
)
3313 log_error ("ERROR: mask length is too long");
3318 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3320 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3322 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3323 uint cs_len
= css
[css_pos
].cs_len
;
3325 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3327 uint c
= cs_buf
[cs_pos
] & 0xff;
3334 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3336 cs_t
*cs
= &css
[css_cnt
];
3338 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3340 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3344 for (i
= 0; i
< cs
->cs_len
; i
++)
3346 const uint u
= cs
->cs_buf
[i
];
3351 for (i
= 0; i
< in_len
; i
++)
3353 uint u
= in_buf
[i
] & 0xff;
3355 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3357 if (css_uniq
[u
] == 1) continue;
3361 cs
->cs_buf
[cs
->cs_len
] = u
;
3369 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3373 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3375 uint p0
= in_buf
[in_pos
] & 0xff;
3377 if (interpret
== 1 && p0
== '?')
3381 if (in_pos
== in_len
) break;
3383 uint p1
= in_buf
[in_pos
] & 0xff;
3387 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3389 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3391 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3393 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3395 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3397 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3399 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3400 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3402 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3403 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3405 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3406 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3408 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3409 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3411 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3413 default: log_error ("Syntax error: %s", in_buf
);
3419 if (data
.hex_charset
)
3423 if (in_pos
== in_len
)
3425 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3430 uint p1
= in_buf
[in_pos
] & 0xff;
3432 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3434 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3441 chr
= hex_convert (p1
) << 0;
3442 chr
|= hex_convert (p0
) << 4;
3444 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3450 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3456 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3460 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3462 sum
*= css
[css_pos
].cs_len
;
3468 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3470 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3475 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3477 char p0
= mask_buf
[mask_pos
];
3483 if (mask_pos
== mask_len
) break;
3485 char p1
= mask_buf
[mask_pos
];
3491 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3493 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3495 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3497 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3499 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3501 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3503 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3504 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3506 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3507 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3509 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3510 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3512 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3513 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3515 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3517 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3523 if (data
.hex_charset
)
3527 // if there is no 2nd hex character, show an error:
3529 if (mask_pos
== mask_len
)
3531 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3536 char p1
= mask_buf
[mask_pos
];
3538 // if they are not valid hex character, show an error:
3540 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3542 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3549 chr
|= hex_convert (p1
) << 0;
3550 chr
|= hex_convert (p0
) << 4;
3552 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3558 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3565 log_error ("ERROR: invalid mask length (0)");
3575 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3577 for (int i
= 0; i
< css_cnt
; i
++)
3579 uint len
= css
[i
].cs_len
;
3580 u64 next
= val
/ len
;
3581 uint pos
= val
% len
;
3582 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3587 void mp_cut_at (char *mask
, uint max
)
3591 uint mask_len
= strlen (mask
);
3593 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3595 if (mask
[i
] == '?') i
++;
3601 void mp_setup_sys (cs_t
*mp_sys
)
3605 uint donec
[CHARSIZ
] = { 0 };
3607 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3608 mp_sys
[0].cs_buf
[pos
++] = chr
;
3609 mp_sys
[0].cs_len
= pos
; }
3611 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3612 mp_sys
[1].cs_buf
[pos
++] = chr
;
3613 mp_sys
[1].cs_len
= pos
; }
3615 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3616 mp_sys
[2].cs_buf
[pos
++] = chr
;
3617 mp_sys
[2].cs_len
= pos
; }
3619 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3620 mp_sys
[3].cs_buf
[pos
++] = chr
;
3621 mp_sys
[3].cs_len
= pos
; }
3623 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3624 mp_sys
[4].cs_len
= pos
; }
3626 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3627 mp_sys
[5].cs_len
= pos
; }
3630 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3632 FILE *fp
= fopen (buf
, "rb");
3634 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3636 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3640 char mp_file
[1024] = { 0 };
3642 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3646 len
= in_superchop (mp_file
);
3650 log_info ("WARNING: charset file corrupted");
3652 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3656 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3661 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3663 mp_usr
[index
].cs_len
= 0;
3665 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3668 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3670 char *new_mask_buf
= (char *) mymalloc (256);
3676 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3678 if (css_pos
== len
) break;
3680 char p0
= mask_buf
[mask_pos
];
3682 new_mask_buf
[mask_pos
] = p0
;
3688 if (mask_pos
== mask_len
) break;
3690 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3694 if (data
.hex_charset
)
3698 if (mask_pos
== mask_len
)
3700 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3705 char p1
= mask_buf
[mask_pos
];
3707 // if they are not valid hex character, show an error:
3709 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3711 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3716 new_mask_buf
[mask_pos
] = p1
;
3721 if (css_pos
== len
) return (new_mask_buf
);
3723 myfree (new_mask_buf
);
3732 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3738 for (i
= start
; i
< stop
; i
++)
3740 sum
*= root_css_buf
[i
].cs_len
;
3746 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3750 cs_t
*cs
= &root_css_buf
[start
];
3754 for (i
= start
; i
< stop
; i
++)
3756 const u64 m
= v
% cs
->cs_len
;
3757 const u64 d
= v
/ cs
->cs_len
;
3761 const uint k
= cs
->cs_buf
[m
];
3763 pw_buf
[i
- start
] = (char) k
;
3765 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3769 int sp_comp_val (const void *p1
, const void *p2
)
3771 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3772 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3774 return b2
->val
- b1
->val
;
3777 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
)
3784 * Initialize hcstats
3787 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3789 u64
*root_stats_ptr
= root_stats_buf
;
3791 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3793 for (i
= 0; i
< SP_PW_MAX
; i
++)
3795 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3797 root_stats_ptr
+= CHARSIZ
;
3800 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3802 u64
*markov_stats_ptr
= markov_stats_buf
;
3804 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3806 for (i
= 0; i
< SP_PW_MAX
; i
++)
3808 for (j
= 0; j
< CHARSIZ
; j
++)
3810 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3812 markov_stats_ptr
+= CHARSIZ
;
3822 char hcstat_tmp
[256] = { 0 };
3824 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3826 hcstat
= hcstat_tmp
;
3829 FILE *fd
= fopen (hcstat
, "rb");
3833 log_error ("%s: %s", hcstat
, strerror (errno
));
3838 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3840 log_error ("%s: Could not load data", hcstat
);
3847 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3849 log_error ("%s: Could not load data", hcstat
);
3859 * Markov modifier of hcstat_table on user request
3864 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3865 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3870 /* Add all stats to first position */
3872 for (i
= 1; i
< SP_PW_MAX
; i
++)
3874 u64
*out
= root_stats_buf_by_pos
[0];
3875 u64
*in
= root_stats_buf_by_pos
[i
];
3877 for (j
= 0; j
< CHARSIZ
; j
++)
3883 for (i
= 1; i
< SP_PW_MAX
; i
++)
3885 u64
*out
= markov_stats_buf_by_key
[0][0];
3886 u64
*in
= markov_stats_buf_by_key
[i
][0];
3888 for (j
= 0; j
< CHARSIZ
; j
++)
3890 for (k
= 0; k
< CHARSIZ
; k
++)
3897 /* copy them to all pw_positions */
3899 for (i
= 1; i
< SP_PW_MAX
; i
++)
3901 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3904 for (i
= 1; i
< SP_PW_MAX
; i
++)
3906 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3914 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3916 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3918 for (i
= 0; i
< SP_PW_MAX
; i
++)
3920 root_table_buf_by_pos
[i
] = root_table_ptr
;
3922 root_table_ptr
+= CHARSIZ
;
3925 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3927 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3929 for (i
= 0; i
< SP_PW_MAX
; i
++)
3931 for (j
= 0; j
< CHARSIZ
; j
++)
3933 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3935 markov_table_ptr
+= CHARSIZ
;
3940 * Convert hcstat to tables
3943 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3945 uint key
= i
% CHARSIZ
;
3947 root_table_buf
[i
].key
= key
;
3948 root_table_buf
[i
].val
= root_stats_buf
[i
];
3951 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3953 uint key
= i
% CHARSIZ
;
3955 markov_table_buf
[i
].key
= key
;
3956 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3959 myfree (root_stats_buf
);
3960 myfree (markov_stats_buf
);
3966 for (i
= 0; i
< SP_PW_MAX
; i
++)
3968 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3971 for (i
= 0; i
< SP_PW_MAX
; i
++)
3973 for (j
= 0; j
< CHARSIZ
; j
++)
3975 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3980 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
])
3983 * Convert tables to css
3986 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3988 uint pw_pos
= i
/ CHARSIZ
;
3990 cs_t
*cs
= &root_css_buf
[pw_pos
];
3992 if (cs
->cs_len
== threshold
) continue;
3994 uint key
= root_table_buf
[i
].key
;
3996 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3998 cs
->cs_buf
[cs
->cs_len
] = key
;
4004 * Convert table to css
4007 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4009 uint c
= i
/ CHARSIZ
;
4011 cs_t
*cs
= &markov_css_buf
[c
];
4013 if (cs
->cs_len
== threshold
) continue;
4015 uint pw_pos
= c
/ CHARSIZ
;
4017 uint key
= markov_table_buf
[i
].key
;
4019 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4021 cs
->cs_buf
[cs
->cs_len
] = key
;
4027 for (uint i = 0; i < 8; i++)
4029 for (uint j = 0x20; j < 0x80; j++)
4031 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4033 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4035 for (uint k = 0; k < 10; k++)
4037 printf (" %u\n", ptr->cs_buf[k]);
4044 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4046 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4048 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4058 for (uint j
= 1; j
< CHARSIZ
; j
++)
4068 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4070 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4072 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4074 out
+= CHARSIZ
* CHARSIZ
;
4075 in
+= CHARSIZ
* CHARSIZ
;
4077 for (uint j
= 0; j
< CHARSIZ
; j
++)
4084 for (uint k
= 1; k
< CHARSIZ
; k
++)
4096 * mixed shared functions
4099 void dump_hex (const u8
*s
, const int sz
)
4101 for (int i
= 0; i
< sz
; i
++)
4103 log_info_nn ("%02x ", s
[i
]);
4109 void usage_mini_print (const char *progname
)
4111 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4114 void usage_big_print (const char *progname
)
4116 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4119 char *get_exec_path ()
4121 int exec_path_len
= 1024;
4123 char *exec_path
= (char *) mymalloc (exec_path_len
);
4127 char tmp
[32] = { 0 };
4129 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4131 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4135 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4139 uint size
= exec_path_len
;
4141 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4143 log_error("! executable path buffer too small\n");
4148 const int len
= strlen (exec_path
);
4151 #error Your Operating System is not supported or detected
4159 char *get_install_dir (const char *progname
)
4161 char *install_dir
= mystrdup (progname
);
4162 char *last_slash
= NULL
;
4164 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4168 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4174 install_dir
[0] = '.';
4178 return (install_dir
);
4181 char *get_profile_dir (const char *homedir
)
4183 #define DOT_HASHCAT ".hashcat"
4185 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
);
4187 char *profile_dir
= (char *) mymalloc (len
+ 1);
4189 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4194 char *get_session_dir (const char *profile_dir
)
4196 #define SESSIONS_FOLDER "sessions"
4198 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
);
4200 char *session_dir
= (char *) mymalloc (len
+ 1);
4202 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4207 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4211 FILE *fd
= fopen (filename
, "rb");
4215 log_error ("%s: %s", filename
, strerror (errno
));
4220 #define MAX_KEY_SIZE (1024 * 1024)
4222 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4224 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4230 for (int fpos
= 0; fpos
< nread
; fpos
++)
4232 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4234 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4235 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4236 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4237 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4239 if (kpos
>= 64) kpos
= 0;
4245 void set_cpu_affinity (char *cpu_affinity
)
4248 DWORD_PTR aff_mask
= 0;
4256 char *devices
= strdup (cpu_affinity
);
4258 char *next
= strtok (devices
, ",");
4262 uint cpu_id
= atoi (next
);
4277 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4283 aff_mask
|= 1 << (cpu_id
- 1);
4285 CPU_SET ((cpu_id
- 1), &cpuset
);
4288 } while ((next
= strtok (NULL
, ",")) != NULL
);
4294 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4295 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4297 pthread_t thread
= pthread_self ();
4298 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4302 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4304 char *element
, *end
;
4306 end
= (char *) base
+ nmemb
* size
;
4308 for (element
= (char *) base
; element
< end
; element
+= size
)
4309 if (!compar (element
, key
))
4315 int sort_by_salt (const void *v1
, const void *v2
)
4317 const salt_t
*s1
= (const salt_t
*) v1
;
4318 const salt_t
*s2
= (const salt_t
*) v2
;
4320 const int res1
= s1
->salt_len
- s2
->salt_len
;
4322 if (res1
!= 0) return (res1
);
4324 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4326 if (res2
!= 0) return (res2
);
4334 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4335 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4342 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4343 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4349 int sort_by_salt_buf (const void *v1
, const void *v2
)
4351 const pot_t
*p1
= (const pot_t
*) v1
;
4352 const pot_t
*p2
= (const pot_t
*) v2
;
4354 const hash_t
*h1
= &p1
->hash
;
4355 const hash_t
*h2
= &p2
->hash
;
4357 const salt_t
*s1
= h1
->salt
;
4358 const salt_t
*s2
= h2
->salt
;
4364 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4365 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4371 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4373 const hash_t
*h1
= (const hash_t
*) v1
;
4374 const hash_t
*h2
= (const hash_t
*) v2
;
4376 const salt_t
*s1
= h1
->salt
;
4377 const salt_t
*s2
= h2
->salt
;
4379 // testphase: this should work
4384 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4385 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4388 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4389 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4390 if (s1->salt_len > s2->salt_len) return ( 1);
4391 if (s1->salt_len < s2->salt_len) return (-1);
4393 uint n = s1->salt_len;
4397 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4398 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4405 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4407 const hash_t
*h1
= (const hash_t
*) v1
;
4408 const hash_t
*h2
= (const hash_t
*) v2
;
4410 const salt_t
*s1
= h1
->salt
;
4411 const salt_t
*s2
= h2
->salt
;
4413 // 12 - 2 (since last 2 uints contain the digest)
4418 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4419 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4425 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4427 const hash_t
*h1
= (const hash_t
*) v1
;
4428 const hash_t
*h2
= (const hash_t
*) v2
;
4430 const void *d1
= h1
->digest
;
4431 const void *d2
= h2
->digest
;
4433 return data
.sort_by_digest (d1
, d2
);
4436 int sort_by_hash (const void *v1
, const void *v2
)
4438 const hash_t
*h1
= (const hash_t
*) v1
;
4439 const hash_t
*h2
= (const hash_t
*) v2
;
4443 const salt_t
*s1
= h1
->salt
;
4444 const salt_t
*s2
= h2
->salt
;
4446 int res
= sort_by_salt (s1
, s2
);
4448 if (res
!= 0) return (res
);
4451 const void *d1
= h1
->digest
;
4452 const void *d2
= h2
->digest
;
4454 return data
.sort_by_digest (d1
, d2
);
4457 int sort_by_pot (const void *v1
, const void *v2
)
4459 const pot_t
*p1
= (const pot_t
*) v1
;
4460 const pot_t
*p2
= (const pot_t
*) v2
;
4462 const hash_t
*h1
= &p1
->hash
;
4463 const hash_t
*h2
= &p2
->hash
;
4465 return sort_by_hash (h1
, h2
);
4468 int sort_by_mtime (const void *p1
, const void *p2
)
4470 const char **f1
= (const char **) p1
;
4471 const char **f2
= (const char **) p2
;
4473 struct stat s1
; stat (*f1
, &s1
);
4474 struct stat s2
; stat (*f2
, &s2
);
4476 return s2
.st_mtime
- s1
.st_mtime
;
4479 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4481 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4482 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4484 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4487 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4489 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4490 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4492 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4495 int sort_by_stringptr (const void *p1
, const void *p2
)
4497 const char **s1
= (const char **) p1
;
4498 const char **s2
= (const char **) p2
;
4500 return strcmp (*s1
, *s2
);
4503 int sort_by_dictstat (const void *s1
, const void *s2
)
4505 dictstat_t
*d1
= (dictstat_t
*) s1
;
4506 dictstat_t
*d2
= (dictstat_t
*) s2
;
4509 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4511 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4514 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4517 int sort_by_bitmap (const void *p1
, const void *p2
)
4519 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4520 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4522 return b1
->collisions
- b2
->collisions
;
4525 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4527 const u32
*d1
= (const u32
*) v1
;
4528 const u32
*d2
= (const u32
*) v2
;
4534 if (d1
[n
] > d2
[n
]) return ( 1);
4535 if (d1
[n
] < d2
[n
]) return (-1);
4541 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4543 const u32
*d1
= (const u32
*) v1
;
4544 const u32
*d2
= (const u32
*) v2
;
4550 if (d1
[n
] > d2
[n
]) return ( 1);
4551 if (d1
[n
] < d2
[n
]) return (-1);
4557 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4559 const u32
*d1
= (const u32
*) v1
;
4560 const u32
*d2
= (const u32
*) v2
;
4566 if (d1
[n
] > d2
[n
]) return ( 1);
4567 if (d1
[n
] < d2
[n
]) return (-1);
4573 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4575 const u32
*d1
= (const u32
*) v1
;
4576 const u32
*d2
= (const u32
*) v2
;
4582 if (d1
[n
] > d2
[n
]) return ( 1);
4583 if (d1
[n
] < d2
[n
]) return (-1);
4589 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4591 const u32
*d1
= (const u32
*) v1
;
4592 const u32
*d2
= (const u32
*) v2
;
4598 if (d1
[n
] > d2
[n
]) return ( 1);
4599 if (d1
[n
] < d2
[n
]) return (-1);
4605 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4607 const u32
*d1
= (const u32
*) v1
;
4608 const u32
*d2
= (const u32
*) v2
;
4614 if (d1
[n
] > d2
[n
]) return ( 1);
4615 if (d1
[n
] < d2
[n
]) return (-1);
4621 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4623 const u32
*d1
= (const u32
*) v1
;
4624 const u32
*d2
= (const u32
*) v2
;
4630 if (d1
[n
] > d2
[n
]) return ( 1);
4631 if (d1
[n
] < d2
[n
]) return (-1);
4637 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4639 const u32
*d1
= (const u32
*) v1
;
4640 const u32
*d2
= (const u32
*) v2
;
4646 if (d1
[n
] > d2
[n
]) return ( 1);
4647 if (d1
[n
] < d2
[n
]) return (-1);
4653 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4655 const u64
*d1
= (const u64
*) v1
;
4656 const u64
*d2
= (const u64
*) v2
;
4662 if (d1
[n
] > d2
[n
]) return ( 1);
4663 if (d1
[n
] < d2
[n
]) return (-1);
4669 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4671 const u64
*d1
= (const u64
*) v1
;
4672 const u64
*d2
= (const u64
*) v2
;
4678 if (d1
[n
] > d2
[n
]) return ( 1);
4679 if (d1
[n
] < d2
[n
]) return (-1);
4685 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4687 const u64
*d1
= (const u64
*) v1
;
4688 const u64
*d2
= (const u64
*) v2
;
4694 if (d1
[n
] > d2
[n
]) return ( 1);
4695 if (d1
[n
] < d2
[n
]) return (-1);
4701 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4703 const u32
*d1
= (const u32
*) v1
;
4704 const u32
*d2
= (const u32
*) v2
;
4706 const uint dgst_pos0
= data
.dgst_pos0
;
4707 const uint dgst_pos1
= data
.dgst_pos1
;
4708 const uint dgst_pos2
= data
.dgst_pos2
;
4709 const uint dgst_pos3
= data
.dgst_pos3
;
4711 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4712 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4713 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4714 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4715 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4716 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4717 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4718 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4723 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
)
4725 uint outfile_autohex
= data
.outfile_autohex
;
4727 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4729 FILE *debug_fp
= NULL
;
4731 if (debug_file
!= NULL
)
4733 debug_fp
= fopen (debug_file
, "ab");
4740 if (debug_fp
== NULL
)
4742 log_info ("WARNING: Could not open debug-file for writing");
4746 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4748 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4750 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4753 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4755 if (debug_mode
== 4)
4757 fputc (':', debug_fp
);
4759 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4762 fputc ('\n', debug_fp
);
4764 if (debug_file
!= NULL
) fclose (debug_fp
);
4768 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4770 int needs_hexify
= 0;
4772 if (outfile_autohex
== 1)
4774 for (uint i
= 0; i
< plain_len
; i
++)
4776 if (plain_ptr
[i
] < 0x20)
4783 if (plain_ptr
[i
] > 0x7f)
4792 if (needs_hexify
== 1)
4794 fprintf (fp
, "$HEX[");
4796 for (uint i
= 0; i
< plain_len
; i
++)
4798 fprintf (fp
, "%02x", plain_ptr
[i
]);
4805 fwrite (plain_ptr
, plain_len
, 1, fp
);
4809 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
)
4811 uint outfile_format
= data
.outfile_format
;
4813 char separator
= data
.separator
;
4815 if (outfile_format
& OUTFILE_FMT_HASH
)
4817 fprintf (out_fp
, "%s", out_buf
);
4819 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4821 fputc (separator
, out_fp
);
4824 else if (data
.username
)
4826 if (username
!= NULL
)
4828 for (uint i
= 0; i
< user_len
; i
++)
4830 fprintf (out_fp
, "%c", username
[i
]);
4833 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4835 fputc (separator
, out_fp
);
4840 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4842 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4844 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4846 fputc (separator
, out_fp
);
4850 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4852 for (uint i
= 0; i
< plain_len
; i
++)
4854 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4857 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4859 fputc (separator
, out_fp
);
4863 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4866 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4871 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4873 fprintf (out_fp
, "%llu", crackpos
);
4878 fputc ('\n', out_fp
);
4881 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
)
4885 pot_key
.hash
.salt
= hashes_buf
->salt
;
4886 pot_key
.hash
.digest
= hashes_buf
->digest
;
4888 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4894 input_buf
[input_len
] = 0;
4897 unsigned char *username
= NULL
;
4902 user_t
*user
= hashes_buf
->hash_info
->user
;
4906 username
= (unsigned char *) (user
->user_name
);
4908 user_len
= user
->user_len
;
4912 // do output the line
4913 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4917 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4918 #define LM_MASKED_PLAIN "[notfound]"
4920 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
)
4926 pot_left_key
.hash
.salt
= hash_left
->salt
;
4927 pot_left_key
.hash
.digest
= hash_left
->digest
;
4929 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4933 uint weak_hash_found
= 0;
4935 pot_t pot_right_key
;
4937 pot_right_key
.hash
.salt
= hash_right
->salt
;
4938 pot_right_key
.hash
.digest
= hash_right
->digest
;
4940 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4942 if (pot_right_ptr
== NULL
)
4944 // special case, if "weak hash"
4946 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4948 weak_hash_found
= 1;
4950 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4952 // in theory this is not needed, but we are paranoia:
4954 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4955 pot_right_ptr
->plain_len
= 0;
4959 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4961 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
4966 // at least one half was found:
4970 input_buf
[input_len
] = 0;
4974 unsigned char *username
= NULL
;
4979 user_t
*user
= hash_left
->hash_info
->user
;
4983 username
= (unsigned char *) (user
->user_name
);
4985 user_len
= user
->user_len
;
4989 // mask the part which was not found
4991 uint left_part_masked
= 0;
4992 uint right_part_masked
= 0;
4994 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
4996 if (pot_left_ptr
== NULL
)
4998 left_part_masked
= 1;
5000 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5002 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5004 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5005 pot_left_ptr
->plain_len
= mask_plain_len
;
5008 if (pot_right_ptr
== NULL
)
5010 right_part_masked
= 1;
5012 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5014 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5016 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5017 pot_right_ptr
->plain_len
= mask_plain_len
;
5020 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5024 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5026 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5028 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5030 // do output the line
5032 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5034 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5036 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5037 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5040 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
)
5044 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5046 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5048 if (pot_ptr
== NULL
)
5052 input_buf
[input_len
] = 0;
5054 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5058 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
)
5064 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5066 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5070 pot_t pot_right_key
;
5072 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5074 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5076 uint weak_hash_found
= 0;
5078 if (pot_right_ptr
== NULL
)
5080 // special case, if "weak hash"
5082 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5084 weak_hash_found
= 1;
5086 // we just need that pot_right_ptr is not a NULL pointer
5088 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5092 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5094 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5099 // ... at least one part was not cracked
5103 input_buf
[input_len
] = 0;
5105 // only show the hash part which is still not cracked
5107 uint user_len
= input_len
- 32;
5109 char *hash_output
= (char *) mymalloc (33);
5111 memcpy (hash_output
, input_buf
, input_len
);
5113 if (pot_left_ptr
!= NULL
)
5115 // only show right part (because left part was already found)
5117 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5119 hash_output
[user_len
+ 16] = 0;
5122 if (pot_right_ptr
!= NULL
)
5124 // only show left part (because right part was already found)
5126 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5128 hash_output
[user_len
+ 16] = 0;
5131 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5133 myfree (hash_output
);
5135 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5138 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5140 uint opencl_platforms_filter
= 0;
5142 if (opencl_platforms
)
5144 char *platforms
= strdup (opencl_platforms
);
5146 char *next
= strtok (platforms
, ",");
5150 int platform
= atoi (next
);
5152 if (platform
< 1 || platform
> 32)
5154 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5159 opencl_platforms_filter
|= 1 << (platform
- 1);
5161 } while ((next
= strtok (NULL
, ",")) != NULL
);
5167 opencl_platforms_filter
= -1;
5170 return opencl_platforms_filter
;
5173 u32
setup_devices_filter (char *opencl_devices
)
5175 u32 devices_filter
= 0;
5179 char *devices
= strdup (opencl_devices
);
5181 char *next
= strtok (devices
, ",");
5185 int device_id
= atoi (next
);
5187 if (device_id
< 1 || device_id
> 32)
5189 log_error ("ERROR: invalid device_id %u specified", device_id
);
5194 devices_filter
|= 1 << (device_id
- 1);
5196 } while ((next
= strtok (NULL
, ",")) != NULL
);
5202 devices_filter
= -1;
5205 return devices_filter
;
5208 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5210 cl_device_type device_types_filter
= 0;
5212 if (opencl_device_types
)
5214 char *device_types
= strdup (opencl_device_types
);
5216 char *next
= strtok (device_types
, ",");
5220 int device_type
= atoi (next
);
5222 if (device_type
< 1 || device_type
> 3)
5224 log_error ("ERROR: invalid device_type %u specified", device_type
);
5229 device_types_filter
|= 1 << device_type
;
5231 } while ((next
= strtok (NULL
, ",")) != NULL
);
5233 free (device_types
);
5237 // Do not use CPU by default, this often reduces GPU performance because
5238 // the CPU is too busy to handle GPU synchronization
5240 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5243 return device_types_filter
;
5246 u32
get_random_num (const u32 min
, const u32 max
)
5248 if (min
== max
) return (min
);
5250 return ((rand () % (max
- min
)) + min
);
5253 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5255 u32 quotient
= dividend
/ divisor
;
5257 if (dividend
% divisor
) quotient
++;
5262 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5264 u64 quotient
= dividend
/ divisor
;
5266 if (dividend
% divisor
) quotient
++;
5271 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5273 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5274 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5276 if (tm
->tm_year
- 70)
5278 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5279 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5281 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5283 else if (tm
->tm_yday
)
5285 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5286 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5288 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5290 else if (tm
->tm_hour
)
5292 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5293 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5295 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5297 else if (tm
->tm_min
)
5299 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5300 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5302 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5306 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5308 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5312 void format_speed_display (float val
, char *buf
, size_t len
)
5323 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5334 /* generate output */
5338 snprintf (buf
, len
- 1, "%.0f ", val
);
5342 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5346 void lowercase (u8
*buf
, int len
)
5348 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5351 void uppercase (u8
*buf
, int len
)
5353 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5356 int fgetl (FILE *fp
, char *line_buf
)
5362 const int c
= fgetc (fp
);
5364 if (c
== EOF
) break;
5366 line_buf
[line_len
] = (char) c
;
5370 if (line_len
== BUFSIZ
) line_len
--;
5372 if (c
== '\n') break;
5375 if (line_len
== 0) return 0;
5377 if (line_buf
[line_len
- 1] == '\n')
5381 line_buf
[line_len
] = 0;
5384 if (line_len
== 0) return 0;
5386 if (line_buf
[line_len
- 1] == '\r')
5390 line_buf
[line_len
] = 0;
5396 int in_superchop (char *buf
)
5398 int len
= strlen (buf
);
5402 if (buf
[len
- 1] == '\n')
5409 if (buf
[len
- 1] == '\r')
5424 char **scan_directory (const char *path
)
5426 char *tmp_path
= mystrdup (path
);
5428 size_t tmp_path_len
= strlen (tmp_path
);
5430 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5432 tmp_path
[tmp_path_len
- 1] = 0;
5434 tmp_path_len
= strlen (tmp_path
);
5437 char **files
= NULL
;
5443 if ((d
= opendir (tmp_path
)) != NULL
)
5449 memset (&e
, 0, sizeof (e
));
5450 struct dirent
*de
= NULL
;
5452 if (readdir_r (d
, &e
, &de
) != 0)
5454 log_error ("ERROR: readdir_r() failed");
5459 if (de
== NULL
) break;
5463 while ((de
= readdir (d
)) != NULL
)
5466 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5468 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5470 char *path_file
= (char *) mymalloc (path_size
+ 1);
5472 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5474 path_file
[path_size
] = 0;
5478 if ((d_test
= opendir (path_file
)) != NULL
)
5486 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5490 files
[num_files
- 1] = path_file
;
5496 else if (errno
== ENOTDIR
)
5498 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5502 files
[num_files
- 1] = mystrdup (path
);
5505 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5509 files
[num_files
- 1] = NULL
;
5516 int count_dictionaries (char **dictionary_files
)
5518 if (dictionary_files
== NULL
) return 0;
5522 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5530 char *stroptitype (const uint opti_type
)
5534 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5535 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5536 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5537 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5538 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5539 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5540 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5541 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5542 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5543 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5544 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5545 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5546 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5547 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5553 char *strparser (const uint parser_status
)
5555 switch (parser_status
)
5557 case PARSER_OK
: return ((char *) PA_000
); break;
5558 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5559 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5560 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5561 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5562 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5563 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5564 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5565 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5566 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5567 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5568 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5569 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5570 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5571 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5572 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5573 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5576 return ((char *) PA_255
);
5579 char *strhashtype (const uint hash_mode
)
5583 case 0: return ((char *) HT_00000
); break;
5584 case 10: return ((char *) HT_00010
); break;
5585 case 11: return ((char *) HT_00011
); break;
5586 case 12: return ((char *) HT_00012
); break;
5587 case 20: return ((char *) HT_00020
); break;
5588 case 21: return ((char *) HT_00021
); break;
5589 case 22: return ((char *) HT_00022
); break;
5590 case 23: return ((char *) HT_00023
); break;
5591 case 30: return ((char *) HT_00030
); break;
5592 case 40: return ((char *) HT_00040
); break;
5593 case 50: return ((char *) HT_00050
); break;
5594 case 60: return ((char *) HT_00060
); break;
5595 case 100: return ((char *) HT_00100
); break;
5596 case 101: return ((char *) HT_00101
); break;
5597 case 110: return ((char *) HT_00110
); break;
5598 case 111: return ((char *) HT_00111
); break;
5599 case 112: return ((char *) HT_00112
); break;
5600 case 120: return ((char *) HT_00120
); break;
5601 case 121: return ((char *) HT_00121
); break;
5602 case 122: return ((char *) HT_00122
); break;
5603 case 124: return ((char *) HT_00124
); break;
5604 case 130: return ((char *) HT_00130
); break;
5605 case 131: return ((char *) HT_00131
); break;
5606 case 132: return ((char *) HT_00132
); break;
5607 case 133: return ((char *) HT_00133
); break;
5608 case 140: return ((char *) HT_00140
); break;
5609 case 141: return ((char *) HT_00141
); break;
5610 case 150: return ((char *) HT_00150
); break;
5611 case 160: return ((char *) HT_00160
); break;
5612 case 190: return ((char *) HT_00190
); break;
5613 case 200: return ((char *) HT_00200
); break;
5614 case 300: return ((char *) HT_00300
); break;
5615 case 400: return ((char *) HT_00400
); break;
5616 case 500: return ((char *) HT_00500
); break;
5617 case 501: return ((char *) HT_00501
); break;
5618 case 900: return ((char *) HT_00900
); break;
5619 case 910: return ((char *) HT_00910
); break;
5620 case 1000: return ((char *) HT_01000
); break;
5621 case 1100: return ((char *) HT_01100
); break;
5622 case 1400: return ((char *) HT_01400
); break;
5623 case 1410: return ((char *) HT_01410
); break;
5624 case 1420: return ((char *) HT_01420
); break;
5625 case 1421: return ((char *) HT_01421
); break;
5626 case 1430: return ((char *) HT_01430
); break;
5627 case 1440: return ((char *) HT_01440
); break;
5628 case 1441: return ((char *) HT_01441
); break;
5629 case 1450: return ((char *) HT_01450
); break;
5630 case 1460: return ((char *) HT_01460
); break;
5631 case 1500: return ((char *) HT_01500
); break;
5632 case 1600: return ((char *) HT_01600
); break;
5633 case 1700: return ((char *) HT_01700
); break;
5634 case 1710: return ((char *) HT_01710
); break;
5635 case 1711: return ((char *) HT_01711
); break;
5636 case 1720: return ((char *) HT_01720
); break;
5637 case 1722: return ((char *) HT_01722
); break;
5638 case 1730: return ((char *) HT_01730
); break;
5639 case 1731: return ((char *) HT_01731
); break;
5640 case 1740: return ((char *) HT_01740
); break;
5641 case 1750: return ((char *) HT_01750
); break;
5642 case 1760: return ((char *) HT_01760
); break;
5643 case 1800: return ((char *) HT_01800
); break;
5644 case 2100: return ((char *) HT_02100
); break;
5645 case 2400: return ((char *) HT_02400
); break;
5646 case 2410: return ((char *) HT_02410
); break;
5647 case 2500: return ((char *) HT_02500
); break;
5648 case 2600: return ((char *) HT_02600
); break;
5649 case 2611: return ((char *) HT_02611
); break;
5650 case 2612: return ((char *) HT_02612
); break;
5651 case 2711: return ((char *) HT_02711
); break;
5652 case 2811: return ((char *) HT_02811
); break;
5653 case 3000: return ((char *) HT_03000
); break;
5654 case 3100: return ((char *) HT_03100
); break;
5655 case 3200: return ((char *) HT_03200
); break;
5656 case 3710: return ((char *) HT_03710
); break;
5657 case 3711: return ((char *) HT_03711
); break;
5658 case 3800: return ((char *) HT_03800
); break;
5659 case 4300: return ((char *) HT_04300
); break;
5660 case 4400: return ((char *) HT_04400
); break;
5661 case 4500: return ((char *) HT_04500
); break;
5662 case 4700: return ((char *) HT_04700
); break;
5663 case 4800: return ((char *) HT_04800
); break;
5664 case 4900: return ((char *) HT_04900
); break;
5665 case 5000: return ((char *) HT_05000
); break;
5666 case 5100: return ((char *) HT_05100
); break;
5667 case 5200: return ((char *) HT_05200
); break;
5668 case 5300: return ((char *) HT_05300
); break;
5669 case 5400: return ((char *) HT_05400
); break;
5670 case 5500: return ((char *) HT_05500
); break;
5671 case 5600: return ((char *) HT_05600
); break;
5672 case 5700: return ((char *) HT_05700
); break;
5673 case 5800: return ((char *) HT_05800
); break;
5674 case 6000: return ((char *) HT_06000
); break;
5675 case 6100: return ((char *) HT_06100
); break;
5676 case 6211: return ((char *) HT_06211
); break;
5677 case 6212: return ((char *) HT_06212
); break;
5678 case 6213: return ((char *) HT_06213
); break;
5679 case 6221: return ((char *) HT_06221
); break;
5680 case 6222: return ((char *) HT_06222
); break;
5681 case 6223: return ((char *) HT_06223
); break;
5682 case 6231: return ((char *) HT_06231
); break;
5683 case 6232: return ((char *) HT_06232
); break;
5684 case 6233: return ((char *) HT_06233
); break;
5685 case 6241: return ((char *) HT_06241
); break;
5686 case 6242: return ((char *) HT_06242
); break;
5687 case 6243: return ((char *) HT_06243
); break;
5688 case 6300: return ((char *) HT_06300
); break;
5689 case 6400: return ((char *) HT_06400
); break;
5690 case 6500: return ((char *) HT_06500
); break;
5691 case 6600: return ((char *) HT_06600
); break;
5692 case 6700: return ((char *) HT_06700
); break;
5693 case 6800: return ((char *) HT_06800
); break;
5694 case 6900: return ((char *) HT_06900
); break;
5695 case 7100: return ((char *) HT_07100
); break;
5696 case 7200: return ((char *) HT_07200
); break;
5697 case 7300: return ((char *) HT_07300
); break;
5698 case 7400: return ((char *) HT_07400
); break;
5699 case 7500: return ((char *) HT_07500
); break;
5700 case 7600: return ((char *) HT_07600
); break;
5701 case 7700: return ((char *) HT_07700
); break;
5702 case 7800: return ((char *) HT_07800
); break;
5703 case 7900: return ((char *) HT_07900
); break;
5704 case 8000: return ((char *) HT_08000
); break;
5705 case 8100: return ((char *) HT_08100
); break;
5706 case 8200: return ((char *) HT_08200
); break;
5707 case 8300: return ((char *) HT_08300
); break;
5708 case 8400: return ((char *) HT_08400
); break;
5709 case 8500: return ((char *) HT_08500
); break;
5710 case 8600: return ((char *) HT_08600
); break;
5711 case 8700: return ((char *) HT_08700
); break;
5712 case 8800: return ((char *) HT_08800
); break;
5713 case 8900: return ((char *) HT_08900
); break;
5714 case 9000: return ((char *) HT_09000
); break;
5715 case 9100: return ((char *) HT_09100
); break;
5716 case 9200: return ((char *) HT_09200
); break;
5717 case 9300: return ((char *) HT_09300
); break;
5718 case 9400: return ((char *) HT_09400
); break;
5719 case 9500: return ((char *) HT_09500
); break;
5720 case 9600: return ((char *) HT_09600
); break;
5721 case 9700: return ((char *) HT_09700
); break;
5722 case 9710: return ((char *) HT_09710
); break;
5723 case 9720: return ((char *) HT_09720
); break;
5724 case 9800: return ((char *) HT_09800
); break;
5725 case 9810: return ((char *) HT_09810
); break;
5726 case 9820: return ((char *) HT_09820
); break;
5727 case 9900: return ((char *) HT_09900
); break;
5728 case 10000: return ((char *) HT_10000
); break;
5729 case 10100: return ((char *) HT_10100
); break;
5730 case 10200: return ((char *) HT_10200
); break;
5731 case 10300: return ((char *) HT_10300
); break;
5732 case 10400: return ((char *) HT_10400
); break;
5733 case 10410: return ((char *) HT_10410
); break;
5734 case 10420: return ((char *) HT_10420
); break;
5735 case 10500: return ((char *) HT_10500
); break;
5736 case 10600: return ((char *) HT_10600
); break;
5737 case 10700: return ((char *) HT_10700
); break;
5738 case 10800: return ((char *) HT_10800
); break;
5739 case 10900: return ((char *) HT_10900
); break;
5740 case 11000: return ((char *) HT_11000
); break;
5741 case 11100: return ((char *) HT_11100
); break;
5742 case 11200: return ((char *) HT_11200
); break;
5743 case 11300: return ((char *) HT_11300
); break;
5744 case 11400: return ((char *) HT_11400
); break;
5745 case 11500: return ((char *) HT_11500
); break;
5746 case 11600: return ((char *) HT_11600
); break;
5747 case 11700: return ((char *) HT_11700
); break;
5748 case 11800: return ((char *) HT_11800
); break;
5749 case 11900: return ((char *) HT_11900
); break;
5750 case 12000: return ((char *) HT_12000
); break;
5751 case 12100: return ((char *) HT_12100
); break;
5752 case 12200: return ((char *) HT_12200
); break;
5753 case 12300: return ((char *) HT_12300
); break;
5754 case 12400: return ((char *) HT_12400
); break;
5755 case 12500: return ((char *) HT_12500
); break;
5756 case 12600: return ((char *) HT_12600
); break;
5757 case 12700: return ((char *) HT_12700
); break;
5758 case 12800: return ((char *) HT_12800
); break;
5759 case 12900: return ((char *) HT_12900
); break;
5760 case 13000: return ((char *) HT_13000
); break;
5763 return ((char *) "Unknown");
5766 char *strstatus (const uint devices_status
)
5768 switch (devices_status
)
5770 case STATUS_INIT
: return ((char *) ST_0000
); break;
5771 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5772 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5773 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5774 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5775 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5776 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5777 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5778 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5779 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5782 return ((char *) "Unknown");
5785 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5787 uint hash_type
= data
.hash_type
;
5788 uint hash_mode
= data
.hash_mode
;
5789 uint salt_type
= data
.salt_type
;
5790 uint opts_type
= data
.opts_type
;
5791 uint opti_type
= data
.opti_type
;
5792 uint dgst_size
= data
.dgst_size
;
5794 char *hashfile
= data
.hashfile
;
5798 uint digest_buf
[64] = { 0 };
5800 u64
*digest_buf64
= (u64
*) digest_buf
;
5802 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5804 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5806 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5812 case HASH_TYPE_DESCRYPT
:
5813 FP (digest_buf
[1], digest_buf
[0], tt
);
5816 case HASH_TYPE_DESRACF
:
5817 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5818 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5820 FP (digest_buf
[1], digest_buf
[0], tt
);
5824 FP (digest_buf
[1], digest_buf
[0], tt
);
5827 case HASH_TYPE_NETNTLM
:
5828 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5829 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5830 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5831 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5833 FP (digest_buf
[1], digest_buf
[0], tt
);
5834 FP (digest_buf
[3], digest_buf
[2], tt
);
5837 case HASH_TYPE_BSDICRYPT
:
5838 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5839 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5841 FP (digest_buf
[1], digest_buf
[0], tt
);
5846 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5851 digest_buf
[0] += MD4M_A
;
5852 digest_buf
[1] += MD4M_B
;
5853 digest_buf
[2] += MD4M_C
;
5854 digest_buf
[3] += MD4M_D
;
5858 digest_buf
[0] += MD5M_A
;
5859 digest_buf
[1] += MD5M_B
;
5860 digest_buf
[2] += MD5M_C
;
5861 digest_buf
[3] += MD5M_D
;
5864 case HASH_TYPE_SHA1
:
5865 digest_buf
[0] += SHA1M_A
;
5866 digest_buf
[1] += SHA1M_B
;
5867 digest_buf
[2] += SHA1M_C
;
5868 digest_buf
[3] += SHA1M_D
;
5869 digest_buf
[4] += SHA1M_E
;
5872 case HASH_TYPE_SHA256
:
5873 digest_buf
[0] += SHA256M_A
;
5874 digest_buf
[1] += SHA256M_B
;
5875 digest_buf
[2] += SHA256M_C
;
5876 digest_buf
[3] += SHA256M_D
;
5877 digest_buf
[4] += SHA256M_E
;
5878 digest_buf
[5] += SHA256M_F
;
5879 digest_buf
[6] += SHA256M_G
;
5880 digest_buf
[7] += SHA256M_H
;
5883 case HASH_TYPE_SHA384
:
5884 digest_buf64
[0] += SHA384M_A
;
5885 digest_buf64
[1] += SHA384M_B
;
5886 digest_buf64
[2] += SHA384M_C
;
5887 digest_buf64
[3] += SHA384M_D
;
5888 digest_buf64
[4] += SHA384M_E
;
5889 digest_buf64
[5] += SHA384M_F
;
5890 digest_buf64
[6] += 0;
5891 digest_buf64
[7] += 0;
5894 case HASH_TYPE_SHA512
:
5895 digest_buf64
[0] += SHA512M_A
;
5896 digest_buf64
[1] += SHA512M_B
;
5897 digest_buf64
[2] += SHA512M_C
;
5898 digest_buf64
[3] += SHA512M_D
;
5899 digest_buf64
[4] += SHA512M_E
;
5900 digest_buf64
[5] += SHA512M_F
;
5901 digest_buf64
[6] += SHA512M_G
;
5902 digest_buf64
[7] += SHA512M_H
;
5907 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5909 if (dgst_size
== DGST_SIZE_4_2
)
5911 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5913 else if (dgst_size
== DGST_SIZE_4_4
)
5915 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5917 else if (dgst_size
== DGST_SIZE_4_5
)
5919 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5921 else if (dgst_size
== DGST_SIZE_4_6
)
5923 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5925 else if (dgst_size
== DGST_SIZE_4_8
)
5927 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5929 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5931 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5933 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5935 else if (hash_type
== HASH_TYPE_SHA384
)
5937 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5939 else if (hash_type
== HASH_TYPE_SHA512
)
5941 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5943 else if (hash_type
== HASH_TYPE_GOST
)
5945 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5948 else if (dgst_size
== DGST_SIZE_4_64
)
5950 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5952 else if (dgst_size
== DGST_SIZE_8_25
)
5954 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5958 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5959 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5960 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5966 memset (&salt
, 0, sizeof (salt_t
));
5968 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5970 char *ptr
= (char *) salt
.salt_buf
;
5972 uint len
= salt
.salt_len
;
5974 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5980 case HASH_TYPE_NETNTLM
:
5982 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
5983 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
5985 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5991 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5993 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6001 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6003 uint max
= salt
.salt_len
/ 4;
6007 for (uint i
= 0; i
< max
; i
++)
6009 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6013 if (opts_type
& OPTS_TYPE_ST_HEX
)
6015 char tmp
[64] = { 0 };
6017 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6019 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6024 memcpy (ptr
, tmp
, len
);
6027 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6029 memset (ptr
+ len
, 0, memset_size
);
6031 salt
.salt_len
= len
;
6035 // some modes require special encoding
6038 uint out_buf_plain
[256] = { 0 };
6039 uint out_buf_salt
[256] = { 0 };
6041 char tmp_buf
[1024] = { 0 };
6043 char *ptr_plain
= (char *) out_buf_plain
;
6044 char *ptr_salt
= (char *) out_buf_salt
;
6046 if (hash_mode
== 22)
6048 char username
[30] = { 0 };
6050 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6052 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6054 u16
*ptr
= (u16
*) digest_buf
;
6056 tmp_buf
[ 0] = sig
[0];
6057 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6058 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6059 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6060 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6061 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6062 tmp_buf
[ 6] = sig
[1];
6063 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6064 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6065 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6066 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6067 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6068 tmp_buf
[12] = sig
[2];
6069 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6070 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6071 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6072 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6073 tmp_buf
[17] = sig
[3];
6074 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6075 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6076 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6077 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6078 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6079 tmp_buf
[23] = sig
[4];
6080 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6081 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6082 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6083 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6084 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6085 tmp_buf
[29] = sig
[5];
6087 snprintf (out_buf
, len
-1, "%s:%s",
6091 else if (hash_mode
== 23)
6093 // do not show the \nskyper\n part in output
6095 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6097 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6099 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6106 else if (hash_mode
== 101)
6108 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6110 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6111 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6112 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6113 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6114 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6116 memcpy (tmp_buf
, digest_buf
, 20);
6118 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6120 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6122 else if (hash_mode
== 111)
6124 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6126 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6127 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6128 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6129 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6130 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6132 memcpy (tmp_buf
, digest_buf
, 20);
6133 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6135 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6137 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6139 else if (hash_mode
== 122)
6141 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6142 (char *) salt
.salt_buf
,
6149 else if (hash_mode
== 124)
6151 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6152 (char *) salt
.salt_buf
,
6159 else if (hash_mode
== 131)
6161 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6162 (char *) salt
.salt_buf
,
6170 else if (hash_mode
== 132)
6172 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6173 (char *) salt
.salt_buf
,
6180 else if (hash_mode
== 133)
6182 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6184 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6185 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6186 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6187 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6188 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6190 memcpy (tmp_buf
, digest_buf
, 20);
6192 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6194 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6196 else if (hash_mode
== 141)
6198 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6200 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6202 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6204 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6206 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6207 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6208 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6209 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6210 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6212 memcpy (tmp_buf
, digest_buf
, 20);
6214 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6218 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6220 else if (hash_mode
== 400)
6222 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6224 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6225 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6226 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6227 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6229 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6231 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6233 else if (hash_mode
== 500)
6235 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6237 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6238 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6239 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6240 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6242 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6244 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6246 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6250 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6253 else if (hash_mode
== 501)
6255 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6257 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6258 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6260 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6262 else if (hash_mode
== 1421)
6264 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6266 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6282 else if (hash_mode
== 1441)
6284 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6286 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6288 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6290 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6292 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6293 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6294 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6295 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6296 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6297 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6298 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6299 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6301 memcpy (tmp_buf
, digest_buf
, 32);
6303 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6307 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6309 else if (hash_mode
== 1500)
6311 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6312 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6313 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6314 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6315 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6317 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6319 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6321 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6322 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6324 memcpy (tmp_buf
, digest_buf
, 8);
6326 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6328 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6332 else if (hash_mode
== 1600)
6334 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6336 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6337 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6338 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6339 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6341 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6343 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6345 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6349 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6352 else if (hash_mode
== 1711)
6354 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6356 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6357 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6358 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6359 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6360 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6361 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6362 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6363 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6365 memcpy (tmp_buf
, digest_buf
, 64);
6366 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6368 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6370 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6372 else if (hash_mode
== 1722)
6374 uint
*ptr
= digest_buf
;
6376 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6377 (unsigned char *) salt
.salt_buf
,
6387 else if (hash_mode
== 1731)
6389 uint
*ptr
= digest_buf
;
6391 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6392 (unsigned char *) salt
.salt_buf
,
6402 else if (hash_mode
== 1800)
6406 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6407 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6408 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6409 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6410 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6411 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6412 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6413 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6415 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6417 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6419 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6423 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6426 else if (hash_mode
== 2100)
6430 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6432 salt
.salt_iter
+ 1);
6434 uint signature_len
= strlen (out_buf
);
6436 pos
+= signature_len
;
6437 len
-= signature_len
;
6439 char *salt_ptr
= (char *) salt
.salt_buf
;
6441 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6443 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6444 byte_swap_32 (digest_buf
[0]),
6445 byte_swap_32 (digest_buf
[1]),
6446 byte_swap_32 (digest_buf
[2]),
6447 byte_swap_32 (digest_buf
[3]));
6449 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6451 memcpy (tmp_buf
, digest_buf
, 16);
6453 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6455 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6456 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6457 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6458 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6460 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6461 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6462 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6463 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6465 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6466 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6467 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6468 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6470 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6471 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6472 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6473 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6475 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6476 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6477 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6478 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6482 else if (hash_mode
== 2500)
6484 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6486 wpa_t
*wpa
= &wpas
[salt_pos
];
6488 uint pke
[25] = { 0 };
6490 char *pke_ptr
= (char *) pke
;
6492 for (uint i
= 0; i
< 25; i
++)
6494 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6497 unsigned char mac1
[6] = { 0 };
6498 unsigned char mac2
[6] = { 0 };
6500 memcpy (mac1
, pke_ptr
+ 23, 6);
6501 memcpy (mac2
, pke_ptr
+ 29, 6);
6503 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6504 (char *) salt
.salt_buf
,
6518 else if (hash_mode
== 4400)
6520 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6521 byte_swap_32 (digest_buf
[0]),
6522 byte_swap_32 (digest_buf
[1]),
6523 byte_swap_32 (digest_buf
[2]),
6524 byte_swap_32 (digest_buf
[3]));
6526 else if (hash_mode
== 4700)
6528 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6529 byte_swap_32 (digest_buf
[0]),
6530 byte_swap_32 (digest_buf
[1]),
6531 byte_swap_32 (digest_buf
[2]),
6532 byte_swap_32 (digest_buf
[3]),
6533 byte_swap_32 (digest_buf
[4]));
6535 else if (hash_mode
== 4800)
6537 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6539 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6544 byte_swap_32 (salt
.salt_buf
[0]),
6545 byte_swap_32 (salt
.salt_buf
[1]),
6546 byte_swap_32 (salt
.salt_buf
[2]),
6547 byte_swap_32 (salt
.salt_buf
[3]),
6550 else if (hash_mode
== 4900)
6552 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6553 byte_swap_32 (digest_buf
[0]),
6554 byte_swap_32 (digest_buf
[1]),
6555 byte_swap_32 (digest_buf
[2]),
6556 byte_swap_32 (digest_buf
[3]),
6557 byte_swap_32 (digest_buf
[4]));
6559 else if (hash_mode
== 5100)
6561 snprintf (out_buf
, len
-1, "%08x%08x",
6565 else if (hash_mode
== 5200)
6567 snprintf (out_buf
, len
-1, "%s", hashfile
);
6569 else if (hash_mode
== 5300)
6571 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6573 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6575 int buf_len
= len
-1;
6579 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6581 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6583 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6585 snprintf (out_buf
, buf_len
, ":");
6591 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6599 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6601 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6603 if ((i
== 0) || (i
== 5))
6605 snprintf (out_buf
, buf_len
, ":");
6611 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6619 for (uint i
= 0; i
< 4; i
++)
6623 snprintf (out_buf
, buf_len
, ":");
6629 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6635 else if (hash_mode
== 5400)
6637 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6639 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6641 int buf_len
= len
-1;
6645 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6647 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6649 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6651 snprintf (out_buf
, buf_len
, ":");
6657 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6665 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6667 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6669 if ((i
== 0) || (i
== 5))
6671 snprintf (out_buf
, buf_len
, ":");
6677 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6685 for (uint i
= 0; i
< 5; i
++)
6689 snprintf (out_buf
, buf_len
, ":");
6695 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6701 else if (hash_mode
== 5500)
6703 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6705 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6707 char user_buf
[64] = { 0 };
6708 char domain_buf
[64] = { 0 };
6709 char srvchall_buf
[1024] = { 0 };
6710 char clichall_buf
[1024] = { 0 };
6712 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6714 char *ptr
= (char *) netntlm
->userdomain_buf
;
6716 user_buf
[i
] = ptr
[j
];
6719 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6721 char *ptr
= (char *) netntlm
->userdomain_buf
;
6723 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6726 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6728 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6730 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6733 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6735 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6737 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6740 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6748 byte_swap_32 (salt
.salt_buf_pc
[0]),
6749 byte_swap_32 (salt
.salt_buf_pc
[1]),
6752 else if (hash_mode
== 5600)
6754 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6756 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6758 char user_buf
[64] = { 0 };
6759 char domain_buf
[64] = { 0 };
6760 char srvchall_buf
[1024] = { 0 };
6761 char clichall_buf
[1024] = { 0 };
6763 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6765 char *ptr
= (char *) netntlm
->userdomain_buf
;
6767 user_buf
[i
] = ptr
[j
];
6770 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6772 char *ptr
= (char *) netntlm
->userdomain_buf
;
6774 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6777 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6779 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6781 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6784 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6786 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6788 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6791 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6801 else if (hash_mode
== 5700)
6803 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6805 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6806 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6807 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6808 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6809 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6810 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6811 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6812 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6814 memcpy (tmp_buf
, digest_buf
, 32);
6816 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6820 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6822 else if (hash_mode
== 5800)
6824 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6825 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6826 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6827 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6828 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6830 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6837 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6839 snprintf (out_buf
, len
-1, "%s", hashfile
);
6841 else if (hash_mode
== 6300)
6843 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6845 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6846 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6847 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6848 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6850 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6852 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6854 else if (hash_mode
== 6400)
6856 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6858 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6860 else if (hash_mode
== 6500)
6862 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6864 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6866 else if (hash_mode
== 6600)
6868 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6870 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6872 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6873 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6875 uint buf_len
= len
- 1;
6877 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6880 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6882 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6887 else if (hash_mode
== 6700)
6889 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6891 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6893 else if (hash_mode
== 6800)
6895 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6897 else if (hash_mode
== 7100)
6899 uint
*ptr
= digest_buf
;
6901 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6903 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6905 uint esalt
[8] = { 0 };
6907 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6908 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6909 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6910 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6911 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6912 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6913 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6914 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6916 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",
6917 SIGNATURE_SHA512OSX
,
6919 esalt
[ 0], esalt
[ 1],
6920 esalt
[ 2], esalt
[ 3],
6921 esalt
[ 4], esalt
[ 5],
6922 esalt
[ 6], esalt
[ 7],
6930 ptr
[15], ptr
[14]);
6932 else if (hash_mode
== 7200)
6934 uint
*ptr
= digest_buf
;
6936 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6938 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6942 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6944 len_used
= strlen (out_buf
);
6946 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6948 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6950 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6953 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",
6961 ptr
[15], ptr
[14]);
6963 else if (hash_mode
== 7300)
6965 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6967 rakp_t
*rakp
= &rakps
[salt_pos
];
6969 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6971 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6974 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6981 else if (hash_mode
== 7400)
6983 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6985 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6986 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6987 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6988 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6989 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6990 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6991 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6992 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6994 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6996 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
6998 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7002 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7005 else if (hash_mode
== 7500)
7007 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7009 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7011 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7012 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7014 char data
[128] = { 0 };
7016 char *ptr_data
= data
;
7018 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7020 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7023 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7025 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7030 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7032 (char *) krb5pa
->user
,
7033 (char *) krb5pa
->realm
,
7034 (char *) krb5pa
->salt
,
7037 else if (hash_mode
== 7700)
7039 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7040 (char *) salt
.salt_buf
,
7044 else if (hash_mode
== 7800)
7046 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7047 (char *) salt
.salt_buf
,
7054 else if (hash_mode
== 7900)
7056 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7060 char *tmp
= (char *) salt
.salt_buf_pc
;
7062 ptr_plain
[42] = tmp
[0];
7068 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7070 else if (hash_mode
== 8000)
7072 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7073 (unsigned char *) salt
.salt_buf
,
7083 else if (hash_mode
== 8100)
7085 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7086 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7088 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7089 (unsigned char *) salt
.salt_buf
,
7096 else if (hash_mode
== 8200)
7098 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7100 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7102 char data_buf
[4096] = { 0 };
7104 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7106 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7109 data_buf
[cloudkey
->data_len
* 2] = 0;
7111 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7112 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7113 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7114 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7115 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7116 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7117 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7118 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7120 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7121 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7122 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7123 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7125 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7141 else if (hash_mode
== 8300)
7143 char digest_buf_c
[34] = { 0 };
7145 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7147 digest_buf_c
[32] = 0;
7151 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7153 char domain_buf_c
[33] = { 0 };
7155 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7157 for (uint i
= 0; i
< salt_pc_len
; i
++)
7159 const char next
= domain_buf_c
[i
];
7161 domain_buf_c
[i
] = '.';
7166 domain_buf_c
[salt_pc_len
] = 0;
7170 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7172 else if (hash_mode
== 8500)
7174 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7176 else if (hash_mode
== 2612)
7178 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7180 (char *) salt
.salt_buf
,
7186 else if (hash_mode
== 3711)
7188 char *salt_ptr
= (char *) salt
.salt_buf
;
7190 salt_ptr
[salt
.salt_len
- 1] = 0;
7192 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7193 SIGNATURE_MEDIAWIKI_B
,
7200 else if (hash_mode
== 8800)
7202 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7204 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7206 char tmp
[3073] = { 0 };
7208 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7210 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7215 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7216 SIGNATURE_ANDROIDFDE
,
7217 byte_swap_32 (salt
.salt_buf
[0]),
7218 byte_swap_32 (salt
.salt_buf
[1]),
7219 byte_swap_32 (salt
.salt_buf
[2]),
7220 byte_swap_32 (salt
.salt_buf
[3]),
7221 byte_swap_32 (digest_buf
[0]),
7222 byte_swap_32 (digest_buf
[1]),
7223 byte_swap_32 (digest_buf
[2]),
7224 byte_swap_32 (digest_buf
[3]),
7227 else if (hash_mode
== 8900)
7229 uint N
= salt
.scrypt_N
;
7230 uint r
= salt
.scrypt_r
;
7231 uint p
= salt
.scrypt_p
;
7233 char base64_salt
[32] = { 0 };
7235 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7237 memset (tmp_buf
, 0, 46);
7239 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7240 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7241 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7242 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7243 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7244 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7245 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7246 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7247 digest_buf
[8] = 0; // needed for base64_encode ()
7249 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7251 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7259 else if (hash_mode
== 9000)
7261 snprintf (out_buf
, len
-1, "%s", hashfile
);
7263 else if (hash_mode
== 9200)
7267 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7269 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7271 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7275 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7276 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7277 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7278 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7279 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7280 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7281 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7282 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7283 digest_buf
[8] = 0; // needed for base64_encode ()
7285 char tmp_buf
[64] = { 0 };
7287 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7288 tmp_buf
[43] = 0; // cut it here
7292 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7294 else if (hash_mode
== 9300)
7296 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7297 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7298 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7299 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7300 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7301 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7302 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7303 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7304 digest_buf
[8] = 0; // needed for base64_encode ()
7306 char tmp_buf
[64] = { 0 };
7308 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7309 tmp_buf
[43] = 0; // cut it here
7311 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7313 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7315 else if (hash_mode
== 9400)
7317 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7319 office2007_t
*office2007
= &office2007s
[salt_pos
];
7321 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7322 SIGNATURE_OFFICE2007
,
7325 office2007
->keySize
,
7331 office2007
->encryptedVerifier
[0],
7332 office2007
->encryptedVerifier
[1],
7333 office2007
->encryptedVerifier
[2],
7334 office2007
->encryptedVerifier
[3],
7335 office2007
->encryptedVerifierHash
[0],
7336 office2007
->encryptedVerifierHash
[1],
7337 office2007
->encryptedVerifierHash
[2],
7338 office2007
->encryptedVerifierHash
[3],
7339 office2007
->encryptedVerifierHash
[4]);
7341 else if (hash_mode
== 9500)
7343 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7345 office2010_t
*office2010
= &office2010s
[salt_pos
];
7347 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,
7353 office2010
->encryptedVerifier
[0],
7354 office2010
->encryptedVerifier
[1],
7355 office2010
->encryptedVerifier
[2],
7356 office2010
->encryptedVerifier
[3],
7357 office2010
->encryptedVerifierHash
[0],
7358 office2010
->encryptedVerifierHash
[1],
7359 office2010
->encryptedVerifierHash
[2],
7360 office2010
->encryptedVerifierHash
[3],
7361 office2010
->encryptedVerifierHash
[4],
7362 office2010
->encryptedVerifierHash
[5],
7363 office2010
->encryptedVerifierHash
[6],
7364 office2010
->encryptedVerifierHash
[7]);
7366 else if (hash_mode
== 9600)
7368 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7370 office2013_t
*office2013
= &office2013s
[salt_pos
];
7372 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x%08x%08x", SIGNATURE_OFFICE2013
, 2013, 100000, 256, 16,
7378 office2013
->encryptedVerifier
[0],
7379 office2013
->encryptedVerifier
[1],
7380 office2013
->encryptedVerifier
[2],
7381 office2013
->encryptedVerifier
[3],
7382 office2013
->encryptedVerifierHash
[0],
7383 office2013
->encryptedVerifierHash
[1],
7384 office2013
->encryptedVerifierHash
[2],
7385 office2013
->encryptedVerifierHash
[3],
7386 office2013
->encryptedVerifierHash
[4],
7387 office2013
->encryptedVerifierHash
[5],
7388 office2013
->encryptedVerifierHash
[6],
7389 office2013
->encryptedVerifierHash
[7]);
7391 else if (hash_mode
== 9700)
7393 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7395 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7397 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7398 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7399 byte_swap_32 (salt
.salt_buf
[0]),
7400 byte_swap_32 (salt
.salt_buf
[1]),
7401 byte_swap_32 (salt
.salt_buf
[2]),
7402 byte_swap_32 (salt
.salt_buf
[3]),
7403 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7404 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7405 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7406 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7407 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7408 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7409 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7410 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7412 else if (hash_mode
== 9710)
7414 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7416 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7418 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7419 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7420 byte_swap_32 (salt
.salt_buf
[0]),
7421 byte_swap_32 (salt
.salt_buf
[1]),
7422 byte_swap_32 (salt
.salt_buf
[2]),
7423 byte_swap_32 (salt
.salt_buf
[3]),
7424 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7425 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7426 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7427 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7428 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7429 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7430 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7431 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7433 else if (hash_mode
== 9720)
7435 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7437 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7439 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7441 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7442 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7443 byte_swap_32 (salt
.salt_buf
[0]),
7444 byte_swap_32 (salt
.salt_buf
[1]),
7445 byte_swap_32 (salt
.salt_buf
[2]),
7446 byte_swap_32 (salt
.salt_buf
[3]),
7447 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7448 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7449 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7450 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7451 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7452 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7453 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7454 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7461 else if (hash_mode
== 9800)
7463 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7465 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7467 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7468 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7473 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7474 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7475 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7476 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7477 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7478 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7479 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7480 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7481 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7483 else if (hash_mode
== 9810)
7485 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7487 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7489 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7490 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7495 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7496 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7497 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7498 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7499 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7500 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7501 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7502 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7503 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7505 else if (hash_mode
== 9820)
7507 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7509 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7511 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7513 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7514 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7519 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7520 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7521 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7522 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7523 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7524 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7525 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7526 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7527 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7534 else if (hash_mode
== 10000)
7538 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7540 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7542 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7546 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7547 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7548 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7549 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7550 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7551 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7552 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7553 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7554 digest_buf
[8] = 0; // needed for base64_encode ()
7556 char tmp_buf
[64] = { 0 };
7558 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7562 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7564 else if (hash_mode
== 10100)
7566 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7571 byte_swap_32 (salt
.salt_buf
[0]),
7572 byte_swap_32 (salt
.salt_buf
[1]),
7573 byte_swap_32 (salt
.salt_buf
[2]),
7574 byte_swap_32 (salt
.salt_buf
[3]));
7576 else if (hash_mode
== 10200)
7578 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7580 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7584 char challenge
[100] = { 0 };
7586 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7590 char tmp_buf
[100] = { 0 };
7592 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7593 (char *) cram_md5
->user
,
7599 char response
[100] = { 0 };
7601 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7603 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7605 else if (hash_mode
== 10300)
7607 char tmp_buf
[100] = { 0 };
7609 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7610 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7612 uint tmp_len
= 20 + salt
.salt_len
;
7616 char base64_encoded
[100] = { 0 };
7618 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7620 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7622 else if (hash_mode
== 10400)
7624 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7626 pdf_t
*pdf
= &pdfs
[salt_pos
];
7628 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",
7636 byte_swap_32 (pdf
->id_buf
[0]),
7637 byte_swap_32 (pdf
->id_buf
[1]),
7638 byte_swap_32 (pdf
->id_buf
[2]),
7639 byte_swap_32 (pdf
->id_buf
[3]),
7641 byte_swap_32 (pdf
->u_buf
[0]),
7642 byte_swap_32 (pdf
->u_buf
[1]),
7643 byte_swap_32 (pdf
->u_buf
[2]),
7644 byte_swap_32 (pdf
->u_buf
[3]),
7645 byte_swap_32 (pdf
->u_buf
[4]),
7646 byte_swap_32 (pdf
->u_buf
[5]),
7647 byte_swap_32 (pdf
->u_buf
[6]),
7648 byte_swap_32 (pdf
->u_buf
[7]),
7650 byte_swap_32 (pdf
->o_buf
[0]),
7651 byte_swap_32 (pdf
->o_buf
[1]),
7652 byte_swap_32 (pdf
->o_buf
[2]),
7653 byte_swap_32 (pdf
->o_buf
[3]),
7654 byte_swap_32 (pdf
->o_buf
[4]),
7655 byte_swap_32 (pdf
->o_buf
[5]),
7656 byte_swap_32 (pdf
->o_buf
[6]),
7657 byte_swap_32 (pdf
->o_buf
[7])
7660 else if (hash_mode
== 10410)
7662 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7664 pdf_t
*pdf
= &pdfs
[salt_pos
];
7666 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7674 byte_swap_32 (pdf
->id_buf
[0]),
7675 byte_swap_32 (pdf
->id_buf
[1]),
7676 byte_swap_32 (pdf
->id_buf
[2]),
7677 byte_swap_32 (pdf
->id_buf
[3]),
7679 byte_swap_32 (pdf
->u_buf
[0]),
7680 byte_swap_32 (pdf
->u_buf
[1]),
7681 byte_swap_32 (pdf
->u_buf
[2]),
7682 byte_swap_32 (pdf
->u_buf
[3]),
7683 byte_swap_32 (pdf
->u_buf
[4]),
7684 byte_swap_32 (pdf
->u_buf
[5]),
7685 byte_swap_32 (pdf
->u_buf
[6]),
7686 byte_swap_32 (pdf
->u_buf
[7]),
7688 byte_swap_32 (pdf
->o_buf
[0]),
7689 byte_swap_32 (pdf
->o_buf
[1]),
7690 byte_swap_32 (pdf
->o_buf
[2]),
7691 byte_swap_32 (pdf
->o_buf
[3]),
7692 byte_swap_32 (pdf
->o_buf
[4]),
7693 byte_swap_32 (pdf
->o_buf
[5]),
7694 byte_swap_32 (pdf
->o_buf
[6]),
7695 byte_swap_32 (pdf
->o_buf
[7])
7698 else if (hash_mode
== 10420)
7700 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7702 pdf_t
*pdf
= &pdfs
[salt_pos
];
7704 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7706 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",
7714 byte_swap_32 (pdf
->id_buf
[0]),
7715 byte_swap_32 (pdf
->id_buf
[1]),
7716 byte_swap_32 (pdf
->id_buf
[2]),
7717 byte_swap_32 (pdf
->id_buf
[3]),
7719 byte_swap_32 (pdf
->u_buf
[0]),
7720 byte_swap_32 (pdf
->u_buf
[1]),
7721 byte_swap_32 (pdf
->u_buf
[2]),
7722 byte_swap_32 (pdf
->u_buf
[3]),
7723 byte_swap_32 (pdf
->u_buf
[4]),
7724 byte_swap_32 (pdf
->u_buf
[5]),
7725 byte_swap_32 (pdf
->u_buf
[6]),
7726 byte_swap_32 (pdf
->u_buf
[7]),
7728 byte_swap_32 (pdf
->o_buf
[0]),
7729 byte_swap_32 (pdf
->o_buf
[1]),
7730 byte_swap_32 (pdf
->o_buf
[2]),
7731 byte_swap_32 (pdf
->o_buf
[3]),
7732 byte_swap_32 (pdf
->o_buf
[4]),
7733 byte_swap_32 (pdf
->o_buf
[5]),
7734 byte_swap_32 (pdf
->o_buf
[6]),
7735 byte_swap_32 (pdf
->o_buf
[7]),
7743 else if (hash_mode
== 10500)
7745 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7747 pdf_t
*pdf
= &pdfs
[salt_pos
];
7749 if (pdf
->id_len
== 32)
7751 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",
7759 byte_swap_32 (pdf
->id_buf
[0]),
7760 byte_swap_32 (pdf
->id_buf
[1]),
7761 byte_swap_32 (pdf
->id_buf
[2]),
7762 byte_swap_32 (pdf
->id_buf
[3]),
7763 byte_swap_32 (pdf
->id_buf
[4]),
7764 byte_swap_32 (pdf
->id_buf
[5]),
7765 byte_swap_32 (pdf
->id_buf
[6]),
7766 byte_swap_32 (pdf
->id_buf
[7]),
7768 byte_swap_32 (pdf
->u_buf
[0]),
7769 byte_swap_32 (pdf
->u_buf
[1]),
7770 byte_swap_32 (pdf
->u_buf
[2]),
7771 byte_swap_32 (pdf
->u_buf
[3]),
7772 byte_swap_32 (pdf
->u_buf
[4]),
7773 byte_swap_32 (pdf
->u_buf
[5]),
7774 byte_swap_32 (pdf
->u_buf
[6]),
7775 byte_swap_32 (pdf
->u_buf
[7]),
7777 byte_swap_32 (pdf
->o_buf
[0]),
7778 byte_swap_32 (pdf
->o_buf
[1]),
7779 byte_swap_32 (pdf
->o_buf
[2]),
7780 byte_swap_32 (pdf
->o_buf
[3]),
7781 byte_swap_32 (pdf
->o_buf
[4]),
7782 byte_swap_32 (pdf
->o_buf
[5]),
7783 byte_swap_32 (pdf
->o_buf
[6]),
7784 byte_swap_32 (pdf
->o_buf
[7])
7789 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",
7797 byte_swap_32 (pdf
->id_buf
[0]),
7798 byte_swap_32 (pdf
->id_buf
[1]),
7799 byte_swap_32 (pdf
->id_buf
[2]),
7800 byte_swap_32 (pdf
->id_buf
[3]),
7802 byte_swap_32 (pdf
->u_buf
[0]),
7803 byte_swap_32 (pdf
->u_buf
[1]),
7804 byte_swap_32 (pdf
->u_buf
[2]),
7805 byte_swap_32 (pdf
->u_buf
[3]),
7806 byte_swap_32 (pdf
->u_buf
[4]),
7807 byte_swap_32 (pdf
->u_buf
[5]),
7808 byte_swap_32 (pdf
->u_buf
[6]),
7809 byte_swap_32 (pdf
->u_buf
[7]),
7811 byte_swap_32 (pdf
->o_buf
[0]),
7812 byte_swap_32 (pdf
->o_buf
[1]),
7813 byte_swap_32 (pdf
->o_buf
[2]),
7814 byte_swap_32 (pdf
->o_buf
[3]),
7815 byte_swap_32 (pdf
->o_buf
[4]),
7816 byte_swap_32 (pdf
->o_buf
[5]),
7817 byte_swap_32 (pdf
->o_buf
[6]),
7818 byte_swap_32 (pdf
->o_buf
[7])
7822 else if (hash_mode
== 10600)
7824 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7826 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7827 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7829 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7831 else if (hash_mode
== 10700)
7833 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7835 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7836 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7838 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7840 else if (hash_mode
== 10900)
7842 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7844 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7845 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7847 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7849 else if (hash_mode
== 11100)
7851 u32 salt_challenge
= salt
.salt_buf
[0];
7853 salt_challenge
= byte_swap_32 (salt_challenge
);
7855 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7857 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7858 SIGNATURE_POSTGRESQL_AUTH
,
7866 else if (hash_mode
== 11200)
7868 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7869 SIGNATURE_MYSQL_AUTH
,
7870 (unsigned char *) salt
.salt_buf
,
7877 else if (hash_mode
== 11300)
7879 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7881 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7883 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7884 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7885 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7887 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7888 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7889 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7891 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7893 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7895 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7898 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7900 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7902 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7905 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7907 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7909 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7912 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7913 SIGNATURE_BITCOIN_WALLET
,
7917 (unsigned char *) salt
.salt_buf
,
7925 free (cry_master_buf
);
7927 free (public_key_buf
);
7929 else if (hash_mode
== 11400)
7931 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7933 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7934 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7936 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7938 else if (hash_mode
== 11600)
7940 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7942 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7944 const uint data_len
= seven_zip
->data_len
;
7946 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7948 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7950 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
7952 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7955 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7956 SIGNATURE_SEVEN_ZIP
,
7960 (char *) seven_zip
->salt_buf
,
7962 seven_zip
->iv_buf
[0],
7963 seven_zip
->iv_buf
[1],
7964 seven_zip
->iv_buf
[2],
7965 seven_zip
->iv_buf
[3],
7967 seven_zip
->data_len
,
7968 seven_zip
->unpack_size
,
7973 else if (hash_mode
== 11700)
7975 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7985 else if (hash_mode
== 11800)
7987 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8005 else if (hash_mode
== 11900)
8007 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8009 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8010 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8012 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8014 else if (hash_mode
== 12000)
8016 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8018 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8019 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8021 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8023 else if (hash_mode
== 12100)
8025 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8027 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8028 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8030 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8032 else if (hash_mode
== 12200)
8034 uint
*ptr_digest
= digest_buf
;
8035 uint
*ptr_salt
= salt
.salt_buf
;
8037 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8044 else if (hash_mode
== 12300)
8046 uint
*ptr_digest
= digest_buf
;
8047 uint
*ptr_salt
= salt
.salt_buf
;
8049 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",
8050 ptr_digest
[ 0], ptr_digest
[ 1],
8051 ptr_digest
[ 2], ptr_digest
[ 3],
8052 ptr_digest
[ 4], ptr_digest
[ 5],
8053 ptr_digest
[ 6], ptr_digest
[ 7],
8054 ptr_digest
[ 8], ptr_digest
[ 9],
8055 ptr_digest
[10], ptr_digest
[11],
8056 ptr_digest
[12], ptr_digest
[13],
8057 ptr_digest
[14], ptr_digest
[15],
8063 else if (hash_mode
== 12400)
8065 // encode iteration count
8067 char salt_iter
[5] = { 0 };
8069 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8070 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8071 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8072 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8077 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8078 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8079 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8080 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8085 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8087 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8088 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8090 memcpy (tmp_buf
, digest_buf
, 8);
8092 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8096 // fill the resulting buffer
8098 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8100 else if (hash_mode
== 12500)
8102 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8104 byte_swap_32 (salt
.salt_buf
[0]),
8105 byte_swap_32 (salt
.salt_buf
[1]),
8111 else if (hash_mode
== 12600)
8113 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8114 digest_buf
[0] + salt
.salt_buf_pc
[0],
8115 digest_buf
[1] + salt
.salt_buf_pc
[1],
8116 digest_buf
[2] + salt
.salt_buf_pc
[2],
8117 digest_buf
[3] + salt
.salt_buf_pc
[3],
8118 digest_buf
[4] + salt
.salt_buf_pc
[4],
8119 digest_buf
[5] + salt
.salt_buf_pc
[5],
8120 digest_buf
[6] + salt
.salt_buf_pc
[6],
8121 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8123 else if (hash_mode
== 12700)
8125 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8127 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8128 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8130 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8132 else if (hash_mode
== 12800)
8134 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8136 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",
8149 byte_swap_32 (digest_buf
[0]),
8150 byte_swap_32 (digest_buf
[1]),
8151 byte_swap_32 (digest_buf
[2]),
8152 byte_swap_32 (digest_buf
[3]),
8153 byte_swap_32 (digest_buf
[4]),
8154 byte_swap_32 (digest_buf
[5]),
8155 byte_swap_32 (digest_buf
[6]),
8156 byte_swap_32 (digest_buf
[7])
8159 else if (hash_mode
== 12900)
8161 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",
8170 byte_swap_32 (digest_buf
[0]),
8171 byte_swap_32 (digest_buf
[1]),
8172 byte_swap_32 (digest_buf
[2]),
8173 byte_swap_32 (digest_buf
[3]),
8174 byte_swap_32 (digest_buf
[4]),
8175 byte_swap_32 (digest_buf
[5]),
8176 byte_swap_32 (digest_buf
[6]),
8177 byte_swap_32 (digest_buf
[7]),
8184 else if (hash_mode
== 13000)
8186 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8188 rar5_t
*rar5
= &rar5s
[salt_pos
];
8190 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8200 byte_swap_32 (digest_buf
[0]),
8201 byte_swap_32 (digest_buf
[1])
8206 if (hash_type
== HASH_TYPE_MD4
)
8208 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8214 else if (hash_type
== HASH_TYPE_MD5
)
8216 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8222 else if (hash_type
== HASH_TYPE_SHA1
)
8224 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8231 else if (hash_type
== HASH_TYPE_SHA256
)
8233 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8243 else if (hash_type
== HASH_TYPE_SHA384
)
8245 uint
*ptr
= digest_buf
;
8247 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8255 else if (hash_type
== HASH_TYPE_SHA512
)
8257 uint
*ptr
= digest_buf
;
8259 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8269 else if (hash_type
== HASH_TYPE_LM
)
8271 snprintf (out_buf
, len
-1, "%08x%08x",
8275 else if (hash_type
== HASH_TYPE_ORACLEH
)
8277 snprintf (out_buf
, len
-1, "%08X%08X",
8281 else if (hash_type
== HASH_TYPE_BCRYPT
)
8283 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8284 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8286 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8288 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8290 else if (hash_type
== HASH_TYPE_KECCAK
)
8292 uint
*ptr
= digest_buf
;
8294 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",
8322 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8324 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8326 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8333 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8335 digest_buf
[ 0] = digest_buf
[ 0];
8336 digest_buf
[ 1] = digest_buf
[ 1];
8337 digest_buf
[ 2] = digest_buf
[ 2];
8338 digest_buf
[ 3] = digest_buf
[ 3];
8339 digest_buf
[ 4] = digest_buf
[ 4];
8340 digest_buf
[ 5] = digest_buf
[ 5];
8341 digest_buf
[ 6] = digest_buf
[ 6];
8342 digest_buf
[ 7] = digest_buf
[ 7];
8343 digest_buf
[ 8] = digest_buf
[ 8];
8344 digest_buf
[ 9] = digest_buf
[ 9];
8345 digest_buf
[10] = digest_buf
[10];
8346 digest_buf
[11] = digest_buf
[11];
8347 digest_buf
[12] = digest_buf
[12];
8348 digest_buf
[13] = digest_buf
[13];
8349 digest_buf
[14] = digest_buf
[14];
8350 digest_buf
[15] = digest_buf
[15];
8352 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8370 else if (hash_type
== HASH_TYPE_GOST
)
8372 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8382 else if (hash_type
== HASH_TYPE_MYSQL
)
8384 snprintf (out_buf
, len
-1, "%08x%08x",
8388 else if (hash_type
== HASH_TYPE_LOTUS5
)
8390 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8396 else if (hash_type
== HASH_TYPE_LOTUS6
)
8398 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8399 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8400 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8401 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8403 char buf
[16] = { 0 };
8405 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8406 memcpy (buf
+ 5, digest_buf
, 9);
8410 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8412 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8415 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8417 else if (hash_type
== HASH_TYPE_LOTUS8
)
8419 char buf
[52] = { 0 };
8423 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8429 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8433 buf
[26] = salt
.salt_buf_pc
[0];
8434 buf
[27] = salt
.salt_buf_pc
[1];
8438 memcpy (buf
+ 28, digest_buf
, 8);
8440 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8444 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8446 else if (hash_type
== HASH_TYPE_CRC32
)
8448 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8452 if (salt_type
== SALT_TYPE_INTERN
)
8454 size_t pos
= strlen (out_buf
);
8456 out_buf
[pos
] = data
.separator
;
8458 char *ptr
= (char *) salt
.salt_buf
;
8460 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8462 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8466 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8468 memset (hccap
, 0, sizeof (hccap_t
));
8470 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8472 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8474 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8475 wpa_t
*wpa
= &wpas
[salt_pos
];
8477 hccap
->keyver
= wpa
->keyver
;
8479 hccap
->eapol_size
= wpa
->eapol_size
;
8481 if (wpa
->keyver
!= 1)
8483 uint eapol_tmp
[64] = { 0 };
8485 for (uint i
= 0; i
< 64; i
++)
8487 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8490 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8494 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8497 uint pke_tmp
[25] = { 0 };
8499 for (int i
= 5; i
< 25; i
++)
8501 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8504 char *pke_ptr
= (char *) pke_tmp
;
8506 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8507 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8508 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8509 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8511 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8513 uint dgst_size
= data
.dgst_size
;
8515 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8517 if (wpa
->keyver
!= 1)
8519 uint digest_tmp
[4] = { 0 };
8521 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8522 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8523 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8524 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8526 memcpy (hccap
->keymic
, digest_tmp
, 16);
8530 memcpy (hccap
->keymic
, digest_ptr
, 16);
8534 void SuspendThreads ()
8536 if (data
.devices_status
== STATUS_RUNNING
)
8538 hc_timer_set (&data
.timer_paused
);
8540 data
.devices_status
= STATUS_PAUSED
;
8542 log_info ("Paused");
8546 void ResumeThreads ()
8548 if (data
.devices_status
== STATUS_PAUSED
)
8552 hc_timer_get (data
.timer_paused
, ms_paused
);
8554 data
.ms_paused
+= ms_paused
;
8556 data
.devices_status
= STATUS_RUNNING
;
8558 log_info ("Resumed");
8564 if (data
.devices_status
!= STATUS_RUNNING
) return;
8566 data
.devices_status
= STATUS_BYPASS
;
8568 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8571 void stop_at_checkpoint ()
8573 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8575 if (data
.devices_status
!= STATUS_RUNNING
) return;
8578 // this feature only makes sense if --restore-disable was not specified
8580 if (data
.restore_disable
== 1)
8582 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8587 // check if monitoring of Restore Point updates should be enabled or disabled
8589 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8591 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8593 // save the current restore point value
8595 data
.checkpoint_cur_words
= get_lowest_words_done ();
8597 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8601 data
.devices_status
= STATUS_RUNNING
;
8603 // reset the global value for checkpoint checks
8605 data
.checkpoint_cur_words
= 0;
8607 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8613 if (data
.devices_status
== STATUS_INIT
) return;
8614 if (data
.devices_status
== STATUS_STARTING
) return;
8616 data
.devices_status
= STATUS_ABORTED
;
8621 if (data
.devices_status
== STATUS_INIT
) return;
8622 if (data
.devices_status
== STATUS_STARTING
) return;
8624 data
.devices_status
= STATUS_QUIT
;
8627 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8631 if ((fp
= fopen (kernel_file
, "rb")) != NULL
)
8635 memset (&st
, 0, sizeof (st
));
8637 stat (kernel_file
, &st
);
8639 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8641 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8643 if (num_read
!= (size_t) st
.st_size
)
8645 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8652 buf
[st
.st_size
] = 0;
8654 for (int i
= 0; i
< num_devices
; i
++)
8656 kernel_lengths
[i
] = (size_t) st
.st_size
;
8658 kernel_sources
[i
] = buf
;
8663 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8671 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8673 FILE *fp
= fopen (dst
, "wb");
8675 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8685 restore_data_t
*init_restore (int argc
, char **argv
)
8687 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8689 if (data
.restore_disable
== 0)
8691 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8695 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8699 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8708 char pidbin
[BUFSIZ
] = { 0 };
8710 int pidbin_len
= -1;
8713 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8715 FILE *fd
= fopen (pidbin
, "rb");
8719 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8721 pidbin
[pidbin_len
] = 0;
8725 char *argv0_r
= strrchr (argv
[0], '/');
8727 char *pidbin_r
= strrchr (pidbin
, '/');
8729 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8731 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8733 if (strcmp (argv0_r
, pidbin_r
) == 0)
8735 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8742 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8744 char pidbin2
[BUFSIZ
] = {Â
0 };
8746 int pidbin2_len
= -1;
8748 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8749 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8751 pidbin
[pidbin_len
] = 0;
8752 pidbin2
[pidbin2_len
] = 0;
8756 if (strcmp (pidbin
, pidbin2
) == 0)
8758 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8766 if (rd
->version_bin
< RESTORE_MIN
)
8768 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8775 memset (rd
, 0, sizeof (restore_data_t
));
8777 rd
->version_bin
= VERSION_BIN
;
8780 rd
->pid
= getpid ();
8782 rd
->pid
= GetCurrentProcessId ();
8785 if (getcwd (rd
->cwd
, 255) == NULL
)
8798 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8800 FILE *fp
= fopen (eff_restore_file
, "rb");
8804 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8809 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8811 log_error ("ERROR: cannot read %s", eff_restore_file
);
8816 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8818 for (uint i
= 0; i
< rd
->argc
; i
++)
8820 char buf
[BUFSIZ
] = { 0 };
8822 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8824 log_error ("ERROR: cannot read %s", eff_restore_file
);
8829 size_t len
= strlen (buf
);
8831 if (len
) buf
[len
- 1] = 0;
8833 rd
->argv
[i
] = mystrdup (buf
);
8838 char new_cwd
[1024] = { 0 };
8840 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8844 log_error ("Restore file is corrupted");
8847 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8849 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8851 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8856 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8859 if (chdir (rd
->cwd
))
8861 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8867 u64
get_lowest_words_done ()
8871 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8873 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8875 if (device_param
->skipped
) continue;
8877 const u64 words_done
= device_param
->words_done
;
8879 if (words_done
< words_cur
) words_cur
= words_done
;
8882 // It's possible that a device's workload isn't finished right after a restore-case.
8883 // In that case, this function would return 0 and overwrite the real restore point
8884 // There's also data.words_cur which is set to rd->words_cur but it changes while
8885 // the attack is running therefore we should stick to rd->words_cur.
8886 // Note that -s influences rd->words_cur we should keep a close look on that.
8888 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8893 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8895 u64 words_cur
= get_lowest_words_done ();
8897 rd
->words_cur
= words_cur
;
8899 FILE *fp
= fopen (new_restore_file
, "wb");
8903 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8908 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8910 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8915 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8917 for (uint i
= 0; i
< rd
->argc
; i
++)
8919 fprintf (fp
, "%s", rd
->argv
[i
]);
8925 fsync (fileno (fp
));
8930 void cycle_restore ()
8932 const char *eff_restore_file
= data
.eff_restore_file
;
8933 const char *new_restore_file
= data
.new_restore_file
;
8935 restore_data_t
*rd
= data
.rd
;
8937 write_restore (new_restore_file
, rd
);
8941 memset (&st
, 0, sizeof(st
));
8943 if (stat (eff_restore_file
, &st
) == 0)
8945 if (unlink (eff_restore_file
))
8947 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8951 if (rename (new_restore_file
, eff_restore_file
))
8953 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8957 void check_checkpoint ()
8959 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8961 u64 words_cur
= get_lowest_words_done ();
8963 if (words_cur
!= data
.checkpoint_cur_words
)
8973 uint
set_kernel_accel (uint hash_mode
)
8977 case 0: return GET_ACCEL (0);
8978 case 10: return GET_ACCEL (10);
8979 case 11: return GET_ACCEL (11);
8980 case 12: return GET_ACCEL (12);
8981 case 20: return GET_ACCEL (20);
8982 case 21: return GET_ACCEL (21);
8983 case 22: return GET_ACCEL (22);
8984 case 23: return GET_ACCEL (23);
8985 case 30: return GET_ACCEL (30);
8986 case 40: return GET_ACCEL (40);
8987 case 50: return GET_ACCEL (50);
8988 case 60: return GET_ACCEL (60);
8989 case 100: return GET_ACCEL (100);
8990 case 101: return GET_ACCEL (101);
8991 case 110: return GET_ACCEL (110);
8992 case 111: return GET_ACCEL (111);
8993 case 112: return GET_ACCEL (112);
8994 case 120: return GET_ACCEL (120);
8995 case 121: return GET_ACCEL (121);
8996 case 122: return GET_ACCEL (122);
8997 case 124: return GET_ACCEL (124);
8998 case 130: return GET_ACCEL (130);
8999 case 131: return GET_ACCEL (131);
9000 case 132: return GET_ACCEL (132);
9001 case 133: return GET_ACCEL (133);
9002 case 140: return GET_ACCEL (140);
9003 case 141: return GET_ACCEL (141);
9004 case 150: return GET_ACCEL (150);
9005 case 160: return GET_ACCEL (160);
9006 case 190: return GET_ACCEL (190);
9007 case 200: return GET_ACCEL (200);
9008 case 300: return GET_ACCEL (300);
9009 case 400: return GET_ACCEL (400);
9010 case 500: return GET_ACCEL (500);
9011 case 501: return GET_ACCEL (501);
9012 case 900: return GET_ACCEL (900);
9013 case 910: return GET_ACCEL (910);
9014 case 1000: return GET_ACCEL (1000);
9015 case 1100: return GET_ACCEL (1100);
9016 case 1400: return GET_ACCEL (1400);
9017 case 1410: return GET_ACCEL (1410);
9018 case 1420: return GET_ACCEL (1420);
9019 case 1421: return GET_ACCEL (1421);
9020 case 1430: return GET_ACCEL (1430);
9021 case 1440: return GET_ACCEL (1440);
9022 case 1441: return GET_ACCEL (1441);
9023 case 1450: return GET_ACCEL (1450);
9024 case 1460: return GET_ACCEL (1460);
9025 case 1500: return GET_ACCEL (1500);
9026 case 1600: return GET_ACCEL (1600);
9027 case 1700: return GET_ACCEL (1700);
9028 case 1710: return GET_ACCEL (1710);
9029 case 1711: return GET_ACCEL (1711);
9030 case 1720: return GET_ACCEL (1720);
9031 case 1722: return GET_ACCEL (1722);
9032 case 1730: return GET_ACCEL (1730);
9033 case 1731: return GET_ACCEL (1731);
9034 case 1740: return GET_ACCEL (1740);
9035 case 1750: return GET_ACCEL (1750);
9036 case 1760: return GET_ACCEL (1760);
9037 case 1800: return GET_ACCEL (1800);
9038 case 2100: return GET_ACCEL (2100);
9039 case 2400: return GET_ACCEL (2400);
9040 case 2410: return GET_ACCEL (2410);
9041 case 2500: return GET_ACCEL (2500);
9042 case 2600: return GET_ACCEL (2600);
9043 case 2611: return GET_ACCEL (2611);
9044 case 2612: return GET_ACCEL (2612);
9045 case 2711: return GET_ACCEL (2711);
9046 case 2811: return GET_ACCEL (2811);
9047 case 3000: return GET_ACCEL (3000);
9048 case 3100: return GET_ACCEL (3100);
9049 case 3200: return GET_ACCEL (3200);
9050 case 3710: return GET_ACCEL (3710);
9051 case 3711: return GET_ACCEL (3711);
9052 case 3800: return GET_ACCEL (3800);
9053 case 4300: return GET_ACCEL (4300);
9054 case 4400: return GET_ACCEL (4400);
9055 case 4500: return GET_ACCEL (4500);
9056 case 4700: return GET_ACCEL (4700);
9057 case 4800: return GET_ACCEL (4800);
9058 case 4900: return GET_ACCEL (4900);
9059 case 5000: return GET_ACCEL (5000);
9060 case 5100: return GET_ACCEL (5100);
9061 case 5200: return GET_ACCEL (5200);
9062 case 5300: return GET_ACCEL (5300);
9063 case 5400: return GET_ACCEL (5400);
9064 case 5500: return GET_ACCEL (5500);
9065 case 5600: return GET_ACCEL (5600);
9066 case 5700: return GET_ACCEL (5700);
9067 case 5800: return GET_ACCEL (5800);
9068 case 6000: return GET_ACCEL (6000);
9069 case 6100: return GET_ACCEL (6100);
9070 case 6211: return GET_ACCEL (6211);
9071 case 6212: return GET_ACCEL (6212);
9072 case 6213: return GET_ACCEL (6213);
9073 case 6221: return GET_ACCEL (6221);
9074 case 6222: return GET_ACCEL (6222);
9075 case 6223: return GET_ACCEL (6223);
9076 case 6231: return GET_ACCEL (6231);
9077 case 6232: return GET_ACCEL (6232);
9078 case 6233: return GET_ACCEL (6233);
9079 case 6241: return GET_ACCEL (6241);
9080 case 6242: return GET_ACCEL (6242);
9081 case 6243: return GET_ACCEL (6243);
9082 case 6300: return GET_ACCEL (6300);
9083 case 6400: return GET_ACCEL (6400);
9084 case 6500: return GET_ACCEL (6500);
9085 case 6600: return GET_ACCEL (6600);
9086 case 6700: return GET_ACCEL (6700);
9087 case 6800: return GET_ACCEL (6800);
9088 case 6900: return GET_ACCEL (6900);
9089 case 7100: return GET_ACCEL (7100);
9090 case 7200: return GET_ACCEL (7200);
9091 case 7300: return GET_ACCEL (7300);
9092 case 7400: return GET_ACCEL (7400);
9093 case 7500: return GET_ACCEL (7500);
9094 case 7600: return GET_ACCEL (7600);
9095 case 7700: return GET_ACCEL (7700);
9096 case 7800: return GET_ACCEL (7800);
9097 case 7900: return GET_ACCEL (7900);
9098 case 8000: return GET_ACCEL (8000);
9099 case 8100: return GET_ACCEL (8100);
9100 case 8200: return GET_ACCEL (8200);
9101 case 8300: return GET_ACCEL (8300);
9102 case 8400: return GET_ACCEL (8400);
9103 case 8500: return GET_ACCEL (8500);
9104 case 8600: return GET_ACCEL (8600);
9105 case 8700: return GET_ACCEL (8700);
9106 case 8800: return GET_ACCEL (8800);
9107 case 8900: return GET_ACCEL (8900);
9108 case 9000: return GET_ACCEL (9000);
9109 case 9100: return GET_ACCEL (9100);
9110 case 9200: return GET_ACCEL (9200);
9111 case 9300: return GET_ACCEL (9300);
9112 case 9400: return GET_ACCEL (9400);
9113 case 9500: return GET_ACCEL (9500);
9114 case 9600: return GET_ACCEL (9600);
9115 case 9700: return GET_ACCEL (9700);
9116 case 9710: return GET_ACCEL (9710);
9117 case 9720: return GET_ACCEL (9720);
9118 case 9800: return GET_ACCEL (9800);
9119 case 9810: return GET_ACCEL (9810);
9120 case 9820: return GET_ACCEL (9820);
9121 case 9900: return GET_ACCEL (9900);
9122 case 10000: return GET_ACCEL (10000);
9123 case 10100: return GET_ACCEL (10100);
9124 case 10200: return GET_ACCEL (10200);
9125 case 10300: return GET_ACCEL (10300);
9126 case 10400: return GET_ACCEL (10400);
9127 case 10410: return GET_ACCEL (10410);
9128 case 10420: return GET_ACCEL (10420);
9129 case 10500: return GET_ACCEL (10500);
9130 case 10600: return GET_ACCEL (10600);
9131 case 10700: return GET_ACCEL (10700);
9132 case 10800: return GET_ACCEL (10800);
9133 case 10900: return GET_ACCEL (10900);
9134 case 11000: return GET_ACCEL (11000);
9135 case 11100: return GET_ACCEL (11100);
9136 case 11200: return GET_ACCEL (11200);
9137 case 11300: return GET_ACCEL (11300);
9138 case 11400: return GET_ACCEL (11400);
9139 case 11500: return GET_ACCEL (11500);
9140 case 11600: return GET_ACCEL (11600);
9141 case 11700: return GET_ACCEL (11700);
9142 case 11800: return GET_ACCEL (11800);
9143 case 11900: return GET_ACCEL (11900);
9144 case 12000: return GET_ACCEL (12000);
9145 case 12100: return GET_ACCEL (12100);
9146 case 12200: return GET_ACCEL (12200);
9147 case 12300: return GET_ACCEL (12300);
9148 case 12400: return GET_ACCEL (12400);
9149 case 12500: return GET_ACCEL (12500);
9150 case 12600: return GET_ACCEL (12600);
9151 case 12700: return GET_ACCEL (12700);
9152 case 12800: return GET_ACCEL (12800);
9153 case 12900: return GET_ACCEL (12900);
9154 case 13000: return GET_ACCEL (13000);
9160 uint
set_kernel_loops (uint hash_mode
)
9164 case 0: return GET_LOOPS (0);
9165 case 10: return GET_LOOPS (10);
9166 case 11: return GET_LOOPS (11);
9167 case 12: return GET_LOOPS (12);
9168 case 20: return GET_LOOPS (20);
9169 case 21: return GET_LOOPS (21);
9170 case 22: return GET_LOOPS (22);
9171 case 23: return GET_LOOPS (23);
9172 case 30: return GET_LOOPS (30);
9173 case 40: return GET_LOOPS (40);
9174 case 50: return GET_LOOPS (50);
9175 case 60: return GET_LOOPS (60);
9176 case 100: return GET_LOOPS (100);
9177 case 101: return GET_LOOPS (101);
9178 case 110: return GET_LOOPS (110);
9179 case 111: return GET_LOOPS (111);
9180 case 112: return GET_LOOPS (112);
9181 case 120: return GET_LOOPS (120);
9182 case 121: return GET_LOOPS (121);
9183 case 122: return GET_LOOPS (122);
9184 case 124: return GET_LOOPS (124);
9185 case 130: return GET_LOOPS (130);
9186 case 131: return GET_LOOPS (131);
9187 case 132: return GET_LOOPS (132);
9188 case 133: return GET_LOOPS (133);
9189 case 140: return GET_LOOPS (140);
9190 case 141: return GET_LOOPS (141);
9191 case 150: return GET_LOOPS (150);
9192 case 160: return GET_LOOPS (160);
9193 case 190: return GET_LOOPS (190);
9194 case 200: return GET_LOOPS (200);
9195 case 300: return GET_LOOPS (300);
9196 case 400: return GET_LOOPS (400);
9197 case 500: return GET_LOOPS (500);
9198 case 501: return GET_LOOPS (501);
9199 case 900: return GET_LOOPS (900);
9200 case 910: return GET_LOOPS (910);
9201 case 1000: return GET_LOOPS (1000);
9202 case 1100: return GET_LOOPS (1100);
9203 case 1400: return GET_LOOPS (1400);
9204 case 1410: return GET_LOOPS (1410);
9205 case 1420: return GET_LOOPS (1420);
9206 case 1421: return GET_LOOPS (1421);
9207 case 1430: return GET_LOOPS (1430);
9208 case 1440: return GET_LOOPS (1440);
9209 case 1441: return GET_LOOPS (1441);
9210 case 1450: return GET_LOOPS (1450);
9211 case 1460: return GET_LOOPS (1460);
9212 case 1500: return GET_LOOPS (1500);
9213 case 1600: return GET_LOOPS (1600);
9214 case 1700: return GET_LOOPS (1700);
9215 case 1710: return GET_LOOPS (1710);
9216 case 1711: return GET_LOOPS (1711);
9217 case 1720: return GET_LOOPS (1720);
9218 case 1722: return GET_LOOPS (1722);
9219 case 1730: return GET_LOOPS (1730);
9220 case 1731: return GET_LOOPS (1731);
9221 case 1740: return GET_LOOPS (1740);
9222 case 1750: return GET_LOOPS (1750);
9223 case 1760: return GET_LOOPS (1760);
9224 case 1800: return GET_LOOPS (1800);
9225 case 2100: return GET_LOOPS (2100);
9226 case 2400: return GET_LOOPS (2400);
9227 case 2410: return GET_LOOPS (2410);
9228 case 2500: return GET_LOOPS (2500);
9229 case 2600: return GET_LOOPS (2600);
9230 case 2611: return GET_LOOPS (2611);
9231 case 2612: return GET_LOOPS (2612);
9232 case 2711: return GET_LOOPS (2711);
9233 case 2811: return GET_LOOPS (2811);
9234 case 3000: return GET_LOOPS (3000);
9235 case 3100: return GET_LOOPS (3100);
9236 case 3200: return GET_LOOPS (3200);
9237 case 3710: return GET_LOOPS (3710);
9238 case 3711: return GET_LOOPS (3711);
9239 case 3800: return GET_LOOPS (3800);
9240 case 4300: return GET_LOOPS (4300);
9241 case 4400: return GET_LOOPS (4400);
9242 case 4500: return GET_LOOPS (4500);
9243 case 4700: return GET_LOOPS (4700);
9244 case 4800: return GET_LOOPS (4800);
9245 case 4900: return GET_LOOPS (4900);
9246 case 5000: return GET_LOOPS (5000);
9247 case 5100: return GET_LOOPS (5100);
9248 case 5200: return GET_LOOPS (5200);
9249 case 5300: return GET_LOOPS (5300);
9250 case 5400: return GET_LOOPS (5400);
9251 case 5500: return GET_LOOPS (5500);
9252 case 5600: return GET_LOOPS (5600);
9253 case 5700: return GET_LOOPS (5700);
9254 case 5800: return GET_LOOPS (5800);
9255 case 6000: return GET_LOOPS (6000);
9256 case 6100: return GET_LOOPS (6100);
9257 case 6211: return GET_LOOPS (6211);
9258 case 6212: return GET_LOOPS (6212);
9259 case 6213: return GET_LOOPS (6213);
9260 case 6221: return GET_LOOPS (6221);
9261 case 6222: return GET_LOOPS (6222);
9262 case 6223: return GET_LOOPS (6223);
9263 case 6231: return GET_LOOPS (6231);
9264 case 6232: return GET_LOOPS (6232);
9265 case 6233: return GET_LOOPS (6233);
9266 case 6241: return GET_LOOPS (6241);
9267 case 6242: return GET_LOOPS (6242);
9268 case 6243: return GET_LOOPS (6243);
9269 case 6300: return GET_LOOPS (6300);
9270 case 6400: return GET_LOOPS (6400);
9271 case 6500: return GET_LOOPS (6500);
9272 case 6600: return GET_LOOPS (6600);
9273 case 6700: return GET_LOOPS (6700);
9274 case 6800: return GET_LOOPS (6800);
9275 case 6900: return GET_LOOPS (6900);
9276 case 7100: return GET_LOOPS (7100);
9277 case 7200: return GET_LOOPS (7200);
9278 case 7300: return GET_LOOPS (7300);
9279 case 7400: return GET_LOOPS (7400);
9280 case 7500: return GET_LOOPS (7500);
9281 case 7600: return GET_LOOPS (7600);
9282 case 7700: return GET_LOOPS (7700);
9283 case 7800: return GET_LOOPS (7800);
9284 case 7900: return GET_LOOPS (7900);
9285 case 8000: return GET_LOOPS (8000);
9286 case 8100: return GET_LOOPS (8100);
9287 case 8200: return GET_LOOPS (8200);
9288 case 8300: return GET_LOOPS (8300);
9289 case 8400: return GET_LOOPS (8400);
9290 case 8500: return GET_LOOPS (8500);
9291 case 8600: return GET_LOOPS (8600);
9292 case 8700: return GET_LOOPS (8700);
9293 case 8800: return GET_LOOPS (8800);
9294 case 8900: return GET_LOOPS (8900);
9295 case 9000: return GET_LOOPS (9000);
9296 case 9100: return GET_LOOPS (9100);
9297 case 9200: return GET_LOOPS (9200);
9298 case 9300: return GET_LOOPS (9300);
9299 case 9400: return GET_LOOPS (9400);
9300 case 9500: return GET_LOOPS (9500);
9301 case 9600: return GET_LOOPS (9600);
9302 case 9700: return GET_LOOPS (9700);
9303 case 9710: return GET_LOOPS (9710);
9304 case 9720: return GET_LOOPS (9720);
9305 case 9800: return GET_LOOPS (9800);
9306 case 9810: return GET_LOOPS (9810);
9307 case 9820: return GET_LOOPS (9820);
9308 case 9900: return GET_LOOPS (9900);
9309 case 10000: return GET_LOOPS (10000);
9310 case 10100: return GET_LOOPS (10100);
9311 case 10200: return GET_LOOPS (10200);
9312 case 10300: return GET_LOOPS (10300);
9313 case 10400: return GET_LOOPS (10400);
9314 case 10410: return GET_LOOPS (10410);
9315 case 10420: return GET_LOOPS (10420);
9316 case 10500: return GET_LOOPS (10500);
9317 case 10600: return GET_LOOPS (10600);
9318 case 10700: return GET_LOOPS (10700);
9319 case 10800: return GET_LOOPS (10800);
9320 case 10900: return GET_LOOPS (10900);
9321 case 11000: return GET_LOOPS (11000);
9322 case 11100: return GET_LOOPS (11100);
9323 case 11200: return GET_LOOPS (11200);
9324 case 11300: return GET_LOOPS (11300);
9325 case 11400: return GET_LOOPS (11400);
9326 case 11500: return GET_LOOPS (11500);
9327 case 11600: return GET_LOOPS (11600);
9328 case 11700: return GET_LOOPS (11700);
9329 case 11800: return GET_LOOPS (11800);
9330 case 11900: return GET_LOOPS (11900);
9331 case 12000: return GET_LOOPS (12000);
9332 case 12100: return GET_LOOPS (12100);
9333 case 12200: return GET_LOOPS (12200);
9334 case 12300: return GET_LOOPS (12300);
9335 case 12400: return GET_LOOPS (12400);
9336 case 12500: return GET_LOOPS (12500);
9337 case 12600: return GET_LOOPS (12600);
9338 case 12700: return GET_LOOPS (12700);
9339 case 12800: return GET_LOOPS (12800);
9340 case 12900: return GET_LOOPS (12900);
9341 case 13000: return GET_LOOPS (13000);
9351 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9353 u8 tmp
[256] = { 0 };
9355 if (salt_len
> sizeof (tmp
))
9360 memcpy (tmp
, in
, salt_len
);
9362 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9364 if ((salt_len
% 2) == 0)
9366 u32 new_salt_len
= salt_len
/ 2;
9368 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9373 tmp
[i
] = hex_convert (p1
) << 0;
9374 tmp
[i
] |= hex_convert (p0
) << 4;
9377 salt_len
= new_salt_len
;
9384 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9386 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9389 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9391 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9395 u32
*tmp_uint
= (u32
*) tmp
;
9397 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9398 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9399 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9400 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9401 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9402 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9403 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9404 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9405 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9406 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9408 salt_len
= salt_len
* 2;
9416 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9418 lowercase (tmp
, salt_len
);
9421 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9423 uppercase (tmp
, salt_len
);
9428 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9433 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9438 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9440 u32
*tmp_uint
= (uint
*) tmp
;
9446 for (u32 i
= 0; i
< max
; i
++)
9448 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9451 // Important: we may need to increase the length of memcpy since
9452 // we don't want to "loose" some swapped bytes (could happen if
9453 // they do not perfectly fit in the 4-byte blocks)
9454 // Memcpy does always copy the bytes in the BE order, but since
9455 // we swapped them, some important bytes could be in positions
9456 // we normally skip with the original len
9458 if (len
% 4) len
+= 4 - (len
% 4);
9461 memcpy (out
, tmp
, len
);
9466 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9468 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9470 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9472 u32
*digest
= (u32
*) hash_buf
->digest
;
9474 salt_t
*salt
= hash_buf
->salt
;
9476 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9478 char *iter_pos
= input_buf
+ 4;
9480 salt
->salt_iter
= 1 << atoi (iter_pos
);
9482 char *salt_pos
= strchr (iter_pos
, '$');
9484 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9490 salt
->salt_len
= salt_len
;
9492 u8 tmp_buf
[100] = { 0 };
9494 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9496 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9498 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9500 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9501 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9502 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9503 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9505 char *hash_pos
= salt_pos
+ 22;
9507 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9509 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9511 memcpy (digest
, tmp_buf
, 24);
9513 digest
[0] = byte_swap_32 (digest
[0]);
9514 digest
[1] = byte_swap_32 (digest
[1]);
9515 digest
[2] = byte_swap_32 (digest
[2]);
9516 digest
[3] = byte_swap_32 (digest
[3]);
9517 digest
[4] = byte_swap_32 (digest
[4]);
9518 digest
[5] = byte_swap_32 (digest
[5]);
9520 digest
[5] &= ~0xff; // its just 23 not 24 !
9525 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9527 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9529 u32
*digest
= (u32
*) hash_buf
->digest
;
9531 u8 tmp_buf
[100] = { 0 };
9533 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9535 memcpy (digest
, tmp_buf
, 32);
9537 digest
[0] = byte_swap_32 (digest
[0]);
9538 digest
[1] = byte_swap_32 (digest
[1]);
9539 digest
[2] = byte_swap_32 (digest
[2]);
9540 digest
[3] = byte_swap_32 (digest
[3]);
9541 digest
[4] = byte_swap_32 (digest
[4]);
9542 digest
[5] = byte_swap_32 (digest
[5]);
9543 digest
[6] = byte_swap_32 (digest
[6]);
9544 digest
[7] = byte_swap_32 (digest
[7]);
9546 digest
[0] -= SHA256M_A
;
9547 digest
[1] -= SHA256M_B
;
9548 digest
[2] -= SHA256M_C
;
9549 digest
[3] -= SHA256M_D
;
9550 digest
[4] -= SHA256M_E
;
9551 digest
[5] -= SHA256M_F
;
9552 digest
[6] -= SHA256M_G
;
9553 digest
[7] -= SHA256M_H
;
9558 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9560 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9562 u32
*digest
= (u32
*) hash_buf
->digest
;
9564 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9565 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9567 digest
[0] = byte_swap_32 (digest
[0]);
9568 digest
[1] = byte_swap_32 (digest
[1]);
9572 IP (digest
[0], digest
[1], tt
);
9574 digest
[0] = digest
[0];
9575 digest
[1] = digest
[1];
9582 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9584 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9586 u32
*digest
= (u32
*) hash_buf
->digest
;
9588 salt_t
*salt
= hash_buf
->salt
;
9590 char *hash_pos
= input_buf
+ 8;
9592 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9593 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9594 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9595 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9596 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9598 digest
[0] -= SHA1M_A
;
9599 digest
[1] -= SHA1M_B
;
9600 digest
[2] -= SHA1M_C
;
9601 digest
[3] -= SHA1M_D
;
9602 digest
[4] -= SHA1M_E
;
9606 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9608 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9610 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9612 salt
->salt_len
= salt_len
;
9617 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9619 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9621 u64
*digest
= (u64
*) hash_buf
->digest
;
9623 salt_t
*salt
= hash_buf
->salt
;
9625 char *hash_pos
= input_buf
+ 8;
9627 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9628 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9629 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9630 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9631 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9632 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9633 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9634 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9636 digest
[0] -= SHA512M_A
;
9637 digest
[1] -= SHA512M_B
;
9638 digest
[2] -= SHA512M_C
;
9639 digest
[3] -= SHA512M_D
;
9640 digest
[4] -= SHA512M_E
;
9641 digest
[5] -= SHA512M_F
;
9642 digest
[6] -= SHA512M_G
;
9643 digest
[7] -= SHA512M_H
;
9647 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9649 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9651 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9653 salt
->salt_len
= salt_len
;
9658 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9660 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9662 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9666 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9669 u32
*digest
= (u32
*) hash_buf
->digest
;
9671 salt_t
*salt
= hash_buf
->salt
;
9673 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9674 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9675 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9676 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9678 digest
[0] = byte_swap_32 (digest
[0]);
9679 digest
[1] = byte_swap_32 (digest
[1]);
9680 digest
[2] = byte_swap_32 (digest
[2]);
9681 digest
[3] = byte_swap_32 (digest
[3]);
9683 digest
[0] -= MD5M_A
;
9684 digest
[1] -= MD5M_B
;
9685 digest
[2] -= MD5M_C
;
9686 digest
[3] -= MD5M_D
;
9688 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9690 uint salt_len
= input_len
- 32 - 1;
9692 char *salt_buf
= input_buf
+ 32 + 1;
9694 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9696 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9698 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9700 salt
->salt_len
= salt_len
;
9705 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9707 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9709 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9713 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9718 char clean_input_buf
[32] = { 0 };
9720 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9721 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9723 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9727 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9733 clean_input_buf
[k
] = input_buf
[i
];
9741 u32
*digest
= (u32
*) hash_buf
->digest
;
9743 salt_t
*salt
= hash_buf
->salt
;
9745 u32 a
, b
, c
, d
, e
, f
;
9747 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9748 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9749 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9750 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9751 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9752 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9754 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9755 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9757 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9758 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9759 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9760 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9761 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9762 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9764 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9765 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9767 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9768 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9769 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9770 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9771 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9772 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9774 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9775 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9777 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9778 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9779 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9780 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9781 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9782 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9784 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9785 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9787 digest
[0] = byte_swap_32 (digest
[0]);
9788 digest
[1] = byte_swap_32 (digest
[1]);
9789 digest
[2] = byte_swap_32 (digest
[2]);
9790 digest
[3] = byte_swap_32 (digest
[3]);
9792 digest
[0] -= MD5M_A
;
9793 digest
[1] -= MD5M_B
;
9794 digest
[2] -= MD5M_C
;
9795 digest
[3] -= MD5M_D
;
9797 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9799 uint salt_len
= input_len
- 30 - 1;
9801 char *salt_buf
= input_buf
+ 30 + 1;
9803 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9805 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9807 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9808 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9810 salt
->salt_len
= salt_len
;
9812 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9814 salt
->salt_len
+= 22;
9819 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9821 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9823 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9827 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9830 u32
*digest
= (u32
*) hash_buf
->digest
;
9832 salt_t
*salt
= hash_buf
->salt
;
9834 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9835 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9836 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9837 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9838 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9840 digest
[0] -= SHA1M_A
;
9841 digest
[1] -= SHA1M_B
;
9842 digest
[2] -= SHA1M_C
;
9843 digest
[3] -= SHA1M_D
;
9844 digest
[4] -= SHA1M_E
;
9846 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9848 uint salt_len
= input_len
- 40 - 1;
9850 char *salt_buf
= input_buf
+ 40 + 1;
9852 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9854 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9856 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9858 salt
->salt_len
= salt_len
;
9863 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9865 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9867 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9871 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9874 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9876 char *iter_pos
= input_buf
+ 6;
9878 salt_t
*salt
= hash_buf
->salt
;
9880 uint iter
= atoi (iter_pos
);
9887 salt
->salt_iter
= iter
- 1;
9889 char *salt_pos
= strchr (iter_pos
, '#');
9891 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9895 char *digest_pos
= strchr (salt_pos
, '#');
9897 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9901 uint salt_len
= digest_pos
- salt_pos
- 1;
9903 u32
*digest
= (u32
*) hash_buf
->digest
;
9905 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9906 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9907 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9908 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9910 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9912 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9914 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9916 salt
->salt_len
= salt_len
;
9921 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9923 u32
*digest
= (u32
*) hash_buf
->digest
;
9925 salt_t
*salt
= hash_buf
->salt
;
9927 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9931 memcpy (&in
, input_buf
, input_len
);
9933 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9935 memcpy (digest
, in
.keymic
, 16);
9938 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9939 The phrase "Pairwise key expansion"
9940 Access Point Address (referred to as Authenticator Address AA)
9941 Supplicant Address (referred to as Supplicant Address SA)
9942 Access Point Nonce (referred to as Authenticator Anonce)
9943 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9946 uint salt_len
= strlen (in
.essid
);
9948 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9950 salt
->salt_len
= salt_len
;
9952 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9954 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9956 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9958 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9960 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9961 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9965 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9966 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9969 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9971 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9972 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9976 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9977 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9980 for (int i
= 0; i
< 25; i
++)
9982 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9985 wpa
->keyver
= in
.keyver
;
9987 if (wpa
->keyver
> 255)
9989 log_info ("ATTENTION!");
9990 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9991 log_info (" This could be due to a recent aircrack-ng bug.");
9992 log_info (" The key version was automatically reset to a reasonable value.");
9995 wpa
->keyver
&= 0xff;
9998 wpa
->eapol_size
= in
.eapol_size
;
10000 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10002 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10004 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10006 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10008 if (wpa
->keyver
== 1)
10014 digest
[0] = byte_swap_32 (digest
[0]);
10015 digest
[1] = byte_swap_32 (digest
[1]);
10016 digest
[2] = byte_swap_32 (digest
[2]);
10017 digest
[3] = byte_swap_32 (digest
[3]);
10019 for (int i
= 0; i
< 64; i
++)
10021 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10025 salt
->salt_buf
[10] = digest
[1];
10026 salt
->salt_buf
[11] = digest
[2];
10028 return (PARSER_OK
);
10031 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10033 u32
*digest
= (u32
*) hash_buf
->digest
;
10035 salt_t
*salt
= hash_buf
->salt
;
10037 if (input_len
== 0)
10039 log_error ("Password Safe v2 container not specified");
10044 FILE *fp
= fopen (input_buf
, "rb");
10048 log_error ("%s: %s", input_buf
, strerror (errno
));
10055 memset (&buf
, 0, sizeof (psafe2_hdr
));
10057 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10061 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10063 salt
->salt_buf
[0] = buf
.random
[0];
10064 salt
->salt_buf
[1] = buf
.random
[1];
10066 salt
->salt_len
= 8;
10067 salt
->salt_iter
= 1000;
10069 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10070 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10071 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10072 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10073 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10075 return (PARSER_OK
);
10078 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10080 u32
*digest
= (u32
*) hash_buf
->digest
;
10082 salt_t
*salt
= hash_buf
->salt
;
10084 if (input_len
== 0)
10086 log_error (".psafe3 not specified");
10091 FILE *fp
= fopen (input_buf
, "rb");
10095 log_error ("%s: %s", input_buf
, strerror (errno
));
10102 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10106 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10108 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10110 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10112 salt
->salt_iter
= in
.iterations
+ 1;
10114 salt
->salt_buf
[0] = in
.salt_buf
[0];
10115 salt
->salt_buf
[1] = in
.salt_buf
[1];
10116 salt
->salt_buf
[2] = in
.salt_buf
[2];
10117 salt
->salt_buf
[3] = in
.salt_buf
[3];
10118 salt
->salt_buf
[4] = in
.salt_buf
[4];
10119 salt
->salt_buf
[5] = in
.salt_buf
[5];
10120 salt
->salt_buf
[6] = in
.salt_buf
[6];
10121 salt
->salt_buf
[7] = in
.salt_buf
[7];
10123 salt
->salt_len
= 32;
10125 digest
[0] = in
.hash_buf
[0];
10126 digest
[1] = in
.hash_buf
[1];
10127 digest
[2] = in
.hash_buf
[2];
10128 digest
[3] = in
.hash_buf
[3];
10129 digest
[4] = in
.hash_buf
[4];
10130 digest
[5] = in
.hash_buf
[5];
10131 digest
[6] = in
.hash_buf
[6];
10132 digest
[7] = in
.hash_buf
[7];
10134 digest
[0] = byte_swap_32 (digest
[0]);
10135 digest
[1] = byte_swap_32 (digest
[1]);
10136 digest
[2] = byte_swap_32 (digest
[2]);
10137 digest
[3] = byte_swap_32 (digest
[3]);
10138 digest
[4] = byte_swap_32 (digest
[4]);
10139 digest
[5] = byte_swap_32 (digest
[5]);
10140 digest
[6] = byte_swap_32 (digest
[6]);
10141 digest
[7] = byte_swap_32 (digest
[7]);
10143 return (PARSER_OK
);
10146 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10148 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10150 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10152 u32
*digest
= (u32
*) hash_buf
->digest
;
10154 salt_t
*salt
= hash_buf
->salt
;
10156 char *iter_pos
= input_buf
+ 3;
10158 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10160 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10162 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10164 salt
->salt_iter
= salt_iter
;
10166 char *salt_pos
= iter_pos
+ 1;
10170 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10172 salt
->salt_len
= salt_len
;
10174 char *hash_pos
= salt_pos
+ salt_len
;
10176 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10178 return (PARSER_OK
);
10181 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10183 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10185 u32
*digest
= (u32
*) hash_buf
->digest
;
10187 salt_t
*salt
= hash_buf
->salt
;
10189 char *salt_pos
= input_buf
+ 3;
10191 uint iterations_len
= 0;
10193 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10197 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10199 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10200 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10204 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10208 iterations_len
+= 8;
10212 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10215 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10217 char *hash_pos
= strchr (salt_pos
, '$');
10219 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10221 uint salt_len
= hash_pos
- salt_pos
;
10223 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10225 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10227 salt
->salt_len
= salt_len
;
10231 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10233 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10235 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10237 return (PARSER_OK
);
10240 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10242 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10244 u32
*digest
= (u32
*) hash_buf
->digest
;
10246 salt_t
*salt
= hash_buf
->salt
;
10248 char *salt_pos
= input_buf
+ 6;
10250 uint iterations_len
= 0;
10252 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10256 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10258 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10259 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10263 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10267 iterations_len
+= 8;
10271 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10274 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10276 char *hash_pos
= strchr (salt_pos
, '$');
10278 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10280 uint salt_len
= hash_pos
- salt_pos
;
10282 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10284 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10286 salt
->salt_len
= salt_len
;
10290 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10292 return (PARSER_OK
);
10295 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10297 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10299 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10301 u32
*digest
= (u32
*) hash_buf
->digest
;
10303 salt_t
*salt
= hash_buf
->salt
;
10305 char *salt_pos
= input_buf
+ 14;
10307 char *hash_pos
= strchr (salt_pos
, '*');
10309 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10313 uint salt_len
= hash_pos
- salt_pos
- 1;
10315 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10317 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10319 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10321 salt
->salt_len
= salt_len
;
10323 u8 tmp_buf
[100] = { 0 };
10325 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10327 memcpy (digest
, tmp_buf
, 20);
10329 digest
[0] = byte_swap_32 (digest
[0]);
10330 digest
[1] = byte_swap_32 (digest
[1]);
10331 digest
[2] = byte_swap_32 (digest
[2]);
10332 digest
[3] = byte_swap_32 (digest
[3]);
10333 digest
[4] = byte_swap_32 (digest
[4]);
10335 digest
[0] -= SHA1M_A
;
10336 digest
[1] -= SHA1M_B
;
10337 digest
[2] -= SHA1M_C
;
10338 digest
[3] -= SHA1M_D
;
10339 digest
[4] -= SHA1M_E
;
10341 return (PARSER_OK
);
10344 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10346 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10348 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10350 if (c12
& 3) return (PARSER_HASH_VALUE
);
10352 u32
*digest
= (u32
*) hash_buf
->digest
;
10354 salt_t
*salt
= hash_buf
->salt
;
10356 // for ascii_digest
10357 salt
->salt_sign
[0] = input_buf
[0];
10358 salt
->salt_sign
[1] = input_buf
[1];
10360 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10361 | itoa64_to_int (input_buf
[1]) << 6;
10363 salt
->salt_len
= 2;
10365 u8 tmp_buf
[100] = { 0 };
10367 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10369 memcpy (digest
, tmp_buf
, 8);
10373 IP (digest
[0], digest
[1], tt
);
10378 return (PARSER_OK
);
10381 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10383 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10385 u32
*digest
= (u32
*) hash_buf
->digest
;
10387 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10388 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10389 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10390 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10392 digest
[0] = byte_swap_32 (digest
[0]);
10393 digest
[1] = byte_swap_32 (digest
[1]);
10394 digest
[2] = byte_swap_32 (digest
[2]);
10395 digest
[3] = byte_swap_32 (digest
[3]);
10397 digest
[0] -= MD4M_A
;
10398 digest
[1] -= MD4M_B
;
10399 digest
[2] -= MD4M_C
;
10400 digest
[3] -= MD4M_D
;
10402 return (PARSER_OK
);
10405 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10407 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10409 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10413 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10416 u32
*digest
= (u32
*) hash_buf
->digest
;
10418 salt_t
*salt
= hash_buf
->salt
;
10420 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10421 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10422 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10423 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10425 digest
[0] = byte_swap_32 (digest
[0]);
10426 digest
[1] = byte_swap_32 (digest
[1]);
10427 digest
[2] = byte_swap_32 (digest
[2]);
10428 digest
[3] = byte_swap_32 (digest
[3]);
10430 digest
[0] -= MD4M_A
;
10431 digest
[1] -= MD4M_B
;
10432 digest
[2] -= MD4M_C
;
10433 digest
[3] -= MD4M_D
;
10435 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10437 uint salt_len
= input_len
- 32 - 1;
10439 char *salt_buf
= input_buf
+ 32 + 1;
10441 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10443 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10445 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10447 salt
->salt_len
= salt_len
;
10449 return (PARSER_OK
);
10452 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10454 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10456 u32
*digest
= (u32
*) hash_buf
->digest
;
10458 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10459 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10460 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10461 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10463 digest
[0] = byte_swap_32 (digest
[0]);
10464 digest
[1] = byte_swap_32 (digest
[1]);
10465 digest
[2] = byte_swap_32 (digest
[2]);
10466 digest
[3] = byte_swap_32 (digest
[3]);
10468 digest
[0] -= MD5M_A
;
10469 digest
[1] -= MD5M_B
;
10470 digest
[2] -= MD5M_C
;
10471 digest
[3] -= MD5M_D
;
10473 return (PARSER_OK
);
10476 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10478 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10480 u32
*digest
= (u32
*) hash_buf
->digest
;
10482 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10483 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10487 digest
[0] = byte_swap_32 (digest
[0]);
10488 digest
[1] = byte_swap_32 (digest
[1]);
10490 return (PARSER_OK
);
10493 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10495 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10497 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10501 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10504 u32
*digest
= (u32
*) hash_buf
->digest
;
10506 salt_t
*salt
= hash_buf
->salt
;
10508 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10509 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10510 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10511 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10513 digest
[0] = byte_swap_32 (digest
[0]);
10514 digest
[1] = byte_swap_32 (digest
[1]);
10515 digest
[2] = byte_swap_32 (digest
[2]);
10516 digest
[3] = byte_swap_32 (digest
[3]);
10518 digest
[0] -= MD5M_A
;
10519 digest
[1] -= MD5M_B
;
10520 digest
[2] -= MD5M_C
;
10521 digest
[3] -= MD5M_D
;
10523 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10525 uint salt_len
= input_len
- 32 - 1;
10527 char *salt_buf
= input_buf
+ 32 + 1;
10529 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10531 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10533 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10535 salt
->salt_len
= salt_len
;
10537 return (PARSER_OK
);
10540 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10542 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10544 u32
*digest
= (u32
*) hash_buf
->digest
;
10546 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10547 | itoa64_to_int (input_buf
[ 1]) << 6
10548 | itoa64_to_int (input_buf
[ 2]) << 12
10549 | itoa64_to_int (input_buf
[ 3]) << 18;
10550 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10551 | itoa64_to_int (input_buf
[ 5]) << 6
10552 | itoa64_to_int (input_buf
[ 6]) << 12
10553 | itoa64_to_int (input_buf
[ 7]) << 18;
10554 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10555 | itoa64_to_int (input_buf
[ 9]) << 6
10556 | itoa64_to_int (input_buf
[10]) << 12
10557 | itoa64_to_int (input_buf
[11]) << 18;
10558 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10559 | itoa64_to_int (input_buf
[13]) << 6
10560 | itoa64_to_int (input_buf
[14]) << 12
10561 | itoa64_to_int (input_buf
[15]) << 18;
10563 digest
[0] -= MD5M_A
;
10564 digest
[1] -= MD5M_B
;
10565 digest
[2] -= MD5M_C
;
10566 digest
[3] -= MD5M_D
;
10568 digest
[0] &= 0x00ffffff;
10569 digest
[1] &= 0x00ffffff;
10570 digest
[2] &= 0x00ffffff;
10571 digest
[3] &= 0x00ffffff;
10573 return (PARSER_OK
);
10576 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10578 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10580 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10584 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10587 u32
*digest
= (u32
*) hash_buf
->digest
;
10589 salt_t
*salt
= hash_buf
->salt
;
10591 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10592 | itoa64_to_int (input_buf
[ 1]) << 6
10593 | itoa64_to_int (input_buf
[ 2]) << 12
10594 | itoa64_to_int (input_buf
[ 3]) << 18;
10595 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10596 | itoa64_to_int (input_buf
[ 5]) << 6
10597 | itoa64_to_int (input_buf
[ 6]) << 12
10598 | itoa64_to_int (input_buf
[ 7]) << 18;
10599 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10600 | itoa64_to_int (input_buf
[ 9]) << 6
10601 | itoa64_to_int (input_buf
[10]) << 12
10602 | itoa64_to_int (input_buf
[11]) << 18;
10603 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10604 | itoa64_to_int (input_buf
[13]) << 6
10605 | itoa64_to_int (input_buf
[14]) << 12
10606 | itoa64_to_int (input_buf
[15]) << 18;
10608 digest
[0] -= MD5M_A
;
10609 digest
[1] -= MD5M_B
;
10610 digest
[2] -= MD5M_C
;
10611 digest
[3] -= MD5M_D
;
10613 digest
[0] &= 0x00ffffff;
10614 digest
[1] &= 0x00ffffff;
10615 digest
[2] &= 0x00ffffff;
10616 digest
[3] &= 0x00ffffff;
10618 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10620 uint salt_len
= input_len
- 16 - 1;
10622 char *salt_buf
= input_buf
+ 16 + 1;
10624 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10626 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10628 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10630 salt
->salt_len
= salt_len
;
10632 return (PARSER_OK
);
10635 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10637 key
[0] = (nthash
[0] >> 0);
10638 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10639 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10640 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10641 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10642 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10643 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10644 key
[7] = (nthash
[6] << 1);
10656 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10658 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10660 u32
*digest
= (u32
*) hash_buf
->digest
;
10662 salt_t
*salt
= hash_buf
->salt
;
10664 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10670 char *user_pos
= input_buf
;
10672 char *unused_pos
= strchr (user_pos
, ':');
10674 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10676 uint user_len
= unused_pos
- user_pos
;
10678 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10682 char *domain_pos
= strchr (unused_pos
, ':');
10684 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10686 uint unused_len
= domain_pos
- unused_pos
;
10688 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10692 char *srvchall_pos
= strchr (domain_pos
, ':');
10694 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10696 uint domain_len
= srvchall_pos
- domain_pos
;
10698 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10702 char *hash_pos
= strchr (srvchall_pos
, ':');
10704 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10706 uint srvchall_len
= hash_pos
- srvchall_pos
;
10708 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10712 char *clichall_pos
= strchr (hash_pos
, ':');
10714 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10716 uint hash_len
= clichall_pos
- hash_pos
;
10718 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10722 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10724 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10727 * store some data for later use
10730 netntlm
->user_len
= user_len
* 2;
10731 netntlm
->domain_len
= domain_len
* 2;
10732 netntlm
->srvchall_len
= srvchall_len
/ 2;
10733 netntlm
->clichall_len
= clichall_len
/ 2;
10735 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10736 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10739 * handle username and domainname
10742 for (uint i
= 0; i
< user_len
; i
++)
10744 *userdomain_ptr
++ = user_pos
[i
];
10745 *userdomain_ptr
++ = 0;
10748 for (uint i
= 0; i
< domain_len
; i
++)
10750 *userdomain_ptr
++ = domain_pos
[i
];
10751 *userdomain_ptr
++ = 0;
10755 * handle server challenge encoding
10758 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10760 const char p0
= srvchall_pos
[i
+ 0];
10761 const char p1
= srvchall_pos
[i
+ 1];
10763 *chall_ptr
++ = hex_convert (p1
) << 0
10764 | hex_convert (p0
) << 4;
10768 * handle client challenge encoding
10771 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10773 const char p0
= clichall_pos
[i
+ 0];
10774 const char p1
= clichall_pos
[i
+ 1];
10776 *chall_ptr
++ = hex_convert (p1
) << 0
10777 | hex_convert (p0
) << 4;
10784 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10786 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10788 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10790 salt
->salt_len
= salt_len
;
10792 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10793 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10794 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10795 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10797 digest
[0] = byte_swap_32 (digest
[0]);
10798 digest
[1] = byte_swap_32 (digest
[1]);
10799 digest
[2] = byte_swap_32 (digest
[2]);
10800 digest
[3] = byte_swap_32 (digest
[3]);
10802 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10804 uint digest_tmp
[2] = { 0 };
10806 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10807 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10809 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10810 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10812 /* special case 2: ESS */
10814 if (srvchall_len
== 48)
10816 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10818 uint w
[16] = { 0 };
10820 w
[ 0] = netntlm
->chall_buf
[6];
10821 w
[ 1] = netntlm
->chall_buf
[7];
10822 w
[ 2] = netntlm
->chall_buf
[0];
10823 w
[ 3] = netntlm
->chall_buf
[1];
10827 uint dgst
[4] = { 0 };
10836 salt
->salt_buf
[0] = dgst
[0];
10837 salt
->salt_buf
[1] = dgst
[1];
10841 /* precompute netntlmv1 exploit start */
10843 for (uint i
= 0; i
< 0x10000; i
++)
10845 uint key_md4
[2] = { i
, 0 };
10846 uint key_des
[2] = { 0, 0 };
10848 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10850 uint Kc
[16] = { 0 };
10851 uint Kd
[16] = { 0 };
10853 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10855 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10857 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10859 if (data3
[0] != digest_tmp
[0]) continue;
10860 if (data3
[1] != digest_tmp
[1]) continue;
10862 salt
->salt_buf
[2] = i
;
10864 salt
->salt_len
= 24;
10869 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10870 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10872 /* precompute netntlmv1 exploit stop */
10876 IP (digest
[0], digest
[1], tt
);
10877 IP (digest
[2], digest
[3], tt
);
10879 digest
[0] = rotr32 (digest
[0], 29);
10880 digest
[1] = rotr32 (digest
[1], 29);
10881 digest
[2] = rotr32 (digest
[2], 29);
10882 digest
[3] = rotr32 (digest
[3], 29);
10884 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10886 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10887 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10889 return (PARSER_OK
);
10892 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10894 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10896 u32
*digest
= (u32
*) hash_buf
->digest
;
10898 salt_t
*salt
= hash_buf
->salt
;
10900 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10906 char *user_pos
= input_buf
;
10908 char *unused_pos
= strchr (user_pos
, ':');
10910 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10912 uint user_len
= unused_pos
- user_pos
;
10914 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10918 char *domain_pos
= strchr (unused_pos
, ':');
10920 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10922 uint unused_len
= domain_pos
- unused_pos
;
10924 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10928 char *srvchall_pos
= strchr (domain_pos
, ':');
10930 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10932 uint domain_len
= srvchall_pos
- domain_pos
;
10934 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10938 char *hash_pos
= strchr (srvchall_pos
, ':');
10940 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10942 uint srvchall_len
= hash_pos
- srvchall_pos
;
10944 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10948 char *clichall_pos
= strchr (hash_pos
, ':');
10950 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10952 uint hash_len
= clichall_pos
- hash_pos
;
10954 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10958 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10960 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10962 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10965 * store some data for later use
10968 netntlm
->user_len
= user_len
* 2;
10969 netntlm
->domain_len
= domain_len
* 2;
10970 netntlm
->srvchall_len
= srvchall_len
/ 2;
10971 netntlm
->clichall_len
= clichall_len
/ 2;
10973 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10974 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10977 * handle username and domainname
10980 for (uint i
= 0; i
< user_len
; i
++)
10982 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10983 *userdomain_ptr
++ = 0;
10986 for (uint i
= 0; i
< domain_len
; i
++)
10988 *userdomain_ptr
++ = domain_pos
[i
];
10989 *userdomain_ptr
++ = 0;
10992 *userdomain_ptr
++ = 0x80;
10995 * handle server challenge encoding
10998 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11000 const char p0
= srvchall_pos
[i
+ 0];
11001 const char p1
= srvchall_pos
[i
+ 1];
11003 *chall_ptr
++ = hex_convert (p1
) << 0
11004 | hex_convert (p0
) << 4;
11008 * handle client challenge encoding
11011 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11013 const char p0
= clichall_pos
[i
+ 0];
11014 const char p1
= clichall_pos
[i
+ 1];
11016 *chall_ptr
++ = hex_convert (p1
) << 0
11017 | hex_convert (p0
) << 4;
11020 *chall_ptr
++ = 0x80;
11023 * handle hash itself
11026 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11027 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11028 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11029 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11031 digest
[0] = byte_swap_32 (digest
[0]);
11032 digest
[1] = byte_swap_32 (digest
[1]);
11033 digest
[2] = byte_swap_32 (digest
[2]);
11034 digest
[3] = byte_swap_32 (digest
[3]);
11037 * reuse challange data as salt_buf, its the buffer that is most likely unique
11040 salt
->salt_buf
[0] = 0;
11041 salt
->salt_buf
[1] = 0;
11042 salt
->salt_buf
[2] = 0;
11043 salt
->salt_buf
[3] = 0;
11044 salt
->salt_buf
[4] = 0;
11045 salt
->salt_buf
[5] = 0;
11046 salt
->salt_buf
[6] = 0;
11047 salt
->salt_buf
[7] = 0;
11051 uptr
= (uint
*) netntlm
->userdomain_buf
;
11053 for (uint i
= 0; i
< 16; i
+= 16)
11055 md5_64 (uptr
, salt
->salt_buf
);
11058 uptr
= (uint
*) netntlm
->chall_buf
;
11060 for (uint i
= 0; i
< 256; i
+= 16)
11062 md5_64 (uptr
, salt
->salt_buf
);
11065 salt
->salt_len
= 16;
11067 return (PARSER_OK
);
11070 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11072 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11074 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11078 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11081 u32
*digest
= (u32
*) hash_buf
->digest
;
11083 salt_t
*salt
= hash_buf
->salt
;
11085 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11086 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11087 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11088 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11090 digest
[0] = byte_swap_32 (digest
[0]);
11091 digest
[1] = byte_swap_32 (digest
[1]);
11092 digest
[2] = byte_swap_32 (digest
[2]);
11093 digest
[3] = byte_swap_32 (digest
[3]);
11095 digest
[0] -= MD5M_A
;
11096 digest
[1] -= MD5M_B
;
11097 digest
[2] -= MD5M_C
;
11098 digest
[3] -= MD5M_D
;
11100 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11102 uint salt_len
= input_len
- 32 - 1;
11104 char *salt_buf
= input_buf
+ 32 + 1;
11106 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11108 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11110 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11112 salt
->salt_len
= salt_len
;
11114 return (PARSER_OK
);
11117 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11119 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11121 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11125 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11128 u32
*digest
= (u32
*) hash_buf
->digest
;
11130 salt_t
*salt
= hash_buf
->salt
;
11132 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11133 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11134 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11135 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11137 digest
[0] = byte_swap_32 (digest
[0]);
11138 digest
[1] = byte_swap_32 (digest
[1]);
11139 digest
[2] = byte_swap_32 (digest
[2]);
11140 digest
[3] = byte_swap_32 (digest
[3]);
11142 digest
[0] -= MD5M_A
;
11143 digest
[1] -= MD5M_B
;
11144 digest
[2] -= MD5M_C
;
11145 digest
[3] -= MD5M_D
;
11147 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11149 uint salt_len
= input_len
- 32 - 1;
11151 char *salt_buf
= input_buf
+ 32 + 1;
11153 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11155 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11157 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11159 salt
->salt_len
= salt_len
;
11161 return (PARSER_OK
);
11164 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11166 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11168 u32
*digest
= (u32
*) hash_buf
->digest
;
11170 salt_t
*salt
= hash_buf
->salt
;
11172 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11173 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11174 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11175 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11177 digest
[0] = byte_swap_32 (digest
[0]);
11178 digest
[1] = byte_swap_32 (digest
[1]);
11179 digest
[2] = byte_swap_32 (digest
[2]);
11180 digest
[3] = byte_swap_32 (digest
[3]);
11182 digest
[0] -= MD5M_A
;
11183 digest
[1] -= MD5M_B
;
11184 digest
[2] -= MD5M_C
;
11185 digest
[3] -= MD5M_D
;
11188 * This is a virtual salt. While the algorithm is basically not salted
11189 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11190 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11193 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11195 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11197 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11199 salt
->salt_len
= salt_len
;
11201 return (PARSER_OK
);
11204 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11206 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11208 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11212 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11215 u32
*digest
= (u32
*) hash_buf
->digest
;
11217 salt_t
*salt
= hash_buf
->salt
;
11219 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11220 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11221 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11222 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11224 digest
[0] = byte_swap_32 (digest
[0]);
11225 digest
[1] = byte_swap_32 (digest
[1]);
11226 digest
[2] = byte_swap_32 (digest
[2]);
11227 digest
[3] = byte_swap_32 (digest
[3]);
11229 digest
[0] -= MD5M_A
;
11230 digest
[1] -= MD5M_B
;
11231 digest
[2] -= MD5M_C
;
11232 digest
[3] -= MD5M_D
;
11234 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11236 uint salt_len
= input_len
- 32 - 1;
11238 char *salt_buf
= input_buf
+ 32 + 1;
11240 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11242 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11244 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11246 salt
->salt_len
= salt_len
;
11248 return (PARSER_OK
);
11251 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11253 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11255 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11259 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11262 u32
*digest
= (u32
*) hash_buf
->digest
;
11264 salt_t
*salt
= hash_buf
->salt
;
11266 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11267 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11268 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11269 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11271 digest
[0] = byte_swap_32 (digest
[0]);
11272 digest
[1] = byte_swap_32 (digest
[1]);
11273 digest
[2] = byte_swap_32 (digest
[2]);
11274 digest
[3] = byte_swap_32 (digest
[3]);
11276 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11278 uint salt_len
= input_len
- 32 - 1;
11280 char *salt_buf
= input_buf
+ 32 + 1;
11282 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11284 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11286 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11288 salt
->salt_len
= salt_len
;
11290 return (PARSER_OK
);
11293 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11295 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11297 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11301 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11304 u32
*digest
= (u32
*) hash_buf
->digest
;
11306 salt_t
*salt
= hash_buf
->salt
;
11308 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11309 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11310 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11311 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11313 digest
[0] = byte_swap_32 (digest
[0]);
11314 digest
[1] = byte_swap_32 (digest
[1]);
11315 digest
[2] = byte_swap_32 (digest
[2]);
11316 digest
[3] = byte_swap_32 (digest
[3]);
11318 digest
[0] -= MD4M_A
;
11319 digest
[1] -= MD4M_B
;
11320 digest
[2] -= MD4M_C
;
11321 digest
[3] -= MD4M_D
;
11323 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11325 uint salt_len
= input_len
- 32 - 1;
11327 char *salt_buf
= input_buf
+ 32 + 1;
11329 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11331 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11333 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11335 salt
->salt_len
= salt_len
;
11337 return (PARSER_OK
);
11340 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11342 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11344 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11348 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11351 u32
*digest
= (u32
*) hash_buf
->digest
;
11353 salt_t
*salt
= hash_buf
->salt
;
11355 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11356 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11357 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11358 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11360 digest
[0] = byte_swap_32 (digest
[0]);
11361 digest
[1] = byte_swap_32 (digest
[1]);
11362 digest
[2] = byte_swap_32 (digest
[2]);
11363 digest
[3] = byte_swap_32 (digest
[3]);
11365 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11367 uint salt_len
= input_len
- 32 - 1;
11369 char *salt_buf
= input_buf
+ 32 + 1;
11371 uint salt_pc_block
[16] = { 0 };
11373 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11375 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11377 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11379 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11381 salt_pc_block
[14] = salt_len
* 8;
11383 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11385 md5_64 (salt_pc_block
, salt_pc_digest
);
11387 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11388 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11389 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11390 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11392 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11394 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11396 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11398 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11399 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11400 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11401 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11403 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11405 return (PARSER_OK
);
11408 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11410 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11412 u32
*digest
= (u32
*) hash_buf
->digest
;
11414 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11415 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11416 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11417 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11418 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11420 digest
[0] -= SHA1M_A
;
11421 digest
[1] -= SHA1M_B
;
11422 digest
[2] -= SHA1M_C
;
11423 digest
[3] -= SHA1M_D
;
11424 digest
[4] -= SHA1M_E
;
11426 return (PARSER_OK
);
11429 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11431 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11433 u32
*digest
= (u32
*) hash_buf
->digest
;
11435 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11436 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11437 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11438 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11439 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11441 return (PARSER_OK
);
11444 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11446 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11448 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11452 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11455 u32
*digest
= (u32
*) hash_buf
->digest
;
11457 salt_t
*salt
= hash_buf
->salt
;
11459 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11460 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11461 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11462 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11463 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11465 digest
[0] -= SHA1M_A
;
11466 digest
[1] -= SHA1M_B
;
11467 digest
[2] -= SHA1M_C
;
11468 digest
[3] -= SHA1M_D
;
11469 digest
[4] -= SHA1M_E
;
11471 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11473 uint salt_len
= input_len
- 40 - 1;
11475 char *salt_buf
= input_buf
+ 40 + 1;
11477 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11479 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11481 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11483 salt
->salt_len
= salt_len
;
11485 return (PARSER_OK
);
11488 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11490 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11492 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11494 u32
*digest
= (u32
*) hash_buf
->digest
;
11496 u8 tmp_buf
[100] = { 0 };
11498 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11500 memcpy (digest
, tmp_buf
, 20);
11502 digest
[0] = byte_swap_32 (digest
[0]);
11503 digest
[1] = byte_swap_32 (digest
[1]);
11504 digest
[2] = byte_swap_32 (digest
[2]);
11505 digest
[3] = byte_swap_32 (digest
[3]);
11506 digest
[4] = byte_swap_32 (digest
[4]);
11508 digest
[0] -= SHA1M_A
;
11509 digest
[1] -= SHA1M_B
;
11510 digest
[2] -= SHA1M_C
;
11511 digest
[3] -= SHA1M_D
;
11512 digest
[4] -= SHA1M_E
;
11514 return (PARSER_OK
);
11517 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11519 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11521 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11523 u32
*digest
= (u32
*) hash_buf
->digest
;
11525 salt_t
*salt
= hash_buf
->salt
;
11527 u8 tmp_buf
[100] = { 0 };
11529 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11531 memcpy (digest
, tmp_buf
, 20);
11533 salt
->salt_len
= tmp_len
- 20;
11535 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11537 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11539 char *ptr
= (char *) salt
->salt_buf
;
11541 ptr
[salt
->salt_len
] = 0x80;
11544 digest
[0] = byte_swap_32 (digest
[0]);
11545 digest
[1] = byte_swap_32 (digest
[1]);
11546 digest
[2] = byte_swap_32 (digest
[2]);
11547 digest
[3] = byte_swap_32 (digest
[3]);
11548 digest
[4] = byte_swap_32 (digest
[4]);
11550 digest
[0] -= SHA1M_A
;
11551 digest
[1] -= SHA1M_B
;
11552 digest
[2] -= SHA1M_C
;
11553 digest
[3] -= SHA1M_D
;
11554 digest
[4] -= SHA1M_E
;
11556 return (PARSER_OK
);
11559 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11561 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11563 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11565 u32
*digest
= (u32
*) hash_buf
->digest
;
11567 salt_t
*salt
= hash_buf
->salt
;
11569 char *salt_buf
= input_buf
+ 6;
11573 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11575 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11577 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11579 salt
->salt_len
= salt_len
;
11581 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11583 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11584 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11585 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11586 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11587 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11589 digest
[0] -= SHA1M_A
;
11590 digest
[1] -= SHA1M_B
;
11591 digest
[2] -= SHA1M_C
;
11592 digest
[3] -= SHA1M_D
;
11593 digest
[4] -= SHA1M_E
;
11595 return (PARSER_OK
);
11598 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11600 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11602 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11604 u32
*digest
= (u32
*) hash_buf
->digest
;
11606 salt_t
*salt
= hash_buf
->salt
;
11608 char *salt_buf
= input_buf
+ 6;
11612 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11614 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11616 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11618 salt
->salt_len
= salt_len
;
11620 char *hash_pos
= input_buf
+ 6 + 8;
11622 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11623 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11624 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11625 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11626 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11628 digest
[0] -= SHA1M_A
;
11629 digest
[1] -= SHA1M_B
;
11630 digest
[2] -= SHA1M_C
;
11631 digest
[3] -= SHA1M_D
;
11632 digest
[4] -= SHA1M_E
;
11634 return (PARSER_OK
);
11637 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11639 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11641 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11643 u64
*digest
= (u64
*) hash_buf
->digest
;
11645 salt_t
*salt
= hash_buf
->salt
;
11647 char *salt_buf
= input_buf
+ 6;
11651 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11653 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11655 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11657 salt
->salt_len
= salt_len
;
11659 char *hash_pos
= input_buf
+ 6 + 8;
11661 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11662 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11663 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11664 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11665 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11666 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11667 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11668 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11670 digest
[0] -= SHA512M_A
;
11671 digest
[1] -= SHA512M_B
;
11672 digest
[2] -= SHA512M_C
;
11673 digest
[3] -= SHA512M_D
;
11674 digest
[4] -= SHA512M_E
;
11675 digest
[5] -= SHA512M_F
;
11676 digest
[6] -= SHA512M_G
;
11677 digest
[7] -= SHA512M_H
;
11679 return (PARSER_OK
);
11682 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11684 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11686 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11690 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11693 u32
*digest
= (u32
*) hash_buf
->digest
;
11695 salt_t
*salt
= hash_buf
->salt
;
11697 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11698 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11702 digest
[0] = byte_swap_32 (digest
[0]);
11703 digest
[1] = byte_swap_32 (digest
[1]);
11705 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11707 uint salt_len
= input_len
- 16 - 1;
11709 char *salt_buf
= input_buf
+ 16 + 1;
11711 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11713 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11715 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11717 salt
->salt_len
= salt_len
;
11719 return (PARSER_OK
);
11722 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11724 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11726 u32
*digest
= (u32
*) hash_buf
->digest
;
11728 salt_t
*salt
= hash_buf
->salt
;
11730 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11731 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11732 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11733 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11734 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11736 digest
[0] -= SHA1M_A
;
11737 digest
[1] -= SHA1M_B
;
11738 digest
[2] -= SHA1M_C
;
11739 digest
[3] -= SHA1M_D
;
11740 digest
[4] -= SHA1M_E
;
11742 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11744 uint salt_len
= input_len
- 40 - 1;
11746 char *salt_buf
= input_buf
+ 40 + 1;
11748 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11750 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11752 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11754 salt
->salt_len
= salt_len
;
11756 return (PARSER_OK
);
11759 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11761 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11763 u32
*digest
= (u32
*) hash_buf
->digest
;
11765 salt_t
*salt
= hash_buf
->salt
;
11767 char *hash_pos
= input_buf
;
11769 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11770 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11771 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11772 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11773 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11774 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11775 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11776 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11777 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11778 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11779 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11780 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11781 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11782 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11783 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11784 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11786 char *salt_pos
= input_buf
+ 128;
11788 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11789 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11790 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11791 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11793 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11794 salt
->salt_len
= 16;
11796 return (PARSER_OK
);
11799 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11801 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11803 u32
*digest
= (u32
*) hash_buf
->digest
;
11805 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11806 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11807 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11808 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11809 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11810 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11811 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11812 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11814 digest
[0] -= SHA256M_A
;
11815 digest
[1] -= SHA256M_B
;
11816 digest
[2] -= SHA256M_C
;
11817 digest
[3] -= SHA256M_D
;
11818 digest
[4] -= SHA256M_E
;
11819 digest
[5] -= SHA256M_F
;
11820 digest
[6] -= SHA256M_G
;
11821 digest
[7] -= SHA256M_H
;
11823 return (PARSER_OK
);
11826 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11828 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11830 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11834 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11837 u32
*digest
= (u32
*) hash_buf
->digest
;
11839 salt_t
*salt
= hash_buf
->salt
;
11841 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11842 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11843 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11844 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11845 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11846 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11847 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11848 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11850 digest
[0] -= SHA256M_A
;
11851 digest
[1] -= SHA256M_B
;
11852 digest
[2] -= SHA256M_C
;
11853 digest
[3] -= SHA256M_D
;
11854 digest
[4] -= SHA256M_E
;
11855 digest
[5] -= SHA256M_F
;
11856 digest
[6] -= SHA256M_G
;
11857 digest
[7] -= SHA256M_H
;
11859 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11861 uint salt_len
= input_len
- 64 - 1;
11863 char *salt_buf
= input_buf
+ 64 + 1;
11865 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11867 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11869 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11871 salt
->salt_len
= salt_len
;
11873 return (PARSER_OK
);
11876 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11878 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11880 u64
*digest
= (u64
*) hash_buf
->digest
;
11882 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11883 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11884 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11885 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11886 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11887 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11891 digest
[0] -= SHA384M_A
;
11892 digest
[1] -= SHA384M_B
;
11893 digest
[2] -= SHA384M_C
;
11894 digest
[3] -= SHA384M_D
;
11895 digest
[4] -= SHA384M_E
;
11896 digest
[5] -= SHA384M_F
;
11900 return (PARSER_OK
);
11903 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11905 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11907 u64
*digest
= (u64
*) hash_buf
->digest
;
11909 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11910 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11911 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11912 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11913 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11914 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11915 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11916 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11918 digest
[0] -= SHA512M_A
;
11919 digest
[1] -= SHA512M_B
;
11920 digest
[2] -= SHA512M_C
;
11921 digest
[3] -= SHA512M_D
;
11922 digest
[4] -= SHA512M_E
;
11923 digest
[5] -= SHA512M_F
;
11924 digest
[6] -= SHA512M_G
;
11925 digest
[7] -= SHA512M_H
;
11927 return (PARSER_OK
);
11930 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11932 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11934 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11938 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11941 u64
*digest
= (u64
*) hash_buf
->digest
;
11943 salt_t
*salt
= hash_buf
->salt
;
11945 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11946 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11947 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11948 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11949 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11950 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11951 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11952 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11954 digest
[0] -= SHA512M_A
;
11955 digest
[1] -= SHA512M_B
;
11956 digest
[2] -= SHA512M_C
;
11957 digest
[3] -= SHA512M_D
;
11958 digest
[4] -= SHA512M_E
;
11959 digest
[5] -= SHA512M_F
;
11960 digest
[6] -= SHA512M_G
;
11961 digest
[7] -= SHA512M_H
;
11963 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11965 uint salt_len
= input_len
- 128 - 1;
11967 char *salt_buf
= input_buf
+ 128 + 1;
11969 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11971 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11973 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11975 salt
->salt_len
= salt_len
;
11977 return (PARSER_OK
);
11980 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11982 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11984 u64
*digest
= (u64
*) hash_buf
->digest
;
11986 salt_t
*salt
= hash_buf
->salt
;
11988 char *salt_pos
= input_buf
+ 3;
11990 uint iterations_len
= 0;
11992 if (memcmp (salt_pos
, "rounds=", 7) == 0)
11996 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
11998 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
11999 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12003 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12007 iterations_len
+= 8;
12011 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12014 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12016 char *hash_pos
= strchr (salt_pos
, '$');
12018 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12020 uint salt_len
= hash_pos
- salt_pos
;
12022 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12024 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12026 salt
->salt_len
= salt_len
;
12030 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12032 return (PARSER_OK
);
12035 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12037 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12039 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12041 u64
*digest
= (u64
*) hash_buf
->digest
;
12043 salt_t
*salt
= hash_buf
->salt
;
12045 uint keccak_mdlen
= input_len
/ 2;
12047 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12049 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12051 digest
[i
] = byte_swap_64 (digest
[i
]);
12054 salt
->keccak_mdlen
= keccak_mdlen
;
12056 return (PARSER_OK
);
12059 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12061 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12063 u32
*digest
= (u32
*) hash_buf
->digest
;
12065 salt_t
*salt
= hash_buf
->salt
;
12067 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12070 * Parse that strange long line
12075 size_t in_len
[9] = { 0 };
12077 in_off
[0] = strtok (input_buf
, ":");
12079 in_len
[0] = strlen (in_off
[0]);
12083 for (i
= 1; i
< 9; i
++)
12085 in_off
[i
] = strtok (NULL
, ":");
12087 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12089 in_len
[i
] = strlen (in_off
[i
]);
12092 char *ptr
= (char *) ikepsk
->msg_buf
;
12094 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12095 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12096 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12097 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12098 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12099 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12103 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12105 ptr
= (char *) ikepsk
->nr_buf
;
12107 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12108 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12112 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12115 * Store to database
12120 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12121 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12122 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12123 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12125 digest
[0] = byte_swap_32 (digest
[0]);
12126 digest
[1] = byte_swap_32 (digest
[1]);
12127 digest
[2] = byte_swap_32 (digest
[2]);
12128 digest
[3] = byte_swap_32 (digest
[3]);
12130 salt
->salt_len
= 32;
12132 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12133 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12134 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12135 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12136 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12137 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12138 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12139 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12141 return (PARSER_OK
);
12144 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12146 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12148 u32
*digest
= (u32
*) hash_buf
->digest
;
12150 salt_t
*salt
= hash_buf
->salt
;
12152 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12155 * Parse that strange long line
12160 size_t in_len
[9] = { 0 };
12162 in_off
[0] = strtok (input_buf
, ":");
12164 in_len
[0] = strlen (in_off
[0]);
12168 for (i
= 1; i
< 9; i
++)
12170 in_off
[i
] = strtok (NULL
, ":");
12172 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12174 in_len
[i
] = strlen (in_off
[i
]);
12177 char *ptr
= (char *) ikepsk
->msg_buf
;
12179 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12180 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12181 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12182 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12183 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12184 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12188 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12190 ptr
= (char *) ikepsk
->nr_buf
;
12192 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12193 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12197 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12200 * Store to database
12205 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12206 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12207 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12208 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12209 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12211 salt
->salt_len
= 32;
12213 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12214 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12215 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12216 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12217 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12218 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12219 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12220 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12222 return (PARSER_OK
);
12225 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12227 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12229 u32
*digest
= (u32
*) hash_buf
->digest
;
12231 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12232 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12233 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12234 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12235 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12237 digest
[0] = byte_swap_32 (digest
[0]);
12238 digest
[1] = byte_swap_32 (digest
[1]);
12239 digest
[2] = byte_swap_32 (digest
[2]);
12240 digest
[3] = byte_swap_32 (digest
[3]);
12241 digest
[4] = byte_swap_32 (digest
[4]);
12243 return (PARSER_OK
);
12246 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12248 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12250 u32
*digest
= (u32
*) hash_buf
->digest
;
12252 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12253 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12254 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12255 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12256 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12257 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12258 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12259 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12260 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12261 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12262 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12263 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12264 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12265 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12266 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12267 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12269 return (PARSER_OK
);
12272 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12274 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12276 u32
*digest
= (u32
*) hash_buf
->digest
;
12278 salt_t
*salt
= hash_buf
->salt
;
12280 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12281 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12282 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12283 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12284 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12286 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12288 uint salt_len
= input_len
- 40 - 1;
12290 char *salt_buf
= input_buf
+ 40 + 1;
12292 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12294 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12296 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12298 salt
->salt_len
= salt_len
;
12300 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12302 return (PARSER_OK
);
12305 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12307 u32
*digest
= (u32
*) hash_buf
->digest
;
12309 salt_t
*salt
= hash_buf
->salt
;
12311 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12313 if (input_len
== 0)
12315 log_error ("TrueCrypt container not specified");
12320 FILE *fp
= fopen (input_buf
, "rb");
12324 log_error ("%s: %s", input_buf
, strerror (errno
));
12329 char buf
[512] = { 0 };
12331 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12335 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12337 memcpy (tc
->salt_buf
, buf
, 64);
12339 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12341 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12343 salt
->salt_len
= 4;
12345 salt
->salt_iter
= 1000 - 1;
12347 digest
[0] = tc
->data_buf
[0];
12349 return (PARSER_OK
);
12352 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12354 u32
*digest
= (u32
*) hash_buf
->digest
;
12356 salt_t
*salt
= hash_buf
->salt
;
12358 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12360 if (input_len
== 0)
12362 log_error ("TrueCrypt container not specified");
12367 FILE *fp
= fopen (input_buf
, "rb");
12371 log_error ("%s: %s", input_buf
, strerror (errno
));
12376 char buf
[512] = { 0 };
12378 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12382 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12384 memcpy (tc
->salt_buf
, buf
, 64);
12386 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12388 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12390 salt
->salt_len
= 4;
12392 salt
->salt_iter
= 2000 - 1;
12394 digest
[0] = tc
->data_buf
[0];
12396 return (PARSER_OK
);
12399 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12401 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12403 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12405 u32
*digest
= (u32
*) hash_buf
->digest
;
12407 salt_t
*salt
= hash_buf
->salt
;
12409 char *salt_pos
= input_buf
+ 6;
12411 char *hash_pos
= strchr (salt_pos
, '$');
12413 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12415 uint salt_len
= hash_pos
- salt_pos
;
12417 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12419 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12421 salt
->salt_len
= salt_len
;
12423 salt
->salt_iter
= 1000;
12427 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12429 return (PARSER_OK
);
12432 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12434 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12436 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12438 u32
*digest
= (u32
*) hash_buf
->digest
;
12440 salt_t
*salt
= hash_buf
->salt
;
12442 char *iter_pos
= input_buf
+ 7;
12444 char *salt_pos
= strchr (iter_pos
, '$');
12446 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12450 char *hash_pos
= strchr (salt_pos
, '$');
12452 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12454 uint salt_len
= hash_pos
- salt_pos
;
12456 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12458 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12460 salt
->salt_len
= salt_len
;
12462 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12464 salt
->salt_sign
[0] = atoi (salt_iter
);
12466 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12470 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12472 digest
[0] = byte_swap_32 (digest
[0]);
12473 digest
[1] = byte_swap_32 (digest
[1]);
12474 digest
[2] = byte_swap_32 (digest
[2]);
12475 digest
[3] = byte_swap_32 (digest
[3]);
12476 digest
[4] = byte_swap_32 (digest
[4]);
12478 return (PARSER_OK
);
12481 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12483 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12485 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12487 u32
*digest
= (u32
*) hash_buf
->digest
;
12489 salt_t
*salt
= hash_buf
->salt
;
12491 char *iter_pos
= input_buf
+ 9;
12493 char *salt_pos
= strchr (iter_pos
, '$');
12495 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12499 char *hash_pos
= strchr (salt_pos
, '$');
12501 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12503 uint salt_len
= hash_pos
- salt_pos
;
12505 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12507 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12509 salt
->salt_len
= salt_len
;
12511 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12513 salt
->salt_sign
[0] = atoi (salt_iter
);
12515 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12519 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12521 digest
[0] = byte_swap_32 (digest
[0]);
12522 digest
[1] = byte_swap_32 (digest
[1]);
12523 digest
[2] = byte_swap_32 (digest
[2]);
12524 digest
[3] = byte_swap_32 (digest
[3]);
12525 digest
[4] = byte_swap_32 (digest
[4]);
12526 digest
[5] = byte_swap_32 (digest
[5]);
12527 digest
[6] = byte_swap_32 (digest
[6]);
12528 digest
[7] = byte_swap_32 (digest
[7]);
12530 return (PARSER_OK
);
12533 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12535 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12537 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12539 u64
*digest
= (u64
*) hash_buf
->digest
;
12541 salt_t
*salt
= hash_buf
->salt
;
12543 char *iter_pos
= input_buf
+ 9;
12545 char *salt_pos
= strchr (iter_pos
, '$');
12547 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12551 char *hash_pos
= strchr (salt_pos
, '$');
12553 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12555 uint salt_len
= hash_pos
- salt_pos
;
12557 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12559 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12561 salt
->salt_len
= salt_len
;
12563 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12565 salt
->salt_sign
[0] = atoi (salt_iter
);
12567 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12571 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12573 digest
[0] = byte_swap_64 (digest
[0]);
12574 digest
[1] = byte_swap_64 (digest
[1]);
12575 digest
[2] = byte_swap_64 (digest
[2]);
12576 digest
[3] = byte_swap_64 (digest
[3]);
12577 digest
[4] = byte_swap_64 (digest
[4]);
12578 digest
[5] = byte_swap_64 (digest
[5]);
12579 digest
[6] = byte_swap_64 (digest
[6]);
12580 digest
[7] = byte_swap_64 (digest
[7]);
12582 return (PARSER_OK
);
12585 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12587 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12589 u32
*digest
= (u32
*) hash_buf
->digest
;
12591 salt_t
*salt
= hash_buf
->salt
;
12593 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12599 char *iterations_pos
= input_buf
;
12601 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12603 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12605 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12607 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12611 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12613 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12615 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12617 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12619 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12621 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12626 * pbkdf2 iterations
12629 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12632 * handle salt encoding
12635 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12637 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12639 const char p0
= saltbuf_pos
[i
+ 0];
12640 const char p1
= saltbuf_pos
[i
+ 1];
12642 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12643 | hex_convert (p0
) << 4;
12646 salt
->salt_len
= saltbuf_len
/ 2;
12649 * handle cipher encoding
12652 uint
*tmp
= (uint
*) mymalloc (32);
12654 char *cipherbuf_ptr
= (char *) tmp
;
12656 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12658 const char p0
= cipherbuf_pos
[i
+ 0];
12659 const char p1
= cipherbuf_pos
[i
+ 1];
12661 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12662 | hex_convert (p0
) << 4;
12665 // iv is stored at salt_buf 4 (length 16)
12666 // data is stored at salt_buf 8 (length 16)
12668 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12669 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12670 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12671 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12673 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12674 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12675 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12676 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12680 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12682 const char p0
= cipherbuf_pos
[j
+ 0];
12683 const char p1
= cipherbuf_pos
[j
+ 1];
12685 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12686 | hex_convert (p0
) << 4;
12693 digest
[0] = 0x10101010;
12694 digest
[1] = 0x10101010;
12695 digest
[2] = 0x10101010;
12696 digest
[3] = 0x10101010;
12698 return (PARSER_OK
);
12701 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12703 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12705 u32
*digest
= (u32
*) hash_buf
->digest
;
12707 salt_t
*salt
= hash_buf
->salt
;
12709 char *hashbuf_pos
= input_buf
;
12711 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12713 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12715 uint hash_len
= iterations_pos
- hashbuf_pos
;
12717 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12721 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12723 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12725 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12729 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12731 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12733 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12735 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12737 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12739 salt
->salt_len
= salt_len
;
12741 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12743 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12744 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12745 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12746 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12748 return (PARSER_OK
);
12751 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12753 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12755 u32
*digest
= (u32
*) hash_buf
->digest
;
12757 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12758 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12759 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12760 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12761 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12762 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12763 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12764 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12766 digest
[0] = byte_swap_32 (digest
[0]);
12767 digest
[1] = byte_swap_32 (digest
[1]);
12768 digest
[2] = byte_swap_32 (digest
[2]);
12769 digest
[3] = byte_swap_32 (digest
[3]);
12770 digest
[4] = byte_swap_32 (digest
[4]);
12771 digest
[5] = byte_swap_32 (digest
[5]);
12772 digest
[6] = byte_swap_32 (digest
[6]);
12773 digest
[7] = byte_swap_32 (digest
[7]);
12775 return (PARSER_OK
);
12778 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12780 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12782 u32
*digest
= (u32
*) hash_buf
->digest
;
12784 salt_t
*salt
= hash_buf
->salt
;
12786 char *salt_pos
= input_buf
+ 3;
12788 uint iterations_len
= 0;
12790 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12794 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12796 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12797 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12801 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12805 iterations_len
+= 8;
12809 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12812 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12814 char *hash_pos
= strchr (salt_pos
, '$');
12816 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12818 uint salt_len
= hash_pos
- salt_pos
;
12820 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12822 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12824 salt
->salt_len
= salt_len
;
12828 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12830 return (PARSER_OK
);
12833 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12835 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12837 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12839 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12841 u64
*digest
= (u64
*) hash_buf
->digest
;
12843 salt_t
*salt
= hash_buf
->salt
;
12845 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12847 char *iter_pos
= input_buf
+ 4;
12849 char *salt_pos
= strchr (iter_pos
, '$');
12851 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12855 char *hash_pos
= strchr (salt_pos
, '$');
12857 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12859 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12863 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12864 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12865 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12866 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12867 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12868 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12869 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12870 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12872 uint salt_len
= hash_pos
- salt_pos
- 1;
12874 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12876 salt
->salt_len
= salt_len
/ 2;
12878 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12879 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12880 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12881 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12882 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12883 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12884 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12885 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12887 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12888 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12889 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12890 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12891 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12892 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12893 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12894 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12895 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12896 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12898 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12900 salt
->salt_iter
= atoi (iter_pos
) - 1;
12902 return (PARSER_OK
);
12905 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12907 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12909 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12911 u32
*digest
= (u32
*) hash_buf
->digest
;
12913 salt_t
*salt
= hash_buf
->salt
;
12915 char *salt_pos
= input_buf
+ 14;
12917 char *hash_pos
= strchr (salt_pos
, '*');
12919 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12923 uint salt_len
= hash_pos
- salt_pos
- 1;
12925 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12927 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12929 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12931 salt
->salt_len
= salt_len
;
12933 u8 tmp_buf
[100] = { 0 };
12935 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
12937 memcpy (digest
, tmp_buf
, 32);
12939 digest
[0] = byte_swap_32 (digest
[0]);
12940 digest
[1] = byte_swap_32 (digest
[1]);
12941 digest
[2] = byte_swap_32 (digest
[2]);
12942 digest
[3] = byte_swap_32 (digest
[3]);
12943 digest
[4] = byte_swap_32 (digest
[4]);
12944 digest
[5] = byte_swap_32 (digest
[5]);
12945 digest
[6] = byte_swap_32 (digest
[6]);
12946 digest
[7] = byte_swap_32 (digest
[7]);
12948 digest
[0] -= SHA256M_A
;
12949 digest
[1] -= SHA256M_B
;
12950 digest
[2] -= SHA256M_C
;
12951 digest
[3] -= SHA256M_D
;
12952 digest
[4] -= SHA256M_E
;
12953 digest
[5] -= SHA256M_F
;
12954 digest
[6] -= SHA256M_G
;
12955 digest
[7] -= SHA256M_H
;
12957 return (PARSER_OK
);
12960 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12962 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12964 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12966 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12968 u64
*digest
= (u64
*) hash_buf
->digest
;
12970 salt_t
*salt
= hash_buf
->salt
;
12972 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12974 char *iter_pos
= input_buf
+ 19;
12976 char *salt_pos
= strchr (iter_pos
, '.');
12978 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12982 char *hash_pos
= strchr (salt_pos
, '.');
12984 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12986 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12990 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12991 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12992 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12993 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12994 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12995 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12996 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12997 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12999 uint salt_len
= hash_pos
- salt_pos
- 1;
13003 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13007 for (i
= 0; i
< salt_len
; i
++)
13009 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13012 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13013 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13015 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13017 salt
->salt_len
= salt_len
;
13019 salt
->salt_iter
= atoi (iter_pos
) - 1;
13021 return (PARSER_OK
);
13024 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13026 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13028 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13030 u64
*digest
= (u64
*) hash_buf
->digest
;
13032 salt_t
*salt
= hash_buf
->salt
;
13034 u8 tmp_buf
[120] = { 0 };
13036 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13038 memcpy (digest
, tmp_buf
, 64);
13040 digest
[0] = byte_swap_64 (digest
[0]);
13041 digest
[1] = byte_swap_64 (digest
[1]);
13042 digest
[2] = byte_swap_64 (digest
[2]);
13043 digest
[3] = byte_swap_64 (digest
[3]);
13044 digest
[4] = byte_swap_64 (digest
[4]);
13045 digest
[5] = byte_swap_64 (digest
[5]);
13046 digest
[6] = byte_swap_64 (digest
[6]);
13047 digest
[7] = byte_swap_64 (digest
[7]);
13049 digest
[0] -= SHA512M_A
;
13050 digest
[1] -= SHA512M_B
;
13051 digest
[2] -= SHA512M_C
;
13052 digest
[3] -= SHA512M_D
;
13053 digest
[4] -= SHA512M_E
;
13054 digest
[5] -= SHA512M_F
;
13055 digest
[6] -= SHA512M_G
;
13056 digest
[7] -= SHA512M_H
;
13058 salt
->salt_len
= tmp_len
- 64;
13060 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13062 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13064 char *ptr
= (char *) salt
->salt_buf
;
13066 ptr
[salt
->salt_len
] = 0x80;
13069 return (PARSER_OK
);
13072 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13074 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13076 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13080 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13083 u32
*digest
= (u32
*) hash_buf
->digest
;
13085 salt_t
*salt
= hash_buf
->salt
;
13087 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13088 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13089 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13090 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13092 digest
[0] = byte_swap_32 (digest
[0]);
13093 digest
[1] = byte_swap_32 (digest
[1]);
13094 digest
[2] = byte_swap_32 (digest
[2]);
13095 digest
[3] = byte_swap_32 (digest
[3]);
13097 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13099 uint salt_len
= input_len
- 32 - 1;
13101 char *salt_buf
= input_buf
+ 32 + 1;
13103 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13105 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13107 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13109 salt
->salt_len
= salt_len
;
13111 return (PARSER_OK
);
13114 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13116 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13118 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13122 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13125 u32
*digest
= (u32
*) hash_buf
->digest
;
13127 salt_t
*salt
= hash_buf
->salt
;
13129 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13130 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13131 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13132 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13133 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13135 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13137 uint salt_len
= input_len
- 40 - 1;
13139 char *salt_buf
= input_buf
+ 40 + 1;
13141 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13143 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13145 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13147 salt
->salt_len
= salt_len
;
13149 return (PARSER_OK
);
13152 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13154 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13156 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13160 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13163 u32
*digest
= (u32
*) hash_buf
->digest
;
13165 salt_t
*salt
= hash_buf
->salt
;
13167 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13168 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13169 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13170 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13171 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13172 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13173 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13174 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13176 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13178 uint salt_len
= input_len
- 64 - 1;
13180 char *salt_buf
= input_buf
+ 64 + 1;
13182 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13184 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13186 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13188 salt
->salt_len
= salt_len
;
13190 return (PARSER_OK
);
13193 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13195 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13197 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13201 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13204 u64
*digest
= (u64
*) hash_buf
->digest
;
13206 salt_t
*salt
= hash_buf
->salt
;
13208 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13209 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13210 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13211 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13212 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13213 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13214 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13215 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13217 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13219 uint salt_len
= input_len
- 128 - 1;
13221 char *salt_buf
= input_buf
+ 128 + 1;
13223 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13225 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13227 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13229 salt
->salt_len
= salt_len
;
13231 return (PARSER_OK
);
13234 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13236 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13238 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13240 u32
*digest
= (u32
*) hash_buf
->digest
;
13242 salt_t
*salt
= hash_buf
->salt
;
13244 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13250 char *user_pos
= input_buf
+ 10 + 1;
13252 char *realm_pos
= strchr (user_pos
, '$');
13254 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13256 uint user_len
= realm_pos
- user_pos
;
13258 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13262 char *salt_pos
= strchr (realm_pos
, '$');
13264 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13266 uint realm_len
= salt_pos
- realm_pos
;
13268 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13272 char *data_pos
= strchr (salt_pos
, '$');
13274 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13276 uint salt_len
= data_pos
- salt_pos
;
13278 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13282 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13284 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13290 memcpy (krb5pa
->user
, user_pos
, user_len
);
13291 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13292 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13294 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13296 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13298 const char p0
= data_pos
[i
+ 0];
13299 const char p1
= data_pos
[i
+ 1];
13301 *timestamp_ptr
++ = hex_convert (p1
) << 0
13302 | hex_convert (p0
) << 4;
13305 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13307 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13309 const char p0
= data_pos
[i
+ 0];
13310 const char p1
= data_pos
[i
+ 1];
13312 *checksum_ptr
++ = hex_convert (p1
) << 0
13313 | hex_convert (p0
) << 4;
13317 * copy some data to generic buffers to make sorting happy
13320 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13321 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13322 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13323 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13324 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13325 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13326 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13327 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13328 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13330 salt
->salt_len
= 36;
13332 digest
[0] = krb5pa
->checksum
[0];
13333 digest
[1] = krb5pa
->checksum
[1];
13334 digest
[2] = krb5pa
->checksum
[2];
13335 digest
[3] = krb5pa
->checksum
[3];
13337 return (PARSER_OK
);
13340 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13342 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13344 u32
*digest
= (u32
*) hash_buf
->digest
;
13346 salt_t
*salt
= hash_buf
->salt
;
13352 char *salt_pos
= input_buf
;
13354 char *hash_pos
= strchr (salt_pos
, '$');
13356 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13358 uint salt_len
= hash_pos
- salt_pos
;
13360 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13364 uint hash_len
= input_len
- 1 - salt_len
;
13366 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13374 for (uint i
= 0; i
< salt_len
; i
++)
13376 if (salt_pos
[i
] == ' ') continue;
13381 // SAP user names cannot be longer than 12 characters
13382 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13384 // SAP user name cannot start with ! or ?
13385 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13391 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13393 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13395 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13397 salt
->salt_len
= salt_len
;
13399 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13400 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13404 digest
[0] = byte_swap_32 (digest
[0]);
13405 digest
[1] = byte_swap_32 (digest
[1]);
13407 return (PARSER_OK
);
13410 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13412 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13414 u32
*digest
= (u32
*) hash_buf
->digest
;
13416 salt_t
*salt
= hash_buf
->salt
;
13422 char *salt_pos
= input_buf
;
13424 char *hash_pos
= strchr (salt_pos
, '$');
13426 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13428 uint salt_len
= hash_pos
- salt_pos
;
13430 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13434 uint hash_len
= input_len
- 1 - salt_len
;
13436 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13444 for (uint i
= 0; i
< salt_len
; i
++)
13446 if (salt_pos
[i
] == ' ') continue;
13451 // SAP user names cannot be longer than 12 characters
13452 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13453 // so far nobody complained so we stay with this because it helps in optimization
13454 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13456 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13458 // SAP user name cannot start with ! or ?
13459 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13465 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13467 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13469 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13471 salt
->salt_len
= salt_len
;
13473 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13474 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13475 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13476 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13477 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13479 return (PARSER_OK
);
13482 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13484 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13486 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13488 u64
*digest
= (u64
*) hash_buf
->digest
;
13490 salt_t
*salt
= hash_buf
->salt
;
13492 char *iter_pos
= input_buf
+ 3;
13494 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13496 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13498 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13500 salt
->salt_iter
= salt_iter
;
13502 char *salt_pos
= iter_pos
+ 1;
13506 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13508 salt
->salt_len
= salt_len
;
13510 char *hash_pos
= salt_pos
+ salt_len
;
13512 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13516 char *tmp
= (char *) salt
->salt_buf_pc
;
13518 tmp
[0] = hash_pos
[42];
13522 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13523 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13524 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13525 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13531 return (PARSER_OK
);
13534 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13536 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13538 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13540 u32
*digest
= (u32
*) hash_buf
->digest
;
13542 salt_t
*salt
= hash_buf
->salt
;
13544 char *salt_buf
= input_buf
+ 6;
13546 uint salt_len
= 16;
13548 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13550 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13552 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13554 salt
->salt_len
= salt_len
;
13556 char *hash_pos
= input_buf
+ 6 + 16;
13558 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13559 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13560 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13561 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13562 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13563 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13564 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13565 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13567 return (PARSER_OK
);
13570 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13572 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13574 u32
*digest
= (u32
*) hash_buf
->digest
;
13576 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13577 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13581 return (PARSER_OK
);
13584 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13586 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13588 u32
*digest
= (u32
*) hash_buf
->digest
;
13590 salt_t
*salt
= hash_buf
->salt
;
13592 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13594 char *saltbuf_pos
= input_buf
;
13596 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13598 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13600 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13602 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13603 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13605 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13609 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13611 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13613 char *salt_ptr
= (char *) saltbuf_pos
;
13614 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13619 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13621 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13624 rakp_ptr
[j
] = 0x80;
13626 rakp
->salt_len
= j
;
13628 for (i
= 0; i
< 64; i
++)
13630 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13633 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13634 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13635 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13636 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13637 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13638 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13639 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13640 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13642 salt
->salt_len
= 32; // muss min. 32 haben
13644 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13645 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13646 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13647 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13648 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13650 return (PARSER_OK
);
13653 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13655 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13657 u32
*digest
= (u32
*) hash_buf
->digest
;
13659 salt_t
*salt
= hash_buf
->salt
;
13661 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13663 char *salt_pos
= input_buf
+ 1;
13665 memcpy (salt
->salt_buf
, salt_pos
, 8);
13667 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13668 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13670 salt
->salt_len
= 8;
13672 char *hash_pos
= salt_pos
+ 8;
13674 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13675 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13676 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13677 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13678 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13680 digest
[0] -= SHA1M_A
;
13681 digest
[1] -= SHA1M_B
;
13682 digest
[2] -= SHA1M_C
;
13683 digest
[3] -= SHA1M_D
;
13684 digest
[4] -= SHA1M_E
;
13686 return (PARSER_OK
);
13689 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13691 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13693 u32
*digest
= (u32
*) hash_buf
->digest
;
13695 salt_t
*salt
= hash_buf
->salt
;
13697 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13698 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13699 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13700 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13702 digest
[0] = byte_swap_32 (digest
[0]);
13703 digest
[1] = byte_swap_32 (digest
[1]);
13704 digest
[2] = byte_swap_32 (digest
[2]);
13705 digest
[3] = byte_swap_32 (digest
[3]);
13707 digest
[0] -= MD5M_A
;
13708 digest
[1] -= MD5M_B
;
13709 digest
[2] -= MD5M_C
;
13710 digest
[3] -= MD5M_D
;
13712 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13714 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13716 u32
*salt_buf
= salt
->salt_buf
;
13718 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13719 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13720 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13721 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13723 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13724 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13725 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13726 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13728 salt
->salt_len
= 16 + 1;
13730 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13732 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13734 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13736 return (PARSER_OK
);
13739 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13741 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13743 u32
*digest
= (u32
*) hash_buf
->digest
;
13745 salt_t
*salt
= hash_buf
->salt
;
13747 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13753 char *hashbuf_pos
= input_buf
;
13755 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13757 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13759 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13761 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13765 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13767 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13769 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13771 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13775 char *databuf_pos
= strchr (iteration_pos
, ':');
13777 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13779 const uint iteration_len
= databuf_pos
- iteration_pos
;
13781 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13782 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13784 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13786 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13787 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13793 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13794 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13795 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13796 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13797 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13798 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13799 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13800 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13804 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13806 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13808 const char p0
= saltbuf_pos
[i
+ 0];
13809 const char p1
= saltbuf_pos
[i
+ 1];
13811 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13812 | hex_convert (p0
) << 4;
13815 salt
->salt_buf
[4] = 0x01000000;
13816 salt
->salt_buf
[5] = 0x80;
13818 salt
->salt_len
= saltbuf_len
/ 2;
13822 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13826 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13828 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13830 const char p0
= databuf_pos
[i
+ 0];
13831 const char p1
= databuf_pos
[i
+ 1];
13833 *databuf_ptr
++ = hex_convert (p1
) << 0
13834 | hex_convert (p0
) << 4;
13837 *databuf_ptr
++ = 0x80;
13839 for (uint i
= 0; i
< 512; i
++)
13841 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13844 cloudkey
->data_len
= databuf_len
/ 2;
13846 return (PARSER_OK
);
13849 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13851 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13853 u32
*digest
= (u32
*) hash_buf
->digest
;
13855 salt_t
*salt
= hash_buf
->salt
;
13861 char *hashbuf_pos
= input_buf
;
13863 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13865 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13867 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13869 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13873 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13875 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13877 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13879 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13881 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13885 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13887 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13889 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13891 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13893 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13897 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13899 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13900 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13902 // ok, the plan for this algorithm is the following:
13903 // we have 2 salts here, the domain-name and a random salt
13904 // while both are used in the initial transformation,
13905 // only the random salt is used in the following iterations
13906 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13907 // and one that includes only the real salt (stored into salt_buf[]).
13908 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13910 u8 tmp_buf
[100] = { 0 };
13912 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
13914 memcpy (digest
, tmp_buf
, 20);
13916 digest
[0] = byte_swap_32 (digest
[0]);
13917 digest
[1] = byte_swap_32 (digest
[1]);
13918 digest
[2] = byte_swap_32 (digest
[2]);
13919 digest
[3] = byte_swap_32 (digest
[3]);
13920 digest
[4] = byte_swap_32 (digest
[4]);
13924 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13926 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13928 char *len_ptr
= NULL
;
13930 for (uint i
= 0; i
< domainbuf_len
; i
++)
13932 if (salt_buf_pc_ptr
[i
] == '.')
13934 len_ptr
= &salt_buf_pc_ptr
[i
];
13944 salt
->salt_buf_pc
[7] = domainbuf_len
;
13948 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13950 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13952 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13954 salt
->salt_len
= salt_len
;
13958 salt
->salt_iter
= atoi (iteration_pos
);
13960 return (PARSER_OK
);
13963 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13965 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13967 u32
*digest
= (u32
*) hash_buf
->digest
;
13969 salt_t
*salt
= hash_buf
->salt
;
13971 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13972 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13973 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13974 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13975 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13977 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13979 uint salt_len
= input_len
- 40 - 1;
13981 char *salt_buf
= input_buf
+ 40 + 1;
13983 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13985 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13987 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13989 salt
->salt_len
= salt_len
;
13991 return (PARSER_OK
);
13994 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13996 const u8 ascii_to_ebcdic
[] =
13998 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
13999 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14000 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14001 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14002 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14003 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14004 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14005 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14006 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14007 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14008 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14009 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14010 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14011 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14012 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14013 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14016 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14018 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14020 u32
*digest
= (u32
*) hash_buf
->digest
;
14022 salt_t
*salt
= hash_buf
->salt
;
14024 char *salt_pos
= input_buf
+ 6 + 1;
14026 char *digest_pos
= strchr (salt_pos
, '*');
14028 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14030 uint salt_len
= digest_pos
- salt_pos
;
14032 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14034 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14036 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14040 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14041 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14043 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14045 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14047 salt
->salt_len
= salt_len
;
14049 for (uint i
= 0; i
< salt_len
; i
++)
14051 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14053 for (uint i
= salt_len
; i
< 8; i
++)
14055 salt_buf_pc_ptr
[i
] = 0x40;
14060 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14062 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14063 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14065 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14066 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14068 digest
[0] = byte_swap_32 (digest
[0]);
14069 digest
[1] = byte_swap_32 (digest
[1]);
14071 IP (digest
[0], digest
[1], tt
);
14073 digest
[0] = rotr32 (digest
[0], 29);
14074 digest
[1] = rotr32 (digest
[1], 29);
14078 return (PARSER_OK
);
14081 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14083 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14085 u32
*digest
= (u32
*) hash_buf
->digest
;
14087 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14088 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14089 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14090 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14092 digest
[0] = byte_swap_32 (digest
[0]);
14093 digest
[1] = byte_swap_32 (digest
[1]);
14094 digest
[2] = byte_swap_32 (digest
[2]);
14095 digest
[3] = byte_swap_32 (digest
[3]);
14097 return (PARSER_OK
);
14100 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14102 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14104 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14106 u32
*digest
= (u32
*) hash_buf
->digest
;
14108 salt_t
*salt
= hash_buf
->salt
;
14110 u8 tmp_buf
[120] = { 0 };
14112 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14114 tmp_buf
[3] += -4; // dont ask!
14116 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14118 salt
->salt_len
= 5;
14120 memcpy (digest
, tmp_buf
+ 5, 9);
14122 // yes, only 9 byte are needed to crack, but 10 to display
14124 salt
->salt_buf_pc
[7] = input_buf
[20];
14126 return (PARSER_OK
);
14129 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14131 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14133 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14135 u32
*digest
= (u32
*) hash_buf
->digest
;
14137 salt_t
*salt
= hash_buf
->salt
;
14139 u8 tmp_buf
[120] = { 0 };
14141 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14143 tmp_buf
[3] += -4; // dont ask!
14147 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14149 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)
14153 char tmp_iter_buf
[11] = { 0 };
14155 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14157 tmp_iter_buf
[10] = 0;
14159 salt
->salt_iter
= atoi (tmp_iter_buf
);
14161 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14163 return (PARSER_SALT_ITERATION
);
14166 salt
->salt_iter
--; // first round in init
14168 // 2 additional bytes for display only
14170 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14171 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14175 memcpy (digest
, tmp_buf
+ 28, 8);
14177 digest
[0] = byte_swap_32 (digest
[0]);
14178 digest
[1] = byte_swap_32 (digest
[1]);
14182 return (PARSER_OK
);
14185 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14187 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14189 u32
*digest
= (u32
*) hash_buf
->digest
;
14191 salt_t
*salt
= hash_buf
->salt
;
14193 char *salt_buf_pos
= input_buf
;
14195 char *hash_buf_pos
= salt_buf_pos
+ 6;
14197 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14198 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14199 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14200 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14201 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14202 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14203 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14204 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14206 digest
[0] -= SHA256M_A
;
14207 digest
[1] -= SHA256M_B
;
14208 digest
[2] -= SHA256M_C
;
14209 digest
[3] -= SHA256M_D
;
14210 digest
[4] -= SHA256M_E
;
14211 digest
[5] -= SHA256M_F
;
14212 digest
[6] -= SHA256M_G
;
14213 digest
[7] -= SHA256M_H
;
14215 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14217 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14219 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14221 salt
->salt_len
= salt_len
;
14223 return (PARSER_OK
);
14226 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14228 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14230 u32
*digest
= (u32
*) hash_buf
->digest
;
14232 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14234 salt_t
*salt
= hash_buf
->salt
;
14236 char *salt_buf
= input_buf
+ 6;
14238 char *digest_buf
= strchr (salt_buf
, '$');
14240 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14242 uint salt_len
= digest_buf
- salt_buf
;
14244 digest_buf
++; // skip the '$' symbol
14246 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14248 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14250 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14252 salt
->salt_len
= salt_len
;
14254 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14255 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14256 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14257 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14259 digest
[0] = byte_swap_32 (digest
[0]);
14260 digest
[1] = byte_swap_32 (digest
[1]);
14261 digest
[2] = byte_swap_32 (digest
[2]);
14262 digest
[3] = byte_swap_32 (digest
[3]);
14264 digest
[0] -= MD5M_A
;
14265 digest
[1] -= MD5M_B
;
14266 digest
[2] -= MD5M_C
;
14267 digest
[3] -= MD5M_D
;
14269 return (PARSER_OK
);
14272 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14274 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14276 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14278 u32
*digest
= (u32
*) hash_buf
->digest
;
14280 salt_t
*salt
= hash_buf
->salt
;
14282 char *salt_buf
= input_buf
+ 3;
14284 char *digest_buf
= strchr (salt_buf
, '$');
14286 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14288 uint salt_len
= digest_buf
- salt_buf
;
14290 digest_buf
++; // skip the '$' symbol
14292 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14294 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14296 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14298 salt_buf_ptr
[salt_len
] = 0x2d;
14300 salt
->salt_len
= salt_len
+ 1;
14302 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14303 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14304 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14305 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14307 digest
[0] = byte_swap_32 (digest
[0]);
14308 digest
[1] = byte_swap_32 (digest
[1]);
14309 digest
[2] = byte_swap_32 (digest
[2]);
14310 digest
[3] = byte_swap_32 (digest
[3]);
14312 digest
[0] -= MD5M_A
;
14313 digest
[1] -= MD5M_B
;
14314 digest
[2] -= MD5M_C
;
14315 digest
[3] -= MD5M_D
;
14317 return (PARSER_OK
);
14320 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14322 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14324 u32
*digest
= (u32
*) hash_buf
->digest
;
14326 u8 tmp_buf
[100] = { 0 };
14328 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14330 memcpy (digest
, tmp_buf
, 20);
14332 digest
[0] = byte_swap_32 (digest
[0]);
14333 digest
[1] = byte_swap_32 (digest
[1]);
14334 digest
[2] = byte_swap_32 (digest
[2]);
14335 digest
[3] = byte_swap_32 (digest
[3]);
14336 digest
[4] = byte_swap_32 (digest
[4]);
14338 digest
[0] -= SHA1M_A
;
14339 digest
[1] -= SHA1M_B
;
14340 digest
[2] -= SHA1M_C
;
14341 digest
[3] -= SHA1M_D
;
14342 digest
[4] -= SHA1M_E
;
14344 return (PARSER_OK
);
14347 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14349 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14351 u32
*digest
= (u32
*) hash_buf
->digest
;
14353 salt_t
*salt
= hash_buf
->salt
;
14355 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14356 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14357 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14358 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14360 digest
[0] = byte_swap_32 (digest
[0]);
14361 digest
[1] = byte_swap_32 (digest
[1]);
14362 digest
[2] = byte_swap_32 (digest
[2]);
14363 digest
[3] = byte_swap_32 (digest
[3]);
14365 digest
[0] -= MD5M_A
;
14366 digest
[1] -= MD5M_B
;
14367 digest
[2] -= MD5M_C
;
14368 digest
[3] -= MD5M_D
;
14370 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14372 uint salt_len
= input_len
- 32 - 1;
14374 char *salt_buf
= input_buf
+ 32 + 1;
14376 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14378 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14380 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14383 * add static "salt" part
14386 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14390 salt
->salt_len
= salt_len
;
14392 return (PARSER_OK
);
14395 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14397 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14399 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14401 u32
*digest
= (u32
*) hash_buf
->digest
;
14403 salt_t
*salt
= hash_buf
->salt
;
14405 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14411 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14413 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14415 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14417 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14419 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14423 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14425 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14427 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14429 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14433 char *keybuf_pos
= strchr (keylen_pos
, '$');
14435 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14437 uint keylen_len
= keybuf_pos
- keylen_pos
;
14439 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14443 char *databuf_pos
= strchr (keybuf_pos
, '$');
14445 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14447 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14449 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14453 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14455 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14461 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14462 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14463 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14464 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14466 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14467 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14468 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14469 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14471 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14472 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14473 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14474 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14476 salt
->salt_len
= 16;
14477 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14479 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14481 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14484 return (PARSER_OK
);
14487 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14489 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14491 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14493 u32
*digest
= (u32
*) hash_buf
->digest
;
14495 salt_t
*salt
= hash_buf
->salt
;
14501 // first is the N salt parameter
14503 char *N_pos
= input_buf
+ 6;
14505 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14509 salt
->scrypt_N
= atoi (N_pos
);
14513 char *r_pos
= strchr (N_pos
, ':');
14515 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14519 salt
->scrypt_r
= atoi (r_pos
);
14523 char *p_pos
= strchr (r_pos
, ':');
14525 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14529 salt
->scrypt_p
= atoi (p_pos
);
14533 char *saltbuf_pos
= strchr (p_pos
, ':');
14535 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14539 char *hash_pos
= strchr (saltbuf_pos
, ':');
14541 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14547 u8 tmp_buf
[33] = { 0 };
14549 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14551 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14553 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14555 salt
->salt_len
= tmp_len
;
14556 salt
->salt_iter
= 1;
14558 // digest - base64 decode
14560 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14562 tmp_len
= input_len
- (hash_pos
- input_buf
);
14564 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14566 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14568 memcpy (digest
, tmp_buf
, 32);
14570 return (PARSER_OK
);
14573 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14575 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14577 u32
*digest
= (u32
*) hash_buf
->digest
;
14579 salt_t
*salt
= hash_buf
->salt
;
14585 char decrypted
[76] = { 0 }; // iv + hash
14587 juniper_decrypt_hash (input_buf
, decrypted
);
14589 char *md5crypt_hash
= decrypted
+ 12;
14591 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14593 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14595 char *salt_pos
= md5crypt_hash
+ 3;
14597 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14599 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14601 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14605 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14607 return (PARSER_OK
);
14610 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14612 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14614 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14616 u32
*digest
= (u32
*) hash_buf
->digest
;
14618 salt_t
*salt
= hash_buf
->salt
;
14620 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14626 // first is *raw* salt
14628 char *salt_pos
= input_buf
+ 3;
14630 char *hash_pos
= strchr (salt_pos
, '$');
14632 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14634 uint salt_len
= hash_pos
- salt_pos
;
14636 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14640 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14642 memcpy (salt_buf_ptr
, salt_pos
, 14);
14644 salt_buf_ptr
[17] = 0x01;
14645 salt_buf_ptr
[18] = 0x80;
14647 // add some stuff to normal salt to make sorted happy
14649 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14650 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14651 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14652 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14654 salt
->salt_len
= salt_len
;
14655 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14657 // base64 decode hash
14659 u8 tmp_buf
[100] = { 0 };
14661 uint hash_len
= input_len
- 3 - salt_len
- 1;
14663 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14665 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14667 memcpy (digest
, tmp_buf
, 32);
14669 digest
[0] = byte_swap_32 (digest
[0]);
14670 digest
[1] = byte_swap_32 (digest
[1]);
14671 digest
[2] = byte_swap_32 (digest
[2]);
14672 digest
[3] = byte_swap_32 (digest
[3]);
14673 digest
[4] = byte_swap_32 (digest
[4]);
14674 digest
[5] = byte_swap_32 (digest
[5]);
14675 digest
[6] = byte_swap_32 (digest
[6]);
14676 digest
[7] = byte_swap_32 (digest
[7]);
14678 return (PARSER_OK
);
14681 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14683 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14685 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14687 u32
*digest
= (u32
*) hash_buf
->digest
;
14689 salt_t
*salt
= hash_buf
->salt
;
14695 // first is *raw* salt
14697 char *salt_pos
= input_buf
+ 3;
14699 char *hash_pos
= strchr (salt_pos
, '$');
14701 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14703 uint salt_len
= hash_pos
- salt_pos
;
14705 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14707 salt
->salt_len
= salt_len
;
14710 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14712 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14713 salt_buf_ptr
[salt_len
] = 0;
14715 // base64 decode hash
14717 u8 tmp_buf
[100] = { 0 };
14719 uint hash_len
= input_len
- 3 - salt_len
- 1;
14721 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14723 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14725 memcpy (digest
, tmp_buf
, 32);
14728 salt
->scrypt_N
= 16384;
14729 salt
->scrypt_r
= 1;
14730 salt
->scrypt_p
= 1;
14731 salt
->salt_iter
= 1;
14733 return (PARSER_OK
);
14736 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14738 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14740 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14742 u32
*digest
= (u32
*) hash_buf
->digest
;
14744 salt_t
*salt
= hash_buf
->salt
;
14746 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14752 char *version_pos
= input_buf
+ 8 + 1;
14754 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14756 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14758 u32 version_len
= verifierHashSize_pos
- version_pos
;
14760 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14762 verifierHashSize_pos
++;
14764 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14766 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14768 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14770 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14774 char *saltSize_pos
= strchr (keySize_pos
, '*');
14776 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14778 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14780 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14784 char *osalt_pos
= strchr (saltSize_pos
, '*');
14786 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14788 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14790 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14794 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14796 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14798 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14800 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14802 encryptedVerifier_pos
++;
14804 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14806 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14808 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14810 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14812 encryptedVerifierHash_pos
++;
14814 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;
14816 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14818 const uint version
= atoi (version_pos
);
14820 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14822 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14824 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14826 const uint keySize
= atoi (keySize_pos
);
14828 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14830 office2007
->keySize
= keySize
;
14832 const uint saltSize
= atoi (saltSize_pos
);
14834 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14840 salt
->salt_len
= 16;
14841 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14843 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14844 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14845 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14846 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14852 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14853 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14854 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14855 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14857 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14858 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14859 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14860 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14861 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14867 digest
[0] = office2007
->encryptedVerifierHash
[0];
14868 digest
[1] = office2007
->encryptedVerifierHash
[1];
14869 digest
[2] = office2007
->encryptedVerifierHash
[2];
14870 digest
[3] = office2007
->encryptedVerifierHash
[3];
14872 return (PARSER_OK
);
14875 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14877 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14879 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14881 u32
*digest
= (u32
*) hash_buf
->digest
;
14883 salt_t
*salt
= hash_buf
->salt
;
14885 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14891 char *version_pos
= input_buf
+ 8 + 1;
14893 char *spinCount_pos
= strchr (version_pos
, '*');
14895 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14897 u32 version_len
= spinCount_pos
- version_pos
;
14899 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14903 char *keySize_pos
= strchr (spinCount_pos
, '*');
14905 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14907 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
14909 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14913 char *saltSize_pos
= strchr (keySize_pos
, '*');
14915 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14917 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14919 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14923 char *osalt_pos
= strchr (saltSize_pos
, '*');
14925 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14927 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14929 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14933 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14935 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14937 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14939 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14941 encryptedVerifier_pos
++;
14943 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14945 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14947 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14949 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14951 encryptedVerifierHash_pos
++;
14953 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;
14955 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14957 const uint version
= atoi (version_pos
);
14959 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14961 const uint spinCount
= atoi (spinCount_pos
);
14963 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14965 const uint keySize
= atoi (keySize_pos
);
14967 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14969 const uint saltSize
= atoi (saltSize_pos
);
14971 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14977 salt
->salt_len
= 16;
14978 salt
->salt_iter
= spinCount
;
14980 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14981 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14982 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14983 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14989 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14990 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14991 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14992 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14994 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14995 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14996 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14997 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14998 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14999 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15000 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15001 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15007 digest
[0] = office2010
->encryptedVerifierHash
[0];
15008 digest
[1] = office2010
->encryptedVerifierHash
[1];
15009 digest
[2] = office2010
->encryptedVerifierHash
[2];
15010 digest
[3] = office2010
->encryptedVerifierHash
[3];
15012 return (PARSER_OK
);
15015 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15017 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15019 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15021 u32
*digest
= (u32
*) hash_buf
->digest
;
15023 salt_t
*salt
= hash_buf
->salt
;
15025 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15031 char *version_pos
= input_buf
+ 8 + 1;
15033 char *spinCount_pos
= strchr (version_pos
, '*');
15035 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15037 u32 version_len
= spinCount_pos
- version_pos
;
15039 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15043 char *keySize_pos
= strchr (spinCount_pos
, '*');
15045 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15047 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15049 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15053 char *saltSize_pos
= strchr (keySize_pos
, '*');
15055 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15057 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15059 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15063 char *osalt_pos
= strchr (saltSize_pos
, '*');
15065 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15067 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15069 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15073 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15075 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15077 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15079 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15081 encryptedVerifier_pos
++;
15083 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15085 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15087 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15089 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15091 encryptedVerifierHash_pos
++;
15093 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;
15095 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15097 const uint version
= atoi (version_pos
);
15099 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15101 const uint spinCount
= atoi (spinCount_pos
);
15103 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15105 const uint keySize
= atoi (keySize_pos
);
15107 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15109 const uint saltSize
= atoi (saltSize_pos
);
15111 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15117 salt
->salt_len
= 16;
15118 salt
->salt_iter
= spinCount
;
15120 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15121 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15122 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15123 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15129 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15130 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15131 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15132 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15134 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15135 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15136 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15137 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15138 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15139 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15140 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15141 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15147 digest
[0] = office2013
->encryptedVerifierHash
[0];
15148 digest
[1] = office2013
->encryptedVerifierHash
[1];
15149 digest
[2] = office2013
->encryptedVerifierHash
[2];
15150 digest
[3] = office2013
->encryptedVerifierHash
[3];
15152 return (PARSER_OK
);
15155 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15157 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15159 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15161 u32
*digest
= (u32
*) hash_buf
->digest
;
15163 salt_t
*salt
= hash_buf
->salt
;
15165 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15171 char *version_pos
= input_buf
+ 11;
15173 char *osalt_pos
= strchr (version_pos
, '*');
15175 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15177 u32 version_len
= osalt_pos
- version_pos
;
15179 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15183 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15185 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15187 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15189 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15191 encryptedVerifier_pos
++;
15193 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15195 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15197 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15199 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15201 encryptedVerifierHash_pos
++;
15203 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15205 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15207 const uint version
= *version_pos
- 0x30;
15209 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15215 oldoffice01
->version
= version
;
15217 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15218 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15219 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15220 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15222 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15223 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15224 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15225 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15227 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15228 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15229 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15230 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15232 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15233 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15234 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15235 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15241 salt
->salt_len
= 16;
15243 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15244 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15245 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15246 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15248 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15249 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15250 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15251 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15253 // this is a workaround as office produces multiple documents with the same salt
15255 salt
->salt_len
+= 32;
15257 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15258 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15259 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15260 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15261 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15262 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15263 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15264 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15270 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15271 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15272 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15273 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15275 return (PARSER_OK
);
15278 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15280 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15283 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15285 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15287 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15289 u32
*digest
= (u32
*) hash_buf
->digest
;
15291 salt_t
*salt
= hash_buf
->salt
;
15293 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15299 char *version_pos
= input_buf
+ 11;
15301 char *osalt_pos
= strchr (version_pos
, '*');
15303 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15305 u32 version_len
= osalt_pos
- version_pos
;
15307 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15311 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15313 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15315 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15317 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15319 encryptedVerifier_pos
++;
15321 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15323 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15325 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15327 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15329 encryptedVerifierHash_pos
++;
15331 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15333 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15335 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15337 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15341 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15343 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15345 const uint version
= *version_pos
- 0x30;
15347 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15353 oldoffice01
->version
= version
;
15355 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15356 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15357 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15358 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15360 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15361 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15362 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15363 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15365 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15366 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15367 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15368 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15370 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15371 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15372 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15373 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15375 oldoffice01
->rc4key
[1] = 0;
15376 oldoffice01
->rc4key
[0] = 0;
15378 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15379 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15380 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15381 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15382 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15383 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15384 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15385 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15386 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15387 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15389 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15390 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15396 salt
->salt_len
= 16;
15398 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15399 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15400 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15401 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15403 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15404 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15405 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15406 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15408 // this is a workaround as office produces multiple documents with the same salt
15410 salt
->salt_len
+= 32;
15412 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15413 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15414 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15415 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15416 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15417 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15418 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15419 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15425 digest
[0] = oldoffice01
->rc4key
[0];
15426 digest
[1] = oldoffice01
->rc4key
[1];
15430 return (PARSER_OK
);
15433 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15435 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15437 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15439 u32
*digest
= (u32
*) hash_buf
->digest
;
15441 salt_t
*salt
= hash_buf
->salt
;
15443 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15449 char *version_pos
= input_buf
+ 11;
15451 char *osalt_pos
= strchr (version_pos
, '*');
15453 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15455 u32 version_len
= osalt_pos
- version_pos
;
15457 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15461 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15463 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15465 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15467 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15469 encryptedVerifier_pos
++;
15471 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15473 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15475 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15477 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15479 encryptedVerifierHash_pos
++;
15481 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15483 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15485 const uint version
= *version_pos
- 0x30;
15487 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15493 oldoffice34
->version
= version
;
15495 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15496 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15497 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15498 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15500 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15501 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15502 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15503 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15505 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15506 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15507 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15508 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15509 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15511 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15512 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15513 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15514 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15515 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15521 salt
->salt_len
= 16;
15523 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15524 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15525 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15526 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15528 // this is a workaround as office produces multiple documents with the same salt
15530 salt
->salt_len
+= 32;
15532 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15533 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15534 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15535 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15536 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15537 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15538 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15539 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15545 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15546 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15547 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15548 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15550 return (PARSER_OK
);
15553 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15555 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15557 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15560 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15562 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15564 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15566 u32
*digest
= (u32
*) hash_buf
->digest
;
15568 salt_t
*salt
= hash_buf
->salt
;
15570 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15576 char *version_pos
= input_buf
+ 11;
15578 char *osalt_pos
= strchr (version_pos
, '*');
15580 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15582 u32 version_len
= osalt_pos
- version_pos
;
15584 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15588 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15590 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15592 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15594 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15596 encryptedVerifier_pos
++;
15598 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15600 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15602 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15604 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15606 encryptedVerifierHash_pos
++;
15608 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15610 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15612 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15614 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15618 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15620 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15622 const uint version
= *version_pos
- 0x30;
15624 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15630 oldoffice34
->version
= version
;
15632 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15633 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15634 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15635 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15637 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15638 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15639 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15640 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15642 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15643 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15644 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15645 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15646 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15648 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15649 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15650 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15651 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15652 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15654 oldoffice34
->rc4key
[1] = 0;
15655 oldoffice34
->rc4key
[0] = 0;
15657 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15658 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15659 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15660 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15661 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15662 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15663 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15664 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15665 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15666 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15668 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15669 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15675 salt
->salt_len
= 16;
15677 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15678 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15679 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15680 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15682 // this is a workaround as office produces multiple documents with the same salt
15684 salt
->salt_len
+= 32;
15686 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15687 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15688 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15689 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15690 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15691 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15692 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15693 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15699 digest
[0] = oldoffice34
->rc4key
[0];
15700 digest
[1] = oldoffice34
->rc4key
[1];
15704 return (PARSER_OK
);
15707 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15709 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15711 u32
*digest
= (u32
*) hash_buf
->digest
;
15713 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15714 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15715 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15716 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15718 digest
[0] = byte_swap_32 (digest
[0]);
15719 digest
[1] = byte_swap_32 (digest
[1]);
15720 digest
[2] = byte_swap_32 (digest
[2]);
15721 digest
[3] = byte_swap_32 (digest
[3]);
15723 return (PARSER_OK
);
15726 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15728 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15730 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15732 u32
*digest
= (u32
*) hash_buf
->digest
;
15734 salt_t
*salt
= hash_buf
->salt
;
15736 char *signature_pos
= input_buf
;
15738 char *salt_pos
= strchr (signature_pos
, '$');
15740 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15742 u32 signature_len
= salt_pos
- signature_pos
;
15744 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15748 char *hash_pos
= strchr (salt_pos
, '$');
15750 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15752 u32 salt_len
= hash_pos
- salt_pos
;
15754 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15758 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15760 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15762 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15763 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15764 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15765 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15766 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15768 digest
[0] -= SHA1M_A
;
15769 digest
[1] -= SHA1M_B
;
15770 digest
[2] -= SHA1M_C
;
15771 digest
[3] -= SHA1M_D
;
15772 digest
[4] -= SHA1M_E
;
15774 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15776 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15778 salt
->salt_len
= salt_len
;
15780 return (PARSER_OK
);
15783 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15785 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15787 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15789 u32
*digest
= (u32
*) hash_buf
->digest
;
15791 salt_t
*salt
= hash_buf
->salt
;
15793 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15799 char *iter_pos
= input_buf
+ 14;
15801 const int iter
= atoi (iter_pos
);
15803 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15805 salt
->salt_iter
= iter
- 1;
15807 char *salt_pos
= strchr (iter_pos
, '$');
15809 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15813 char *hash_pos
= strchr (salt_pos
, '$');
15815 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15817 const uint salt_len
= hash_pos
- salt_pos
;
15821 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15823 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15825 salt
->salt_len
= salt_len
;
15827 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15828 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15830 // add some stuff to normal salt to make sorted happy
15832 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15833 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15834 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15835 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15836 salt
->salt_buf
[4] = salt
->salt_iter
;
15838 // base64 decode hash
15840 u8 tmp_buf
[100] = { 0 };
15842 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15844 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15846 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15848 memcpy (digest
, tmp_buf
, 32);
15850 digest
[0] = byte_swap_32 (digest
[0]);
15851 digest
[1] = byte_swap_32 (digest
[1]);
15852 digest
[2] = byte_swap_32 (digest
[2]);
15853 digest
[3] = byte_swap_32 (digest
[3]);
15854 digest
[4] = byte_swap_32 (digest
[4]);
15855 digest
[5] = byte_swap_32 (digest
[5]);
15856 digest
[6] = byte_swap_32 (digest
[6]);
15857 digest
[7] = byte_swap_32 (digest
[7]);
15859 return (PARSER_OK
);
15862 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15864 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15866 u32
*digest
= (u32
*) hash_buf
->digest
;
15868 salt_t
*salt
= hash_buf
->salt
;
15870 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15871 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15875 digest
[0] = byte_swap_32 (digest
[0]);
15876 digest
[1] = byte_swap_32 (digest
[1]);
15878 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15879 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15880 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15882 char iter_c
= input_buf
[17];
15883 char iter_d
= input_buf
[19];
15885 // atm only defaults, let's see if there's more request
15886 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15887 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15889 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15891 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15892 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15893 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15894 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15896 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15897 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15898 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15899 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15901 salt
->salt_len
= 16;
15903 return (PARSER_OK
);
15906 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15908 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15910 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15912 u32
*digest
= (u32
*) hash_buf
->digest
;
15914 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15916 salt_t
*salt
= hash_buf
->salt
;
15918 char *salt_pos
= input_buf
+ 10;
15920 char *hash_pos
= strchr (salt_pos
, '$');
15922 uint salt_len
= hash_pos
- salt_pos
;
15924 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15928 uint hash_len
= input_len
- 10 - salt_len
- 1;
15930 // base64 decode salt
15932 u8 tmp_buf
[100] = { 0 };
15934 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
15936 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15938 tmp_buf
[salt_len
] = 0x80;
15940 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15942 salt
->salt_len
= salt_len
;
15944 // base64 decode salt
15946 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15948 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15950 uint user_len
= hash_len
- 32;
15952 const u8
*tmp_hash
= tmp_buf
+ user_len
;
15954 user_len
--; // skip the trailing space
15956 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
15957 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
15958 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
15959 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
15961 digest
[0] = byte_swap_32 (digest
[0]);
15962 digest
[1] = byte_swap_32 (digest
[1]);
15963 digest
[2] = byte_swap_32 (digest
[2]);
15964 digest
[3] = byte_swap_32 (digest
[3]);
15966 // store username for host only (output hash if cracked)
15968 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15969 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15971 return (PARSER_OK
);
15974 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15976 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15978 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15980 u32
*digest
= (u32
*) hash_buf
->digest
;
15982 salt_t
*salt
= hash_buf
->salt
;
15984 char *iter_pos
= input_buf
+ 10;
15986 u32 iter
= atoi (iter_pos
);
15990 return (PARSER_SALT_ITERATION
);
15993 iter
--; // first iteration is special
15995 salt
->salt_iter
= iter
;
15997 char *base64_pos
= strchr (iter_pos
, '}');
15999 if (base64_pos
== NULL
)
16001 return (PARSER_SIGNATURE_UNMATCHED
);
16006 // base64 decode salt
16008 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16010 u8 tmp_buf
[100] = { 0 };
16012 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16014 if (decoded_len
< 24)
16016 return (PARSER_SALT_LENGTH
);
16021 uint salt_len
= decoded_len
- 20;
16023 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16024 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16026 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16028 salt
->salt_len
= salt_len
;
16032 u32
*digest_ptr
= (u32
*) tmp_buf
;
16034 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16035 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16036 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16037 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16038 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16040 return (PARSER_OK
);
16043 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16045 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16047 u32
*digest
= (u32
*) hash_buf
->digest
;
16049 salt_t
*salt
= hash_buf
->salt
;
16051 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16052 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16053 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16054 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16055 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16057 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16059 uint salt_len
= input_len
- 40 - 1;
16061 char *salt_buf
= input_buf
+ 40 + 1;
16063 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16065 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16067 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16069 salt
->salt_len
= salt_len
;
16071 return (PARSER_OK
);
16074 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16076 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16078 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16080 u32
*digest
= (u32
*) hash_buf
->digest
;
16082 salt_t
*salt
= hash_buf
->salt
;
16084 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16090 char *V_pos
= input_buf
+ 5;
16092 char *R_pos
= strchr (V_pos
, '*');
16094 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16096 u32 V_len
= R_pos
- V_pos
;
16100 char *bits_pos
= strchr (R_pos
, '*');
16102 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16104 u32 R_len
= bits_pos
- R_pos
;
16108 char *P_pos
= strchr (bits_pos
, '*');
16110 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16112 u32 bits_len
= P_pos
- bits_pos
;
16116 char *enc_md_pos
= strchr (P_pos
, '*');
16118 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16120 u32 P_len
= enc_md_pos
- P_pos
;
16124 char *id_len_pos
= strchr (enc_md_pos
, '*');
16126 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16128 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16132 char *id_buf_pos
= strchr (id_len_pos
, '*');
16134 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16136 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16140 char *u_len_pos
= strchr (id_buf_pos
, '*');
16142 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16144 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16146 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16150 char *u_buf_pos
= strchr (u_len_pos
, '*');
16152 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16154 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16158 char *o_len_pos
= strchr (u_buf_pos
, '*');
16160 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16162 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16164 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16168 char *o_buf_pos
= strchr (o_len_pos
, '*');
16170 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16172 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16176 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;
16178 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16182 const int V
= atoi (V_pos
);
16183 const int R
= atoi (R_pos
);
16184 const int P
= atoi (P_pos
);
16186 if (V
!= 1) return (PARSER_SALT_VALUE
);
16187 if (R
!= 2) return (PARSER_SALT_VALUE
);
16189 const int enc_md
= atoi (enc_md_pos
);
16191 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16193 const int id_len
= atoi (id_len_pos
);
16194 const int u_len
= atoi (u_len_pos
);
16195 const int o_len
= atoi (o_len_pos
);
16197 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16198 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16199 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16201 const int bits
= atoi (bits_pos
);
16203 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16205 // copy data to esalt
16211 pdf
->enc_md
= enc_md
;
16213 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16214 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16215 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16216 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16217 pdf
->id_len
= id_len
;
16219 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16220 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16221 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16222 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16223 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16224 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16225 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16226 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16227 pdf
->u_len
= u_len
;
16229 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16230 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16231 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16232 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16233 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16234 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16235 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16236 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16237 pdf
->o_len
= o_len
;
16239 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16240 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16241 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16242 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16244 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16245 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16246 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16247 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16248 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16249 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16250 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16251 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16253 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16254 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16255 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16256 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16257 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16258 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16259 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16260 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16262 // we use ID for salt, maybe needs to change, we will see...
16264 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16265 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16266 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16267 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16268 salt
->salt_len
= pdf
->id_len
;
16270 digest
[0] = pdf
->u_buf
[0];
16271 digest
[1] = pdf
->u_buf
[1];
16272 digest
[2] = pdf
->u_buf
[2];
16273 digest
[3] = pdf
->u_buf
[3];
16275 return (PARSER_OK
);
16278 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16280 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16283 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16285 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16287 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16289 u32
*digest
= (u32
*) hash_buf
->digest
;
16291 salt_t
*salt
= hash_buf
->salt
;
16293 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16299 char *V_pos
= input_buf
+ 5;
16301 char *R_pos
= strchr (V_pos
, '*');
16303 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16305 u32 V_len
= R_pos
- V_pos
;
16309 char *bits_pos
= strchr (R_pos
, '*');
16311 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16313 u32 R_len
= bits_pos
- R_pos
;
16317 char *P_pos
= strchr (bits_pos
, '*');
16319 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16321 u32 bits_len
= P_pos
- bits_pos
;
16325 char *enc_md_pos
= strchr (P_pos
, '*');
16327 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16329 u32 P_len
= enc_md_pos
- P_pos
;
16333 char *id_len_pos
= strchr (enc_md_pos
, '*');
16335 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16337 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16341 char *id_buf_pos
= strchr (id_len_pos
, '*');
16343 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16345 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16349 char *u_len_pos
= strchr (id_buf_pos
, '*');
16351 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16353 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16355 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16359 char *u_buf_pos
= strchr (u_len_pos
, '*');
16361 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16363 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16367 char *o_len_pos
= strchr (u_buf_pos
, '*');
16369 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16371 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16373 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16377 char *o_buf_pos
= strchr (o_len_pos
, '*');
16379 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16381 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16385 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16387 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16389 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16391 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16395 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;
16397 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16401 const int V
= atoi (V_pos
);
16402 const int R
= atoi (R_pos
);
16403 const int P
= atoi (P_pos
);
16405 if (V
!= 1) return (PARSER_SALT_VALUE
);
16406 if (R
!= 2) return (PARSER_SALT_VALUE
);
16408 const int enc_md
= atoi (enc_md_pos
);
16410 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16412 const int id_len
= atoi (id_len_pos
);
16413 const int u_len
= atoi (u_len_pos
);
16414 const int o_len
= atoi (o_len_pos
);
16416 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16417 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16418 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16420 const int bits
= atoi (bits_pos
);
16422 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16424 // copy data to esalt
16430 pdf
->enc_md
= enc_md
;
16432 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16433 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16434 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16435 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16436 pdf
->id_len
= id_len
;
16438 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16439 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16440 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16441 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16442 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16443 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16444 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16445 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16446 pdf
->u_len
= u_len
;
16448 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16449 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16450 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16451 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16452 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16453 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16454 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16455 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16456 pdf
->o_len
= o_len
;
16458 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16459 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16460 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16461 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16463 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16464 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16465 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16466 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16467 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16468 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16469 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16470 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16472 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16473 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16474 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16475 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16476 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16477 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16478 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16479 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16481 pdf
->rc4key
[1] = 0;
16482 pdf
->rc4key
[0] = 0;
16484 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16485 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16486 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16487 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16488 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16489 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16490 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16491 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16492 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16493 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16495 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16496 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16498 // we use ID for salt, maybe needs to change, we will see...
16500 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16501 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16502 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16503 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16504 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16505 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16506 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16507 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16508 salt
->salt_len
= pdf
->id_len
+ 16;
16510 digest
[0] = pdf
->rc4key
[0];
16511 digest
[1] = pdf
->rc4key
[1];
16515 return (PARSER_OK
);
16518 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16520 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16522 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16524 u32
*digest
= (u32
*) hash_buf
->digest
;
16526 salt_t
*salt
= hash_buf
->salt
;
16528 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16534 char *V_pos
= input_buf
+ 5;
16536 char *R_pos
= strchr (V_pos
, '*');
16538 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16540 u32 V_len
= R_pos
- V_pos
;
16544 char *bits_pos
= strchr (R_pos
, '*');
16546 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16548 u32 R_len
= bits_pos
- R_pos
;
16552 char *P_pos
= strchr (bits_pos
, '*');
16554 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16556 u32 bits_len
= P_pos
- bits_pos
;
16560 char *enc_md_pos
= strchr (P_pos
, '*');
16562 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16564 u32 P_len
= enc_md_pos
- P_pos
;
16568 char *id_len_pos
= strchr (enc_md_pos
, '*');
16570 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16572 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16576 char *id_buf_pos
= strchr (id_len_pos
, '*');
16578 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16580 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16584 char *u_len_pos
= strchr (id_buf_pos
, '*');
16586 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16588 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16590 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16594 char *u_buf_pos
= strchr (u_len_pos
, '*');
16596 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16598 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16602 char *o_len_pos
= strchr (u_buf_pos
, '*');
16604 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16606 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16608 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16612 char *o_buf_pos
= strchr (o_len_pos
, '*');
16614 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16616 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16620 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;
16622 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16626 const int V
= atoi (V_pos
);
16627 const int R
= atoi (R_pos
);
16628 const int P
= atoi (P_pos
);
16632 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16633 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16635 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16637 const int id_len
= atoi (id_len_pos
);
16638 const int u_len
= atoi (u_len_pos
);
16639 const int o_len
= atoi (o_len_pos
);
16641 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16643 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16644 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16646 const int bits
= atoi (bits_pos
);
16648 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16654 enc_md
= atoi (enc_md_pos
);
16657 // copy data to esalt
16663 pdf
->enc_md
= enc_md
;
16665 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16666 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16667 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16668 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16672 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16673 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16674 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16675 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16678 pdf
->id_len
= id_len
;
16680 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16681 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16682 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16683 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16684 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16685 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16686 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16687 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16688 pdf
->u_len
= u_len
;
16690 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16691 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16692 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16693 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16694 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16695 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16696 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16697 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16698 pdf
->o_len
= o_len
;
16700 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16701 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16702 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16703 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16707 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16708 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16709 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16710 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16713 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16714 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16715 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16716 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16717 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16718 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16719 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16720 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16722 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16723 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16724 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16725 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16726 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16727 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16728 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16729 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16731 // precompute rc4 data for later use
16747 uint salt_pc_block
[32] = { 0 };
16749 char *salt_pc_ptr
= (char *) salt_pc_block
;
16751 memcpy (salt_pc_ptr
, padding
, 32);
16752 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16754 uint salt_pc_digest
[4] = { 0 };
16756 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16758 pdf
->rc4data
[0] = salt_pc_digest
[0];
16759 pdf
->rc4data
[1] = salt_pc_digest
[1];
16761 // we use ID for salt, maybe needs to change, we will see...
16763 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16764 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16765 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16766 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16767 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16768 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16769 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16770 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16771 salt
->salt_len
= pdf
->id_len
+ 16;
16773 salt
->salt_iter
= ROUNDS_PDF14
;
16775 digest
[0] = pdf
->u_buf
[0];
16776 digest
[1] = pdf
->u_buf
[1];
16780 return (PARSER_OK
);
16783 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16785 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16787 if (ret
!= PARSER_OK
)
16792 u32
*digest
= (u32
*) hash_buf
->digest
;
16794 salt_t
*salt
= hash_buf
->salt
;
16796 digest
[0] -= SHA256M_A
;
16797 digest
[1] -= SHA256M_B
;
16798 digest
[2] -= SHA256M_C
;
16799 digest
[3] -= SHA256M_D
;
16800 digest
[4] -= SHA256M_E
;
16801 digest
[5] -= SHA256M_F
;
16802 digest
[6] -= SHA256M_G
;
16803 digest
[7] -= SHA256M_H
;
16805 salt
->salt_buf
[2] = 0x80;
16807 return (PARSER_OK
);
16810 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16812 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16814 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16816 u32
*digest
= (u32
*) hash_buf
->digest
;
16818 salt_t
*salt
= hash_buf
->salt
;
16820 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16826 char *V_pos
= input_buf
+ 5;
16828 char *R_pos
= strchr (V_pos
, '*');
16830 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16832 u32 V_len
= R_pos
- V_pos
;
16836 char *bits_pos
= strchr (R_pos
, '*');
16838 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16840 u32 R_len
= bits_pos
- R_pos
;
16844 char *P_pos
= strchr (bits_pos
, '*');
16846 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16848 u32 bits_len
= P_pos
- bits_pos
;
16852 char *enc_md_pos
= strchr (P_pos
, '*');
16854 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16856 u32 P_len
= enc_md_pos
- P_pos
;
16860 char *id_len_pos
= strchr (enc_md_pos
, '*');
16862 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16864 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16868 char *id_buf_pos
= strchr (id_len_pos
, '*');
16870 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16872 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16876 char *u_len_pos
= strchr (id_buf_pos
, '*');
16878 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16880 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16884 char *u_buf_pos
= strchr (u_len_pos
, '*');
16886 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16888 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16892 char *o_len_pos
= strchr (u_buf_pos
, '*');
16894 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16896 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16900 char *o_buf_pos
= strchr (o_len_pos
, '*');
16902 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16904 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16908 char *last
= strchr (o_buf_pos
, '*');
16910 if (last
== NULL
) last
= input_buf
+ input_len
;
16912 u32 o_buf_len
= last
- o_buf_pos
;
16916 const int V
= atoi (V_pos
);
16917 const int R
= atoi (R_pos
);
16921 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16922 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16924 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16926 const int bits
= atoi (bits_pos
);
16928 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16930 int enc_md
= atoi (enc_md_pos
);
16932 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16934 const uint id_len
= atoi (id_len_pos
);
16935 const uint u_len
= atoi (u_len_pos
);
16936 const uint o_len
= atoi (o_len_pos
);
16938 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16939 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16940 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16941 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16942 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16943 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16944 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16945 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16947 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16948 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16949 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16951 // copy data to esalt
16953 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16955 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16957 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
16960 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16961 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16963 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16964 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16966 salt
->salt_len
= 8;
16967 salt
->salt_iter
= ROUNDS_PDF17L8
;
16969 digest
[0] = pdf
->u_buf
[0];
16970 digest
[1] = pdf
->u_buf
[1];
16971 digest
[2] = pdf
->u_buf
[2];
16972 digest
[3] = pdf
->u_buf
[3];
16973 digest
[4] = pdf
->u_buf
[4];
16974 digest
[5] = pdf
->u_buf
[5];
16975 digest
[6] = pdf
->u_buf
[6];
16976 digest
[7] = pdf
->u_buf
[7];
16978 return (PARSER_OK
);
16981 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16983 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
16985 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
16987 u32
*digest
= (u32
*) hash_buf
->digest
;
16989 salt_t
*salt
= hash_buf
->salt
;
16991 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16999 char *iter_pos
= input_buf
+ 7;
17001 u32 iter
= atoi (iter_pos
);
17003 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17004 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17006 // first is *raw* salt
17008 char *salt_pos
= strchr (iter_pos
, ':');
17010 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17014 char *hash_pos
= strchr (salt_pos
, ':');
17016 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17018 u32 salt_len
= hash_pos
- salt_pos
;
17020 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17024 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17026 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17030 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17032 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17034 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17036 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17037 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17039 salt
->salt_len
= salt_len
;
17040 salt
->salt_iter
= iter
- 1;
17044 u8 tmp_buf
[100] = { 0 };
17046 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17048 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17050 memcpy (digest
, tmp_buf
, 16);
17052 digest
[0] = byte_swap_32 (digest
[0]);
17053 digest
[1] = byte_swap_32 (digest
[1]);
17054 digest
[2] = byte_swap_32 (digest
[2]);
17055 digest
[3] = byte_swap_32 (digest
[3]);
17057 // add some stuff to normal salt to make sorted happy
17059 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17060 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17061 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17062 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17063 salt
->salt_buf
[4] = salt
->salt_iter
;
17065 return (PARSER_OK
);
17068 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17070 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17072 u32
*digest
= (u32
*) hash_buf
->digest
;
17074 salt_t
*salt
= hash_buf
->salt
;
17076 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17077 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17078 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17079 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17081 digest
[0] = byte_swap_32 (digest
[0]);
17082 digest
[1] = byte_swap_32 (digest
[1]);
17083 digest
[2] = byte_swap_32 (digest
[2]);
17084 digest
[3] = byte_swap_32 (digest
[3]);
17086 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17088 uint salt_len
= input_len
- 32 - 1;
17090 char *salt_buf
= input_buf
+ 32 + 1;
17092 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17094 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17096 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17098 salt
->salt_len
= salt_len
;
17100 return (PARSER_OK
);
17103 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17105 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17107 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17109 u32
*digest
= (u32
*) hash_buf
->digest
;
17111 salt_t
*salt
= hash_buf
->salt
;
17113 char *user_pos
= input_buf
+ 10;
17115 char *salt_pos
= strchr (user_pos
, '*');
17117 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17121 char *hash_pos
= strchr (salt_pos
, '*');
17125 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17127 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17129 uint user_len
= salt_pos
- user_pos
- 1;
17131 uint salt_len
= hash_pos
- salt_pos
- 1;
17133 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17139 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17140 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17141 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17142 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17144 digest
[0] = byte_swap_32 (digest
[0]);
17145 digest
[1] = byte_swap_32 (digest
[1]);
17146 digest
[2] = byte_swap_32 (digest
[2]);
17147 digest
[3] = byte_swap_32 (digest
[3]);
17149 digest
[0] -= MD5M_A
;
17150 digest
[1] -= MD5M_B
;
17151 digest
[2] -= MD5M_C
;
17152 digest
[3] -= MD5M_D
;
17158 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17160 // first 4 bytes are the "challenge"
17162 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17163 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17164 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17165 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17167 // append the user name
17169 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17171 salt
->salt_len
= 4 + user_len
;
17173 return (PARSER_OK
);
17176 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17178 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17180 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17182 u32
*digest
= (u32
*) hash_buf
->digest
;
17184 salt_t
*salt
= hash_buf
->salt
;
17186 char *salt_pos
= input_buf
+ 9;
17188 char *hash_pos
= strchr (salt_pos
, '*');
17190 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17194 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17196 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17198 uint salt_len
= hash_pos
- salt_pos
- 1;
17200 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17206 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17207 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17208 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17209 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17210 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17216 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17218 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17220 salt
->salt_len
= salt_len
;
17222 return (PARSER_OK
);
17225 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17227 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17229 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17231 u32
*digest
= (u32
*) hash_buf
->digest
;
17233 salt_t
*salt
= hash_buf
->salt
;
17235 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17241 char *cry_master_len_pos
= input_buf
+ 9;
17243 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17245 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17247 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17249 cry_master_buf_pos
++;
17251 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17253 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17255 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17257 cry_salt_len_pos
++;
17259 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17261 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17263 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17265 cry_salt_buf_pos
++;
17267 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17269 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17271 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17275 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17277 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17279 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17283 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17285 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17287 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17291 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17293 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17295 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17297 public_key_len_pos
++;
17299 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17301 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17303 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17305 public_key_buf_pos
++;
17307 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;
17309 const uint cry_master_len
= atoi (cry_master_len_pos
);
17310 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17311 const uint ckey_len
= atoi (ckey_len_pos
);
17312 const uint public_key_len
= atoi (public_key_len_pos
);
17314 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17315 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17316 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17317 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17319 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17321 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17323 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17326 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17328 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17330 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17333 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17335 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17337 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17340 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17341 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17342 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17345 * store digest (should be unique enought, hopefully)
17348 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17349 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17350 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17351 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17357 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17359 const uint cry_rounds
= atoi (cry_rounds_pos
);
17361 salt
->salt_iter
= cry_rounds
- 1;
17363 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17365 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17367 salt
->salt_len
= salt_len
;
17369 return (PARSER_OK
);
17372 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17374 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17376 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17378 u32
*digest
= (u32
*) hash_buf
->digest
;
17380 salt_t
*salt
= hash_buf
->salt
;
17382 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17384 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17386 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17388 memcpy (temp_input_buf
, input_buf
, input_len
);
17392 char *URI_server_pos
= temp_input_buf
+ 6;
17394 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17396 if (URI_client_pos
== NULL
)
17398 myfree (temp_input_buf
);
17400 return (PARSER_SEPARATOR_UNMATCHED
);
17403 URI_client_pos
[0] = 0;
17406 uint URI_server_len
= strlen (URI_server_pos
);
17408 if (URI_server_len
> 512)
17410 myfree (temp_input_buf
);
17412 return (PARSER_SALT_LENGTH
);
17417 char *user_pos
= strchr (URI_client_pos
, '*');
17419 if (user_pos
== NULL
)
17421 myfree (temp_input_buf
);
17423 return (PARSER_SEPARATOR_UNMATCHED
);
17429 uint URI_client_len
= strlen (URI_client_pos
);
17431 if (URI_client_len
> 512)
17433 myfree (temp_input_buf
);
17435 return (PARSER_SALT_LENGTH
);
17440 char *realm_pos
= strchr (user_pos
, '*');
17442 if (realm_pos
== NULL
)
17444 myfree (temp_input_buf
);
17446 return (PARSER_SEPARATOR_UNMATCHED
);
17452 uint user_len
= strlen (user_pos
);
17454 if (user_len
> 116)
17456 myfree (temp_input_buf
);
17458 return (PARSER_SALT_LENGTH
);
17463 char *method_pos
= strchr (realm_pos
, '*');
17465 if (method_pos
== NULL
)
17467 myfree (temp_input_buf
);
17469 return (PARSER_SEPARATOR_UNMATCHED
);
17475 uint realm_len
= strlen (realm_pos
);
17477 if (realm_len
> 116)
17479 myfree (temp_input_buf
);
17481 return (PARSER_SALT_LENGTH
);
17486 char *URI_prefix_pos
= strchr (method_pos
, '*');
17488 if (URI_prefix_pos
== NULL
)
17490 myfree (temp_input_buf
);
17492 return (PARSER_SEPARATOR_UNMATCHED
);
17495 URI_prefix_pos
[0] = 0;
17498 uint method_len
= strlen (method_pos
);
17500 if (method_len
> 246)
17502 myfree (temp_input_buf
);
17504 return (PARSER_SALT_LENGTH
);
17509 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17511 if (URI_resource_pos
== NULL
)
17513 myfree (temp_input_buf
);
17515 return (PARSER_SEPARATOR_UNMATCHED
);
17518 URI_resource_pos
[0] = 0;
17519 URI_resource_pos
++;
17521 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17523 if (URI_prefix_len
> 245)
17525 myfree (temp_input_buf
);
17527 return (PARSER_SALT_LENGTH
);
17532 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17534 if (URI_suffix_pos
== NULL
)
17536 myfree (temp_input_buf
);
17538 return (PARSER_SEPARATOR_UNMATCHED
);
17541 URI_suffix_pos
[0] = 0;
17544 uint URI_resource_len
= strlen (URI_resource_pos
);
17546 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17548 myfree (temp_input_buf
);
17550 return (PARSER_SALT_LENGTH
);
17555 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17557 if (nonce_pos
== NULL
)
17559 myfree (temp_input_buf
);
17561 return (PARSER_SEPARATOR_UNMATCHED
);
17567 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17569 if (URI_suffix_len
> 245)
17571 myfree (temp_input_buf
);
17573 return (PARSER_SALT_LENGTH
);
17578 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17580 if (nonce_client_pos
== NULL
)
17582 myfree (temp_input_buf
);
17584 return (PARSER_SEPARATOR_UNMATCHED
);
17587 nonce_client_pos
[0] = 0;
17588 nonce_client_pos
++;
17590 uint nonce_len
= strlen (nonce_pos
);
17592 if (nonce_len
< 1 || nonce_len
> 50)
17594 myfree (temp_input_buf
);
17596 return (PARSER_SALT_LENGTH
);
17601 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17603 if (nonce_count_pos
== NULL
)
17605 myfree (temp_input_buf
);
17607 return (PARSER_SEPARATOR_UNMATCHED
);
17610 nonce_count_pos
[0] = 0;
17613 uint nonce_client_len
= strlen (nonce_client_pos
);
17615 if (nonce_client_len
> 50)
17617 myfree (temp_input_buf
);
17619 return (PARSER_SALT_LENGTH
);
17624 char *qop_pos
= strchr (nonce_count_pos
, '*');
17626 if (qop_pos
== NULL
)
17628 myfree (temp_input_buf
);
17630 return (PARSER_SEPARATOR_UNMATCHED
);
17636 uint nonce_count_len
= strlen (nonce_count_pos
);
17638 if (nonce_count_len
> 50)
17640 myfree (temp_input_buf
);
17642 return (PARSER_SALT_LENGTH
);
17647 char *directive_pos
= strchr (qop_pos
, '*');
17649 if (directive_pos
== NULL
)
17651 myfree (temp_input_buf
);
17653 return (PARSER_SEPARATOR_UNMATCHED
);
17656 directive_pos
[0] = 0;
17659 uint qop_len
= strlen (qop_pos
);
17663 myfree (temp_input_buf
);
17665 return (PARSER_SALT_LENGTH
);
17670 char *digest_pos
= strchr (directive_pos
, '*');
17672 if (digest_pos
== NULL
)
17674 myfree (temp_input_buf
);
17676 return (PARSER_SEPARATOR_UNMATCHED
);
17682 uint directive_len
= strlen (directive_pos
);
17684 if (directive_len
!= 3)
17686 myfree (temp_input_buf
);
17688 return (PARSER_SALT_LENGTH
);
17691 if (memcmp (directive_pos
, "MD5", 3))
17693 log_info ("ERROR: only the MD5 directive is currently supported\n");
17695 myfree (temp_input_buf
);
17697 return (PARSER_SIP_AUTH_DIRECTIVE
);
17701 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17706 uint md5_max_len
= 4 * 64;
17708 uint md5_remaining_len
= md5_max_len
;
17710 uint tmp_md5_buf
[64] = { 0 };
17712 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17714 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17716 md5_len
+= method_len
+ 1;
17717 tmp_md5_ptr
+= method_len
+ 1;
17719 if (URI_prefix_len
> 0)
17721 md5_remaining_len
= md5_max_len
- md5_len
;
17723 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17725 md5_len
+= URI_prefix_len
+ 1;
17726 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17729 md5_remaining_len
= md5_max_len
- md5_len
;
17731 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17733 md5_len
+= URI_resource_len
;
17734 tmp_md5_ptr
+= URI_resource_len
;
17736 if (URI_suffix_len
> 0)
17738 md5_remaining_len
= md5_max_len
- md5_len
;
17740 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17742 md5_len
+= 1 + URI_suffix_len
;
17745 uint tmp_digest
[4] = { 0 };
17747 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17749 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17750 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17751 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17752 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17758 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17760 uint esalt_len
= 0;
17762 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17764 // there are 2 possibilities for the esalt:
17766 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17768 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17770 if (esalt_len
> max_esalt_len
)
17772 myfree (temp_input_buf
);
17774 return (PARSER_SALT_LENGTH
);
17777 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17789 esalt_len
= 1 + nonce_len
+ 1 + 32;
17791 if (esalt_len
> max_esalt_len
)
17793 myfree (temp_input_buf
);
17795 return (PARSER_SALT_LENGTH
);
17798 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17806 // add 0x80 to esalt
17808 esalt_buf_ptr
[esalt_len
] = 0x80;
17810 sip
->esalt_len
= esalt_len
;
17816 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17818 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17820 uint max_salt_len
= 119;
17822 if (salt_len
> max_salt_len
)
17824 myfree (temp_input_buf
);
17826 return (PARSER_SALT_LENGTH
);
17829 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17831 sip
->salt_len
= salt_len
;
17834 * fake salt (for sorting)
17837 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17841 uint fake_salt_len
= salt_len
;
17843 if (fake_salt_len
> max_salt_len
)
17845 fake_salt_len
= max_salt_len
;
17848 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17850 salt
->salt_len
= fake_salt_len
;
17856 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17857 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17858 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17859 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17861 digest
[0] = byte_swap_32 (digest
[0]);
17862 digest
[1] = byte_swap_32 (digest
[1]);
17863 digest
[2] = byte_swap_32 (digest
[2]);
17864 digest
[3] = byte_swap_32 (digest
[3]);
17866 myfree (temp_input_buf
);
17868 return (PARSER_OK
);
17871 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17873 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17875 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17877 u32
*digest
= (u32
*) hash_buf
->digest
;
17879 salt_t
*salt
= hash_buf
->salt
;
17883 char *digest_pos
= input_buf
;
17885 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17892 char *salt_buf
= input_buf
+ 8 + 1;
17896 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17898 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17900 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17902 salt
->salt_len
= salt_len
;
17904 return (PARSER_OK
);
17907 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17909 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17911 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17913 u32
*digest
= (u32
*) hash_buf
->digest
;
17915 salt_t
*salt
= hash_buf
->salt
;
17917 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17923 char *p_buf_pos
= input_buf
+ 4;
17925 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17927 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17929 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17931 NumCyclesPower_pos
++;
17933 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17935 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17937 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17941 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17943 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17945 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
17949 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17951 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17953 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17957 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17959 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17961 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
17965 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17967 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17969 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17973 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17975 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17977 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
17981 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17983 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17985 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
17989 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17991 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17993 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17997 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;
17999 const uint iter
= atoi (NumCyclesPower_pos
);
18000 const uint crc
= atoi (crc_buf_pos
);
18001 const uint p_buf
= atoi (p_buf_pos
);
18002 const uint salt_len
= atoi (salt_len_pos
);
18003 const uint iv_len
= atoi (iv_len_pos
);
18004 const uint unpack_size
= atoi (unpack_size_pos
);
18005 const uint data_len
= atoi (data_len_pos
);
18011 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18012 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18014 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18016 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18018 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18024 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18025 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18026 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18027 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18029 seven_zip
->iv_len
= iv_len
;
18031 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18033 seven_zip
->salt_len
= 0;
18035 seven_zip
->crc
= crc
;
18037 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18039 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18041 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18044 seven_zip
->data_len
= data_len
;
18046 seven_zip
->unpack_size
= unpack_size
;
18050 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18051 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18052 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18053 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18055 salt
->salt_len
= 16;
18057 salt
->salt_sign
[0] = iter
;
18059 salt
->salt_iter
= 1 << iter
;
18070 return (PARSER_OK
);
18073 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18075 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18077 u32
*digest
= (u32
*) hash_buf
->digest
;
18079 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18080 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18081 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18082 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18083 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18084 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18085 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18086 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18088 digest
[0] = byte_swap_32 (digest
[0]);
18089 digest
[1] = byte_swap_32 (digest
[1]);
18090 digest
[2] = byte_swap_32 (digest
[2]);
18091 digest
[3] = byte_swap_32 (digest
[3]);
18092 digest
[4] = byte_swap_32 (digest
[4]);
18093 digest
[5] = byte_swap_32 (digest
[5]);
18094 digest
[6] = byte_swap_32 (digest
[6]);
18095 digest
[7] = byte_swap_32 (digest
[7]);
18097 return (PARSER_OK
);
18100 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18102 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18104 u32
*digest
= (u32
*) hash_buf
->digest
;
18106 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18107 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18108 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18109 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18110 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18111 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18112 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18113 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18114 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18115 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18116 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18117 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18118 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18119 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18120 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18121 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18123 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18124 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18125 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18126 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18127 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18128 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18129 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18130 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18131 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18132 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18133 digest
[10] = byte_swap_32 (digest
[10]);
18134 digest
[11] = byte_swap_32 (digest
[11]);
18135 digest
[12] = byte_swap_32 (digest
[12]);
18136 digest
[13] = byte_swap_32 (digest
[13]);
18137 digest
[14] = byte_swap_32 (digest
[14]);
18138 digest
[15] = byte_swap_32 (digest
[15]);
18140 return (PARSER_OK
);
18143 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18145 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18147 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18149 u32
*digest
= (u32
*) hash_buf
->digest
;
18151 salt_t
*salt
= hash_buf
->salt
;
18153 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18161 char *iter_pos
= input_buf
+ 4;
18163 u32 iter
= atoi (iter_pos
);
18165 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18166 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18168 // first is *raw* salt
18170 char *salt_pos
= strchr (iter_pos
, ':');
18172 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18176 char *hash_pos
= strchr (salt_pos
, ':');
18178 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18180 u32 salt_len
= hash_pos
- salt_pos
;
18182 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18186 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18188 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18192 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18194 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18196 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18198 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18199 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18201 salt
->salt_len
= salt_len
;
18202 salt
->salt_iter
= iter
- 1;
18206 u8 tmp_buf
[100] = { 0 };
18208 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18210 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18212 memcpy (digest
, tmp_buf
, 16);
18214 // add some stuff to normal salt to make sorted happy
18216 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18217 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18218 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18219 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18220 salt
->salt_buf
[4] = salt
->salt_iter
;
18222 return (PARSER_OK
);
18225 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18227 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18229 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18231 u32
*digest
= (u32
*) hash_buf
->digest
;
18233 salt_t
*salt
= hash_buf
->salt
;
18235 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18243 char *iter_pos
= input_buf
+ 5;
18245 u32 iter
= atoi (iter_pos
);
18247 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18248 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18250 // first is *raw* salt
18252 char *salt_pos
= strchr (iter_pos
, ':');
18254 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18258 char *hash_pos
= strchr (salt_pos
, ':');
18260 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18262 u32 salt_len
= hash_pos
- salt_pos
;
18264 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18268 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18270 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18274 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18276 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18278 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18280 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18281 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18283 salt
->salt_len
= salt_len
;
18284 salt
->salt_iter
= iter
- 1;
18288 u8 tmp_buf
[100] = { 0 };
18290 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18292 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18294 memcpy (digest
, tmp_buf
, 16);
18296 digest
[0] = byte_swap_32 (digest
[0]);
18297 digest
[1] = byte_swap_32 (digest
[1]);
18298 digest
[2] = byte_swap_32 (digest
[2]);
18299 digest
[3] = byte_swap_32 (digest
[3]);
18301 // add some stuff to normal salt to make sorted happy
18303 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18304 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18305 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18306 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18307 salt
->salt_buf
[4] = salt
->salt_iter
;
18309 return (PARSER_OK
);
18312 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18314 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18316 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18318 u64
*digest
= (u64
*) hash_buf
->digest
;
18320 salt_t
*salt
= hash_buf
->salt
;
18322 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18330 char *iter_pos
= input_buf
+ 7;
18332 u32 iter
= atoi (iter_pos
);
18334 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18335 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18337 // first is *raw* salt
18339 char *salt_pos
= strchr (iter_pos
, ':');
18341 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18345 char *hash_pos
= strchr (salt_pos
, ':');
18347 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18349 u32 salt_len
= hash_pos
- salt_pos
;
18351 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18355 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18357 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18361 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18363 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18365 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18367 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18368 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18370 salt
->salt_len
= salt_len
;
18371 salt
->salt_iter
= iter
- 1;
18375 u8 tmp_buf
[100] = { 0 };
18377 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18379 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18381 memcpy (digest
, tmp_buf
, 64);
18383 digest
[0] = byte_swap_64 (digest
[0]);
18384 digest
[1] = byte_swap_64 (digest
[1]);
18385 digest
[2] = byte_swap_64 (digest
[2]);
18386 digest
[3] = byte_swap_64 (digest
[3]);
18387 digest
[4] = byte_swap_64 (digest
[4]);
18388 digest
[5] = byte_swap_64 (digest
[5]);
18389 digest
[6] = byte_swap_64 (digest
[6]);
18390 digest
[7] = byte_swap_64 (digest
[7]);
18392 // add some stuff to normal salt to make sorted happy
18394 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18395 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18396 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18397 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18398 salt
->salt_buf
[4] = salt
->salt_iter
;
18400 return (PARSER_OK
);
18403 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18405 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18407 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18409 uint
*digest
= (uint
*) hash_buf
->digest
;
18411 salt_t
*salt
= hash_buf
->salt
;
18417 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18419 char *hash_pos
= strchr (salt_pos
, '$');
18421 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18423 u32 salt_len
= hash_pos
- salt_pos
;
18425 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18429 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18431 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18435 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18436 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18454 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18455 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18457 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18458 salt
->salt_len
= 8;
18460 return (PARSER_OK
);
18463 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18465 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18467 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18469 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18471 if (c19
& 3) return (PARSER_HASH_VALUE
);
18473 salt_t
*salt
= hash_buf
->salt
;
18475 u32
*digest
= (u32
*) hash_buf
->digest
;
18479 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18480 | itoa64_to_int (input_buf
[2]) << 6
18481 | itoa64_to_int (input_buf
[3]) << 12
18482 | itoa64_to_int (input_buf
[4]) << 18;
18486 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18487 | itoa64_to_int (input_buf
[6]) << 6
18488 | itoa64_to_int (input_buf
[7]) << 12
18489 | itoa64_to_int (input_buf
[8]) << 18;
18491 salt
->salt_len
= 4;
18493 u8 tmp_buf
[100] = { 0 };
18495 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18497 memcpy (digest
, tmp_buf
, 8);
18501 IP (digest
[0], digest
[1], tt
);
18503 digest
[0] = rotr32 (digest
[0], 31);
18504 digest
[1] = rotr32 (digest
[1], 31);
18508 return (PARSER_OK
);
18511 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18513 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18515 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18517 u32
*digest
= (u32
*) hash_buf
->digest
;
18519 salt_t
*salt
= hash_buf
->salt
;
18525 char *type_pos
= input_buf
+ 6 + 1;
18527 char *salt_pos
= strchr (type_pos
, '*');
18529 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18531 u32 type_len
= salt_pos
- type_pos
;
18533 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18537 char *crypted_pos
= strchr (salt_pos
, '*');
18539 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18541 u32 salt_len
= crypted_pos
- salt_pos
;
18543 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18547 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18549 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18555 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18556 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18558 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18559 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18561 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18562 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18563 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18564 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18566 salt
->salt_len
= 24;
18567 salt
->salt_iter
= ROUNDS_RAR3
;
18569 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18570 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18572 digest
[0] = 0xc43d7b00;
18573 digest
[1] = 0x40070000;
18577 return (PARSER_OK
);
18580 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18582 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18584 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18586 u32
*digest
= (u32
*) hash_buf
->digest
;
18588 salt_t
*salt
= hash_buf
->salt
;
18590 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18596 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18598 char *param1_pos
= strchr (param0_pos
, '$');
18600 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18602 u32 param0_len
= param1_pos
- param0_pos
;
18606 char *param2_pos
= strchr (param1_pos
, '$');
18608 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18610 u32 param1_len
= param2_pos
- param1_pos
;
18614 char *param3_pos
= strchr (param2_pos
, '$');
18616 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18618 u32 param2_len
= param3_pos
- param2_pos
;
18622 char *param4_pos
= strchr (param3_pos
, '$');
18624 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18626 u32 param3_len
= param4_pos
- param3_pos
;
18630 char *param5_pos
= strchr (param4_pos
, '$');
18632 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18634 u32 param4_len
= param5_pos
- param4_pos
;
18638 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18640 char *salt_buf
= param1_pos
;
18641 char *iv
= param3_pos
;
18642 char *pswcheck
= param5_pos
;
18644 const uint salt_len
= atoi (param0_pos
);
18645 const uint iterations
= atoi (param2_pos
);
18646 const uint pswcheck_len
= atoi (param4_pos
);
18652 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18653 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18654 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18656 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18657 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18658 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18664 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18665 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18666 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18667 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18669 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18670 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18671 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18672 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18674 salt
->salt_len
= 16;
18676 salt
->salt_sign
[0] = iterations
;
18678 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18684 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18685 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18689 return (PARSER_OK
);
18692 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18694 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18696 u32
*digest
= (u32
*) hash_buf
->digest
;
18698 salt_t
*salt
= hash_buf
->salt
;
18700 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18701 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18702 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18703 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18704 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18705 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18706 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18707 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18709 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18711 uint salt_len
= input_len
- 64 - 1;
18713 char *salt_buf
= input_buf
+ 64 + 1;
18715 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18717 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18719 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18721 salt
->salt_len
= salt_len
;
18724 * we can precompute the first sha256 transform
18727 uint w
[16] = { 0 };
18729 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18730 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18731 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18732 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18733 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18734 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18735 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18736 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18737 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18738 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18739 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18740 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18741 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18742 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18743 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18744 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18746 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
18748 sha256_64 (w
, pc256
);
18750 salt
->salt_buf_pc
[0] = pc256
[0];
18751 salt
->salt_buf_pc
[1] = pc256
[1];
18752 salt
->salt_buf_pc
[2] = pc256
[2];
18753 salt
->salt_buf_pc
[3] = pc256
[3];
18754 salt
->salt_buf_pc
[4] = pc256
[4];
18755 salt
->salt_buf_pc
[5] = pc256
[5];
18756 salt
->salt_buf_pc
[6] = pc256
[6];
18757 salt
->salt_buf_pc
[7] = pc256
[7];
18759 digest
[0] -= pc256
[0];
18760 digest
[1] -= pc256
[1];
18761 digest
[2] -= pc256
[2];
18762 digest
[3] -= pc256
[3];
18763 digest
[4] -= pc256
[4];
18764 digest
[5] -= pc256
[5];
18765 digest
[6] -= pc256
[6];
18766 digest
[7] -= pc256
[7];
18768 return (PARSER_OK
);
18771 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18773 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18775 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18777 u32
*digest
= (u32
*) hash_buf
->digest
;
18779 salt_t
*salt
= hash_buf
->salt
;
18785 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18787 char *data_buf_pos
= strchr (data_len_pos
, '$');
18789 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18791 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18793 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18794 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18798 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18800 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18802 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18804 u32 data_len
= atoi (data_len_pos
);
18806 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18812 char *salt_pos
= data_buf_pos
;
18814 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18815 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18816 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
18817 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
18819 // this is actually the CT, which is also the hash later (if matched)
18821 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
18822 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
18823 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
18824 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
18826 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18828 salt
->salt_iter
= 10 - 1;
18834 digest
[0] = salt
->salt_buf
[4];
18835 digest
[1] = salt
->salt_buf
[5];
18836 digest
[2] = salt
->salt_buf
[6];
18837 digest
[3] = salt
->salt_buf
[7];
18839 return (PARSER_OK
);
18842 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18844 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18846 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18848 u32
*digest
= (u32
*) hash_buf
->digest
;
18850 salt_t
*salt
= hash_buf
->salt
;
18856 char *salt_pos
= input_buf
+ 11 + 1;
18858 char *iter_pos
= strchr (salt_pos
, ',');
18860 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18862 u32 salt_len
= iter_pos
- salt_pos
;
18864 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18868 char *hash_pos
= strchr (iter_pos
, ',');
18870 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18872 u32 iter_len
= hash_pos
- iter_pos
;
18874 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18878 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18880 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18886 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18887 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18888 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
18889 salt
->salt_buf
[3] = 0x00018000;
18891 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18892 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18893 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18894 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18896 salt
->salt_len
= salt_len
/ 2;
18898 salt
->salt_iter
= atoi (iter_pos
) - 1;
18904 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18905 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18906 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18907 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18908 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18909 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18910 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18911 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18913 return (PARSER_OK
);
18916 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18918 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
18920 u32
*digest
= (u32
*) hash_buf
->digest
;
18922 salt_t
*salt
= hash_buf
->salt
;
18928 char *hash_pos
= input_buf
+ 64;
18929 char *salt1_pos
= input_buf
+ 128;
18930 char *salt2_pos
= input_buf
;
18936 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
18937 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
18938 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
18939 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
18941 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
18942 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
18943 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
18944 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
18946 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
18947 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
18948 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
18949 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
18951 salt
->salt_len
= 48;
18953 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
18959 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18960 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18961 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18962 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18963 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18964 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18965 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18966 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18968 return (PARSER_OK
);
18972 * parallel running threads
18977 BOOL WINAPI
sigHandler_default (DWORD sig
)
18981 case CTRL_CLOSE_EVENT
:
18984 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18985 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18986 * function otherwise it is too late (e.g. after returning from this function)
18991 SetConsoleCtrlHandler (NULL
, TRUE
);
18998 case CTRL_LOGOFF_EVENT
:
18999 case CTRL_SHUTDOWN_EVENT
:
19003 SetConsoleCtrlHandler (NULL
, TRUE
);
19011 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19015 case CTRL_CLOSE_EVENT
:
19019 SetConsoleCtrlHandler (NULL
, TRUE
);
19026 case CTRL_LOGOFF_EVENT
:
19027 case CTRL_SHUTDOWN_EVENT
:
19031 SetConsoleCtrlHandler (NULL
, TRUE
);
19039 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19041 if (callback
== NULL
)
19043 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19047 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19053 void sigHandler_default (int sig
)
19057 signal (sig
, NULL
);
19060 void sigHandler_benchmark (int sig
)
19064 signal (sig
, NULL
);
19067 void hc_signal (void (callback
) (int))
19069 if (callback
== NULL
) callback
= SIG_DFL
;
19071 signal (SIGINT
, callback
);
19072 signal (SIGTERM
, callback
);
19073 signal (SIGABRT
, callback
);
19078 void status_display ();
19080 void *thread_keypress (void *p
)
19082 int benchmark
= *((int *) p
);
19084 uint quiet
= data
.quiet
;
19088 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19090 int ch
= tty_getchar();
19092 if (ch
== -1) break;
19094 if (ch
== 0) continue;
19100 hc_thread_mutex_lock (mux_display
);
19115 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19116 if (quiet
== 0) fflush (stdout
);
19128 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19129 if (quiet
== 0) fflush (stdout
);
19141 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19142 if (quiet
== 0) fflush (stdout
);
19154 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19155 if (quiet
== 0) fflush (stdout
);
19163 if (benchmark
== 1) break;
19165 stop_at_checkpoint ();
19169 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19170 if (quiet
== 0) fflush (stdout
);
19178 if (benchmark
== 1)
19190 hc_thread_mutex_unlock (mux_display
);
19202 bool class_num (const u8 c
)
19204 return ((c
>= '0') && (c
<= '9'));
19207 bool class_lower (const u8 c
)
19209 return ((c
>= 'a') && (c
<= 'z'));
19212 bool class_upper (const u8 c
)
19214 return ((c
>= 'A') && (c
<= 'Z'));
19217 bool class_alpha (const u8 c
)
19219 return (class_lower (c
) || class_upper (c
));
19222 int conv_ctoi (const u8 c
)
19228 else if (class_upper (c
))
19230 return c
- 'A' + 10;
19236 int conv_itoc (const u8 c
)
19244 return c
+ 'A' - 10;
19254 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19255 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19256 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19257 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19258 #define MAX_KERNEL_RULES 255
19259 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19260 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19261 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19263 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19264 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19265 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19266 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19268 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19273 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19275 switch (rule_buf
[rule_pos
])
19281 case RULE_OP_MANGLE_NOOP
:
19282 SET_NAME (rule
, rule_buf
[rule_pos
]);
19285 case RULE_OP_MANGLE_LREST
:
19286 SET_NAME (rule
, rule_buf
[rule_pos
]);
19289 case RULE_OP_MANGLE_UREST
:
19290 SET_NAME (rule
, rule_buf
[rule_pos
]);
19293 case RULE_OP_MANGLE_LREST_UFIRST
:
19294 SET_NAME (rule
, rule_buf
[rule_pos
]);
19297 case RULE_OP_MANGLE_UREST_LFIRST
:
19298 SET_NAME (rule
, rule_buf
[rule_pos
]);
19301 case RULE_OP_MANGLE_TREST
:
19302 SET_NAME (rule
, rule_buf
[rule_pos
]);
19305 case RULE_OP_MANGLE_TOGGLE_AT
:
19306 SET_NAME (rule
, rule_buf
[rule_pos
]);
19307 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19310 case RULE_OP_MANGLE_REVERSE
:
19311 SET_NAME (rule
, rule_buf
[rule_pos
]);
19314 case RULE_OP_MANGLE_DUPEWORD
:
19315 SET_NAME (rule
, rule_buf
[rule_pos
]);
19318 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19319 SET_NAME (rule
, rule_buf
[rule_pos
]);
19320 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19323 case RULE_OP_MANGLE_REFLECT
:
19324 SET_NAME (rule
, rule_buf
[rule_pos
]);
19327 case RULE_OP_MANGLE_ROTATE_LEFT
:
19328 SET_NAME (rule
, rule_buf
[rule_pos
]);
19331 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19332 SET_NAME (rule
, rule_buf
[rule_pos
]);
19335 case RULE_OP_MANGLE_APPEND
:
19336 SET_NAME (rule
, rule_buf
[rule_pos
]);
19337 SET_P0 (rule
, rule_buf
[rule_pos
]);
19340 case RULE_OP_MANGLE_PREPEND
:
19341 SET_NAME (rule
, rule_buf
[rule_pos
]);
19342 SET_P0 (rule
, rule_buf
[rule_pos
]);
19345 case RULE_OP_MANGLE_DELETE_FIRST
:
19346 SET_NAME (rule
, rule_buf
[rule_pos
]);
19349 case RULE_OP_MANGLE_DELETE_LAST
:
19350 SET_NAME (rule
, rule_buf
[rule_pos
]);
19353 case RULE_OP_MANGLE_DELETE_AT
:
19354 SET_NAME (rule
, rule_buf
[rule_pos
]);
19355 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19358 case RULE_OP_MANGLE_EXTRACT
:
19359 SET_NAME (rule
, rule_buf
[rule_pos
]);
19360 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19361 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19364 case RULE_OP_MANGLE_OMIT
:
19365 SET_NAME (rule
, rule_buf
[rule_pos
]);
19366 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19367 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19370 case RULE_OP_MANGLE_INSERT
:
19371 SET_NAME (rule
, rule_buf
[rule_pos
]);
19372 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19373 SET_P1 (rule
, rule_buf
[rule_pos
]);
19376 case RULE_OP_MANGLE_OVERSTRIKE
:
19377 SET_NAME (rule
, rule_buf
[rule_pos
]);
19378 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19379 SET_P1 (rule
, rule_buf
[rule_pos
]);
19382 case RULE_OP_MANGLE_TRUNCATE_AT
:
19383 SET_NAME (rule
, rule_buf
[rule_pos
]);
19384 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19387 case RULE_OP_MANGLE_REPLACE
:
19388 SET_NAME (rule
, rule_buf
[rule_pos
]);
19389 SET_P0 (rule
, rule_buf
[rule_pos
]);
19390 SET_P1 (rule
, rule_buf
[rule_pos
]);
19393 case RULE_OP_MANGLE_PURGECHAR
:
19397 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19401 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19402 SET_NAME (rule
, rule_buf
[rule_pos
]);
19403 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19406 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19407 SET_NAME (rule
, rule_buf
[rule_pos
]);
19408 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19411 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19412 SET_NAME (rule
, rule_buf
[rule_pos
]);
19415 case RULE_OP_MANGLE_SWITCH_FIRST
:
19416 SET_NAME (rule
, rule_buf
[rule_pos
]);
19419 case RULE_OP_MANGLE_SWITCH_LAST
:
19420 SET_NAME (rule
, rule_buf
[rule_pos
]);
19423 case RULE_OP_MANGLE_SWITCH_AT
:
19424 SET_NAME (rule
, rule_buf
[rule_pos
]);
19425 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19426 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19429 case RULE_OP_MANGLE_CHR_SHIFTL
:
19430 SET_NAME (rule
, rule_buf
[rule_pos
]);
19431 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19434 case RULE_OP_MANGLE_CHR_SHIFTR
:
19435 SET_NAME (rule
, rule_buf
[rule_pos
]);
19436 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19439 case RULE_OP_MANGLE_CHR_INCR
:
19440 SET_NAME (rule
, rule_buf
[rule_pos
]);
19441 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19444 case RULE_OP_MANGLE_CHR_DECR
:
19445 SET_NAME (rule
, rule_buf
[rule_pos
]);
19446 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19449 case RULE_OP_MANGLE_REPLACE_NP1
:
19450 SET_NAME (rule
, rule_buf
[rule_pos
]);
19451 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19454 case RULE_OP_MANGLE_REPLACE_NM1
:
19455 SET_NAME (rule
, rule_buf
[rule_pos
]);
19456 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19459 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19460 SET_NAME (rule
, rule_buf
[rule_pos
]);
19461 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19464 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19465 SET_NAME (rule
, rule_buf
[rule_pos
]);
19466 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19469 case RULE_OP_MANGLE_TITLE
:
19470 SET_NAME (rule
, rule_buf
[rule_pos
]);
19479 if (rule_pos
< rule_len
) return (-1);
19484 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19488 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19492 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19496 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19500 case RULE_OP_MANGLE_NOOP
:
19501 rule_buf
[rule_pos
] = rule_cmd
;
19504 case RULE_OP_MANGLE_LREST
:
19505 rule_buf
[rule_pos
] = rule_cmd
;
19508 case RULE_OP_MANGLE_UREST
:
19509 rule_buf
[rule_pos
] = rule_cmd
;
19512 case RULE_OP_MANGLE_LREST_UFIRST
:
19513 rule_buf
[rule_pos
] = rule_cmd
;
19516 case RULE_OP_MANGLE_UREST_LFIRST
:
19517 rule_buf
[rule_pos
] = rule_cmd
;
19520 case RULE_OP_MANGLE_TREST
:
19521 rule_buf
[rule_pos
] = rule_cmd
;
19524 case RULE_OP_MANGLE_TOGGLE_AT
:
19525 rule_buf
[rule_pos
] = rule_cmd
;
19526 GET_P0_CONV (rule
);
19529 case RULE_OP_MANGLE_REVERSE
:
19530 rule_buf
[rule_pos
] = rule_cmd
;
19533 case RULE_OP_MANGLE_DUPEWORD
:
19534 rule_buf
[rule_pos
] = rule_cmd
;
19537 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19538 rule_buf
[rule_pos
] = rule_cmd
;
19539 GET_P0_CONV (rule
);
19542 case RULE_OP_MANGLE_REFLECT
:
19543 rule_buf
[rule_pos
] = rule_cmd
;
19546 case RULE_OP_MANGLE_ROTATE_LEFT
:
19547 rule_buf
[rule_pos
] = rule_cmd
;
19550 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19551 rule_buf
[rule_pos
] = rule_cmd
;
19554 case RULE_OP_MANGLE_APPEND
:
19555 rule_buf
[rule_pos
] = rule_cmd
;
19559 case RULE_OP_MANGLE_PREPEND
:
19560 rule_buf
[rule_pos
] = rule_cmd
;
19564 case RULE_OP_MANGLE_DELETE_FIRST
:
19565 rule_buf
[rule_pos
] = rule_cmd
;
19568 case RULE_OP_MANGLE_DELETE_LAST
:
19569 rule_buf
[rule_pos
] = rule_cmd
;
19572 case RULE_OP_MANGLE_DELETE_AT
:
19573 rule_buf
[rule_pos
] = rule_cmd
;
19574 GET_P0_CONV (rule
);
19577 case RULE_OP_MANGLE_EXTRACT
:
19578 rule_buf
[rule_pos
] = rule_cmd
;
19579 GET_P0_CONV (rule
);
19580 GET_P1_CONV (rule
);
19583 case RULE_OP_MANGLE_OMIT
:
19584 rule_buf
[rule_pos
] = rule_cmd
;
19585 GET_P0_CONV (rule
);
19586 GET_P1_CONV (rule
);
19589 case RULE_OP_MANGLE_INSERT
:
19590 rule_buf
[rule_pos
] = rule_cmd
;
19591 GET_P0_CONV (rule
);
19595 case RULE_OP_MANGLE_OVERSTRIKE
:
19596 rule_buf
[rule_pos
] = rule_cmd
;
19597 GET_P0_CONV (rule
);
19601 case RULE_OP_MANGLE_TRUNCATE_AT
:
19602 rule_buf
[rule_pos
] = rule_cmd
;
19603 GET_P0_CONV (rule
);
19606 case RULE_OP_MANGLE_REPLACE
:
19607 rule_buf
[rule_pos
] = rule_cmd
;
19612 case RULE_OP_MANGLE_PURGECHAR
:
19616 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19620 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19621 rule_buf
[rule_pos
] = rule_cmd
;
19622 GET_P0_CONV (rule
);
19625 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19626 rule_buf
[rule_pos
] = rule_cmd
;
19627 GET_P0_CONV (rule
);
19630 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19631 rule_buf
[rule_pos
] = rule_cmd
;
19634 case RULE_OP_MANGLE_SWITCH_FIRST
:
19635 rule_buf
[rule_pos
] = rule_cmd
;
19638 case RULE_OP_MANGLE_SWITCH_LAST
:
19639 rule_buf
[rule_pos
] = rule_cmd
;
19642 case RULE_OP_MANGLE_SWITCH_AT
:
19643 rule_buf
[rule_pos
] = rule_cmd
;
19644 GET_P0_CONV (rule
);
19645 GET_P1_CONV (rule
);
19648 case RULE_OP_MANGLE_CHR_SHIFTL
:
19649 rule_buf
[rule_pos
] = rule_cmd
;
19650 GET_P0_CONV (rule
);
19653 case RULE_OP_MANGLE_CHR_SHIFTR
:
19654 rule_buf
[rule_pos
] = rule_cmd
;
19655 GET_P0_CONV (rule
);
19658 case RULE_OP_MANGLE_CHR_INCR
:
19659 rule_buf
[rule_pos
] = rule_cmd
;
19660 GET_P0_CONV (rule
);
19663 case RULE_OP_MANGLE_CHR_DECR
:
19664 rule_buf
[rule_pos
] = rule_cmd
;
19665 GET_P0_CONV (rule
);
19668 case RULE_OP_MANGLE_REPLACE_NP1
:
19669 rule_buf
[rule_pos
] = rule_cmd
;
19670 GET_P0_CONV (rule
);
19673 case RULE_OP_MANGLE_REPLACE_NM1
:
19674 rule_buf
[rule_pos
] = rule_cmd
;
19675 GET_P0_CONV (rule
);
19678 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19679 rule_buf
[rule_pos
] = rule_cmd
;
19680 GET_P0_CONV (rule
);
19683 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19684 rule_buf
[rule_pos
] = rule_cmd
;
19685 GET_P0_CONV (rule
);
19688 case RULE_OP_MANGLE_TITLE
:
19689 rule_buf
[rule_pos
] = rule_cmd
;
19693 return rule_pos
- 1;
19711 * CPU rules : this is from hashcat sources, cpu based rules
19714 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19715 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19717 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19718 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19719 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19721 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19722 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19723 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19725 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19729 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19734 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19738 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19743 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19747 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19752 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19757 for (l
= 0; l
< arr_len
; l
++)
19759 r
= arr_len
- 1 - l
;
19763 MANGLE_SWITCH (arr
, l
, r
);
19769 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19771 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19773 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19775 return (arr_len
* 2);
19778 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19780 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19782 int orig_len
= arr_len
;
19786 for (i
= 0; i
< times
; i
++)
19788 memcpy (&arr
[arr_len
], arr
, orig_len
);
19790 arr_len
+= orig_len
;
19796 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19798 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19800 mangle_double (arr
, arr_len
);
19802 mangle_reverse (arr
+ arr_len
, arr_len
);
19804 return (arr_len
* 2);
19807 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19812 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19814 MANGLE_SWITCH (arr
, l
, r
);
19820 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19825 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19827 MANGLE_SWITCH (arr
, l
, r
);
19833 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19835 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19839 return (arr_len
+ 1);
19842 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19844 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19848 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19850 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19855 return (arr_len
+ 1);
19858 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19860 if (upos
>= arr_len
) return (arr_len
);
19864 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19866 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19869 return (arr_len
- 1);
19872 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19874 if (upos
>= arr_len
) return (arr_len
);
19876 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19880 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19882 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19888 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19890 if (upos
>= arr_len
) return (arr_len
);
19892 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19896 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19898 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19901 return (arr_len
- ulen
);
19904 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19906 if (upos
>= arr_len
) return (arr_len
);
19908 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19912 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19914 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19919 return (arr_len
+ 1);
19922 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
)
19924 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19926 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19928 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19930 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19932 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19934 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19936 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19938 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19940 return (arr_len
+ arr2_cpy
);
19943 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19945 if (upos
>= arr_len
) return (arr_len
);
19952 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19954 if (upos
>= arr_len
) return (arr_len
);
19956 memset (arr
+ upos
, 0, arr_len
- upos
);
19961 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19965 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19967 if (arr
[arr_pos
] != oldc
) continue;
19969 arr
[arr_pos
] = newc
;
19975 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19981 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19983 if (arr
[arr_pos
] == c
) continue;
19985 arr
[ret_len
] = arr
[arr_pos
];
19993 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19995 if (ulen
> arr_len
) return (arr_len
);
19997 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19999 char cs
[100] = { 0 };
20001 memcpy (cs
, arr
, ulen
);
20005 for (i
= 0; i
< ulen
; i
++)
20009 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20015 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20017 if (ulen
> arr_len
) return (arr_len
);
20019 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20021 int upos
= arr_len
- ulen
;
20025 for (i
= 0; i
< ulen
; i
++)
20027 char c
= arr
[upos
+ i
];
20029 arr_len
= mangle_append (arr
, arr_len
, c
);
20035 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20037 if ( arr_len
== 0) return (arr_len
);
20038 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20040 char c
= arr
[upos
];
20044 for (i
= 0; i
< ulen
; i
++)
20046 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20052 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20054 if ( arr_len
== 0) return (arr_len
);
20055 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20059 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20061 int new_pos
= arr_pos
* 2;
20063 arr
[new_pos
] = arr
[arr_pos
];
20065 arr
[new_pos
+ 1] = arr
[arr_pos
];
20068 return (arr_len
* 2);
20071 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20073 if (upos
>= arr_len
) return (arr_len
);
20074 if (upos2
>= arr_len
) return (arr_len
);
20076 MANGLE_SWITCH (arr
, upos
, upos2
);
20081 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20083 MANGLE_SWITCH (arr
, upos
, upos2
);
20088 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20090 if (upos
>= arr_len
) return (arr_len
);
20097 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20099 if (upos
>= arr_len
) return (arr_len
);
20106 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20108 if (upos
>= arr_len
) return (arr_len
);
20115 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20117 if (upos
>= arr_len
) return (arr_len
);
20124 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20126 int upper_next
= 1;
20130 for (pos
= 0; pos
< arr_len
; pos
++)
20132 if (arr
[pos
] == ' ')
20143 MANGLE_UPPER_AT (arr
, pos
);
20147 MANGLE_LOWER_AT (arr
, pos
);
20154 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20156 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20162 for (j
= 0; j
< rp_gen_num
; j
++)
20169 switch ((char) get_random_num (0, 9))
20172 r
= get_random_num (0, sizeof (grp_op_nop
));
20173 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20177 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20178 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20179 p1
= get_random_num (0, sizeof (grp_pos
));
20180 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20184 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20185 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20186 p1
= get_random_num (1, 6);
20187 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20191 r
= get_random_num (0, sizeof (grp_op_chr
));
20192 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20193 p1
= get_random_num (0x20, 0x7e);
20194 rule_buf
[rule_pos
++] = (char) p1
;
20198 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20199 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20200 p1
= get_random_num (0x20, 0x7e);
20201 rule_buf
[rule_pos
++] = (char) p1
;
20202 p2
= get_random_num (0x20, 0x7e);
20204 p2
= get_random_num (0x20, 0x7e);
20205 rule_buf
[rule_pos
++] = (char) p2
;
20209 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20210 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20211 p1
= get_random_num (0, sizeof (grp_pos
));
20212 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20213 p2
= get_random_num (0x20, 0x7e);
20214 rule_buf
[rule_pos
++] = (char) p2
;
20218 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20219 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20220 p1
= get_random_num (0, sizeof (grp_pos
));
20221 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20222 p2
= get_random_num (0, sizeof (grp_pos
));
20224 p2
= get_random_num (0, sizeof (grp_pos
));
20225 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20229 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20230 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20231 p1
= get_random_num (0, sizeof (grp_pos
));
20232 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20233 p2
= get_random_num (1, sizeof (grp_pos
));
20235 p2
= get_random_num (1, sizeof (grp_pos
));
20236 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20240 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20241 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20242 p1
= get_random_num (0, sizeof (grp_pos
));
20243 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20244 p2
= get_random_num (1, sizeof (grp_pos
));
20245 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20246 p3
= get_random_num (0, sizeof (grp_pos
));
20247 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20255 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20257 char mem
[BLOCK_SIZE
];
20259 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20261 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20263 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
20265 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20267 int out_len
= in_len
;
20268 int mem_len
= in_len
;
20270 memcpy (out
, in
, out_len
);
20274 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20279 switch (rule
[rule_pos
])
20284 case RULE_OP_MANGLE_NOOP
:
20287 case RULE_OP_MANGLE_LREST
:
20288 out_len
= mangle_lrest (out
, out_len
);
20291 case RULE_OP_MANGLE_UREST
:
20292 out_len
= mangle_urest (out
, out_len
);
20295 case RULE_OP_MANGLE_LREST_UFIRST
:
20296 out_len
= mangle_lrest (out
, out_len
);
20297 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20300 case RULE_OP_MANGLE_UREST_LFIRST
:
20301 out_len
= mangle_urest (out
, out_len
);
20302 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20305 case RULE_OP_MANGLE_TREST
:
20306 out_len
= mangle_trest (out
, out_len
);
20309 case RULE_OP_MANGLE_TOGGLE_AT
:
20310 NEXT_RULEPOS (rule_pos
);
20311 NEXT_RPTOI (rule
, rule_pos
, upos
);
20312 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20315 case RULE_OP_MANGLE_REVERSE
:
20316 out_len
= mangle_reverse (out
, out_len
);
20319 case RULE_OP_MANGLE_DUPEWORD
:
20320 out_len
= mangle_double (out
, out_len
);
20323 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20324 NEXT_RULEPOS (rule_pos
);
20325 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20326 out_len
= mangle_double_times (out
, out_len
, ulen
);
20329 case RULE_OP_MANGLE_REFLECT
:
20330 out_len
= mangle_reflect (out
, out_len
);
20333 case RULE_OP_MANGLE_ROTATE_LEFT
:
20334 mangle_rotate_left (out
, out_len
);
20337 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20338 mangle_rotate_right (out
, out_len
);
20341 case RULE_OP_MANGLE_APPEND
:
20342 NEXT_RULEPOS (rule_pos
);
20343 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20346 case RULE_OP_MANGLE_PREPEND
:
20347 NEXT_RULEPOS (rule_pos
);
20348 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20351 case RULE_OP_MANGLE_DELETE_FIRST
:
20352 out_len
= mangle_delete_at (out
, out_len
, 0);
20355 case RULE_OP_MANGLE_DELETE_LAST
:
20356 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20359 case RULE_OP_MANGLE_DELETE_AT
:
20360 NEXT_RULEPOS (rule_pos
);
20361 NEXT_RPTOI (rule
, rule_pos
, upos
);
20362 out_len
= mangle_delete_at (out
, out_len
, upos
);
20365 case RULE_OP_MANGLE_EXTRACT
:
20366 NEXT_RULEPOS (rule_pos
);
20367 NEXT_RPTOI (rule
, rule_pos
, upos
);
20368 NEXT_RULEPOS (rule_pos
);
20369 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20370 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20373 case RULE_OP_MANGLE_OMIT
:
20374 NEXT_RULEPOS (rule_pos
);
20375 NEXT_RPTOI (rule
, rule_pos
, upos
);
20376 NEXT_RULEPOS (rule_pos
);
20377 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20378 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20381 case RULE_OP_MANGLE_INSERT
:
20382 NEXT_RULEPOS (rule_pos
);
20383 NEXT_RPTOI (rule
, rule_pos
, upos
);
20384 NEXT_RULEPOS (rule_pos
);
20385 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20388 case RULE_OP_MANGLE_OVERSTRIKE
:
20389 NEXT_RULEPOS (rule_pos
);
20390 NEXT_RPTOI (rule
, rule_pos
, upos
);
20391 NEXT_RULEPOS (rule_pos
);
20392 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20395 case RULE_OP_MANGLE_TRUNCATE_AT
:
20396 NEXT_RULEPOS (rule_pos
);
20397 NEXT_RPTOI (rule
, rule_pos
, upos
);
20398 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20401 case RULE_OP_MANGLE_REPLACE
:
20402 NEXT_RULEPOS (rule_pos
);
20403 NEXT_RULEPOS (rule_pos
);
20404 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20407 case RULE_OP_MANGLE_PURGECHAR
:
20408 NEXT_RULEPOS (rule_pos
);
20409 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20412 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20416 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20417 NEXT_RULEPOS (rule_pos
);
20418 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20419 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20422 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20423 NEXT_RULEPOS (rule_pos
);
20424 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20425 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20428 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20429 out_len
= mangle_dupechar (out
, out_len
);
20432 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20433 NEXT_RULEPOS (rule_pos
);
20434 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20435 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20438 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20439 NEXT_RULEPOS (rule_pos
);
20440 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20441 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20444 case RULE_OP_MANGLE_SWITCH_FIRST
:
20445 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20448 case RULE_OP_MANGLE_SWITCH_LAST
:
20449 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20452 case RULE_OP_MANGLE_SWITCH_AT
:
20453 NEXT_RULEPOS (rule_pos
);
20454 NEXT_RPTOI (rule
, rule_pos
, upos
);
20455 NEXT_RULEPOS (rule_pos
);
20456 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20457 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20460 case RULE_OP_MANGLE_CHR_SHIFTL
:
20461 NEXT_RULEPOS (rule_pos
);
20462 NEXT_RPTOI (rule
, rule_pos
, upos
);
20463 mangle_chr_shiftl (out
, out_len
, upos
);
20466 case RULE_OP_MANGLE_CHR_SHIFTR
:
20467 NEXT_RULEPOS (rule_pos
);
20468 NEXT_RPTOI (rule
, rule_pos
, upos
);
20469 mangle_chr_shiftr (out
, out_len
, upos
);
20472 case RULE_OP_MANGLE_CHR_INCR
:
20473 NEXT_RULEPOS (rule_pos
);
20474 NEXT_RPTOI (rule
, rule_pos
, upos
);
20475 mangle_chr_incr (out
, out_len
, upos
);
20478 case RULE_OP_MANGLE_CHR_DECR
:
20479 NEXT_RULEPOS (rule_pos
);
20480 NEXT_RPTOI (rule
, rule_pos
, upos
);
20481 mangle_chr_decr (out
, out_len
, upos
);
20484 case RULE_OP_MANGLE_REPLACE_NP1
:
20485 NEXT_RULEPOS (rule_pos
);
20486 NEXT_RPTOI (rule
, rule_pos
, upos
);
20487 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20490 case RULE_OP_MANGLE_REPLACE_NM1
:
20491 NEXT_RULEPOS (rule_pos
);
20492 NEXT_RPTOI (rule
, rule_pos
, upos
);
20493 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20496 case RULE_OP_MANGLE_TITLE
:
20497 out_len
= mangle_title (out
, out_len
);
20500 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20501 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20502 NEXT_RULEPOS (rule_pos
);
20503 NEXT_RPTOI (rule
, rule_pos
, upos
);
20504 NEXT_RULEPOS (rule_pos
);
20505 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20506 NEXT_RULEPOS (rule_pos
);
20507 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20508 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20511 case RULE_OP_MANGLE_APPEND_MEMORY
:
20512 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20513 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20514 memcpy (out
+ out_len
, mem
, mem_len
);
20515 out_len
+= mem_len
;
20518 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20519 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20520 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20521 memcpy (mem
+ mem_len
, out
, out_len
);
20522 out_len
+= mem_len
;
20523 memcpy (out
, mem
, out_len
);
20526 case RULE_OP_MEMORIZE_WORD
:
20527 memcpy (mem
, out
, out_len
);
20531 case RULE_OP_REJECT_LESS
:
20532 NEXT_RULEPOS (rule_pos
);
20533 NEXT_RPTOI (rule
, rule_pos
, upos
);
20534 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20537 case RULE_OP_REJECT_GREATER
:
20538 NEXT_RULEPOS (rule_pos
);
20539 NEXT_RPTOI (rule
, rule_pos
, upos
);
20540 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20543 case RULE_OP_REJECT_CONTAIN
:
20544 NEXT_RULEPOS (rule_pos
);
20545 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20548 case RULE_OP_REJECT_NOT_CONTAIN
:
20549 NEXT_RULEPOS (rule_pos
);
20550 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20553 case RULE_OP_REJECT_EQUAL_FIRST
:
20554 NEXT_RULEPOS (rule_pos
);
20555 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20558 case RULE_OP_REJECT_EQUAL_LAST
:
20559 NEXT_RULEPOS (rule_pos
);
20560 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20563 case RULE_OP_REJECT_EQUAL_AT
:
20564 NEXT_RULEPOS (rule_pos
);
20565 NEXT_RPTOI (rule
, rule_pos
, upos
);
20566 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20567 NEXT_RULEPOS (rule_pos
);
20568 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20571 case RULE_OP_REJECT_CONTAINS
:
20572 NEXT_RULEPOS (rule_pos
);
20573 NEXT_RPTOI (rule
, rule_pos
, upos
);
20574 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20575 NEXT_RULEPOS (rule_pos
);
20576 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20577 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20580 case RULE_OP_REJECT_MEMORY
:
20581 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20585 return (RULE_RC_SYNTAX_ERROR
);
20590 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);