2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
19 #define GET_ACCEL(x) KERNEL_ACCEL_ ## x
20 #define GET_LOOPS(x) KERNEL_LOOPS_ ## x
26 u32
rotl32 (const u32 a
, const u32 n
)
28 return ((a
<< n
) | (a
>> (32 - n
)));
31 u32
rotr32 (const u32 a
, const u32 n
)
33 return ((a
>> n
) | (a
<< (32 - n
)));
36 u64
rotl64 (const u64 a
, const u64 n
)
38 return ((a
<< n
) | (a
>> (64 - n
)));
41 u64
rotr64 (const u64 a
, const u64 n
)
43 return ((a
>> n
) | (a
<< (64 - n
)));
46 u32
byte_swap_32 (const u32 n
)
48 return (n
& 0xff000000) >> 24
49 | (n
& 0x00ff0000) >> 8
50 | (n
& 0x0000ff00) << 8
51 | (n
& 0x000000ff) << 24;
54 u64
byte_swap_64 (const u64 n
)
56 return (n
& 0xff00000000000000ULL
) >> 56
57 | (n
& 0x00ff000000000000ULL
) >> 40
58 | (n
& 0x0000ff0000000000ULL
) >> 24
59 | (n
& 0x000000ff00000000ULL
) >> 8
60 | (n
& 0x00000000ff000000ULL
) << 8
61 | (n
& 0x0000000000ff0000ULL
) << 24
62 | (n
& 0x000000000000ff00ULL
) << 40
63 | (n
& 0x00000000000000ffULL
) << 56;
67 * ciphers for use on cpu
74 * hashes for use on cpu
78 #include "cpu-sha256.c"
86 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
92 for (int i
= 0; i
< last_len
; i
++)
100 char s
[4096] = { 0 };
102 int max_len
= (int) sizeof (s
);
104 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
106 if (len
> max_len
) len
= max_len
;
108 fwrite (s
, len
, 1, fp
);
115 void log_out_nn (FILE *fp
, const char *fmt
, ...)
117 if (SUPPRESS_OUTPUT
) return;
123 log_final (fp
, fmt
, ap
);
128 void log_info_nn (const char *fmt
, ...)
130 if (SUPPRESS_OUTPUT
) return;
136 log_final (stdout
, fmt
, ap
);
141 void log_error_nn (const char *fmt
, ...)
143 if (SUPPRESS_OUTPUT
) return;
149 log_final (stderr
, fmt
, ap
);
154 void log_out (FILE *fp
, const char *fmt
, ...)
156 if (SUPPRESS_OUTPUT
) return;
162 log_final (fp
, fmt
, ap
);
171 void log_info (const char *fmt
, ...)
173 if (SUPPRESS_OUTPUT
) return;
179 log_final (stdout
, fmt
, ap
);
183 fputc ('\n', stdout
);
188 void log_error (const char *fmt
, ...)
190 if (SUPPRESS_OUTPUT
) return;
192 fputc ('\n', stderr
);
193 fputc ('\n', stderr
);
199 log_final (stderr
, fmt
, ap
);
203 fputc ('\n', stderr
);
204 fputc ('\n', stderr
);
213 u8
int_to_base32 (const u8 c
)
215 static const u8 tbl
[0x20] =
217 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
218 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
224 u8
base32_to_int (const u8 c
)
226 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
227 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
232 u8
int_to_itoa32 (const u8 c
)
234 static const u8 tbl
[0x20] =
236 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
237 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
243 u8
itoa32_to_int (const u8 c
)
245 if ((c
>= '0') && (c
<= '9')) return c
- '0';
246 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
251 u8
int_to_itoa64 (const u8 c
)
253 static const u8 tbl
[0x40] =
255 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
256 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
257 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
258 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
264 u8
itoa64_to_int (const u8 c
)
266 static const u8 tbl
[0x100] =
268 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
269 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
270 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
271 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
272 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
273 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
274 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
275 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
276 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
277 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
278 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
279 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
280 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
281 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
282 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
283 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
289 u8
int_to_base64 (const u8 c
)
291 static const u8 tbl
[0x40] =
293 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
294 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
295 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
296 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
302 u8
base64_to_int (const u8 c
)
304 static const u8 tbl
[0x100] =
306 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
308 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
309 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
310 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
311 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
313 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
327 u8
int_to_bf64 (const u8 c
)
329 static const u8 tbl
[0x40] =
331 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
332 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
333 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
334 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
340 u8
bf64_to_int (const u8 c
)
342 static const u8 tbl
[0x100] =
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
346 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
347 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
348 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
349 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
350 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
351 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
365 u8
int_to_lotus64 (const u8 c
)
367 if (c
< 10) return '0' + c
;
368 else if (c
< 36) return 'A' + c
- 10;
369 else if (c
< 62) return 'a' + c
- 36;
370 else if (c
== 62) return '+';
371 else if (c
== 63) return '/';
376 u8
lotus64_to_int (const u8 c
)
378 if ((c
>= '0') && (c
<= '9')) return c
- '0';
379 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
380 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
381 else if (c
== '+') return 62;
382 else if (c
== '/') return 63;
388 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
390 const u8
*in_ptr
= in_buf
;
392 u8
*out_ptr
= out_buf
;
394 for (int i
= 0; i
< in_len
; i
+= 8)
396 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
397 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
398 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
399 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
400 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
401 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
402 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
403 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
405 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
406 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
407 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
408 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
409 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
415 for (int i
= 0; i
< in_len
; i
++)
417 if (in_buf
[i
] != '=') continue;
422 int out_len
= (in_len
* 5) / 8;
427 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
429 const u8
*in_ptr
= in_buf
;
431 u8
*out_ptr
= out_buf
;
433 for (int i
= 0; i
< in_len
; i
+= 5)
435 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
436 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
437 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
438 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
439 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
440 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
441 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
442 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
444 out_ptr
[0] = out_val0
& 0x7f;
445 out_ptr
[1] = out_val1
& 0x7f;
446 out_ptr
[2] = out_val2
& 0x7f;
447 out_ptr
[3] = out_val3
& 0x7f;
448 out_ptr
[4] = out_val4
& 0x7f;
449 out_ptr
[5] = out_val5
& 0x7f;
450 out_ptr
[6] = out_val6
& 0x7f;
451 out_ptr
[7] = out_val7
& 0x7f;
457 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
461 out_buf
[out_len
] = '=';
469 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
471 const u8
*in_ptr
= in_buf
;
473 u8
*out_ptr
= out_buf
;
475 for (int i
= 0; i
< in_len
; i
+= 4)
477 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
478 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
479 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
480 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
482 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
483 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
484 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
490 for (int i
= 0; i
< in_len
; i
++)
492 if (in_buf
[i
] != '=') continue;
497 int out_len
= (in_len
* 6) / 8;
502 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
504 const u8
*in_ptr
= in_buf
;
506 u8
*out_ptr
= out_buf
;
508 for (int i
= 0; i
< in_len
; i
+= 3)
510 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
511 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
512 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
513 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
515 out_ptr
[0] = out_val0
& 0x7f;
516 out_ptr
[1] = out_val1
& 0x7f;
517 out_ptr
[2] = out_val2
& 0x7f;
518 out_ptr
[3] = out_val3
& 0x7f;
524 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
528 out_buf
[out_len
] = '=';
536 int is_valid_hex_char (const u8 c
)
538 if ((c
>= '0') && (c
<= '9')) return 1;
539 if ((c
>= 'A') && (c
<= 'F')) return 1;
540 if ((c
>= 'a') && (c
<= 'f')) return 1;
545 u8
hex_convert (const u8 c
)
547 return (c
& 15) + (c
>> 6) * 9;
550 u8
hex_to_u8 (const u8 hex
[2])
554 v
|= (hex_convert (hex
[1]) << 0);
555 v
|= (hex_convert (hex
[0]) << 4);
560 u32
hex_to_u32 (const u8 hex
[8])
564 v
|= ((u32
) hex_convert (hex
[7])) << 0;
565 v
|= ((u32
) hex_convert (hex
[6])) << 4;
566 v
|= ((u32
) hex_convert (hex
[5])) << 8;
567 v
|= ((u32
) hex_convert (hex
[4])) << 12;
568 v
|= ((u32
) hex_convert (hex
[3])) << 16;
569 v
|= ((u32
) hex_convert (hex
[2])) << 20;
570 v
|= ((u32
) hex_convert (hex
[1])) << 24;
571 v
|= ((u32
) hex_convert (hex
[0])) << 28;
576 u64
hex_to_u64 (const u8 hex
[16])
580 v
|= ((u64
) hex_convert (hex
[15]) << 0);
581 v
|= ((u64
) hex_convert (hex
[14]) << 4);
582 v
|= ((u64
) hex_convert (hex
[13]) << 8);
583 v
|= ((u64
) hex_convert (hex
[12]) << 12);
584 v
|= ((u64
) hex_convert (hex
[11]) << 16);
585 v
|= ((u64
) hex_convert (hex
[10]) << 20);
586 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
587 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
588 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
589 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
590 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
591 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
592 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
593 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
594 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
595 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
600 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
602 hex
[0] = v
>> 28 & 15;
603 hex
[1] = v
>> 24 & 15;
604 hex
[2] = v
>> 20 & 15;
605 hex
[3] = v
>> 16 & 15;
606 hex
[4] = v
>> 12 & 15;
607 hex
[5] = v
>> 8 & 15;
608 hex
[6] = v
>> 4 & 15;
609 hex
[7] = v
>> 0 & 15;
613 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
614 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
615 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
616 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
617 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
618 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
619 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
620 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
627 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
631 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
640 for (int i
= 0; i
< 16; i
+= 4)
650 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
657 out
[i
+ 0] = _out
[0];
658 out
[i
+ 1] = _out
[1];
659 out
[i
+ 2] = _out
[2];
660 out
[i
+ 3] = _out
[3];
669 static void juniper_decrypt_hash (char *in
, char *out
)
673 u8 base64_buf
[100] = { 0 };
675 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
679 u32 juniper_iv
[4] = { 0 };
681 memcpy (juniper_iv
, base64_buf
, 12);
683 memcpy (out
, juniper_iv
, 12);
687 u32 juniper_key
[4] = { 0 };
689 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
690 juniper_key
[1] = byte_swap_32 (0x8df91059);
691 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
692 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
696 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
697 u32
*out_ptr
= (u32
*) (out
+ 12);
699 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
702 void phpass_decode (u8 digest
[16], u8 buf
[22])
706 l
= itoa64_to_int (buf
[ 0]) << 0;
707 l
|= itoa64_to_int (buf
[ 1]) << 6;
708 l
|= itoa64_to_int (buf
[ 2]) << 12;
709 l
|= itoa64_to_int (buf
[ 3]) << 18;
711 digest
[ 0] = (l
>> 0) & 0xff;
712 digest
[ 1] = (l
>> 8) & 0xff;
713 digest
[ 2] = (l
>> 16) & 0xff;
715 l
= itoa64_to_int (buf
[ 4]) << 0;
716 l
|= itoa64_to_int (buf
[ 5]) << 6;
717 l
|= itoa64_to_int (buf
[ 6]) << 12;
718 l
|= itoa64_to_int (buf
[ 7]) << 18;
720 digest
[ 3] = (l
>> 0) & 0xff;
721 digest
[ 4] = (l
>> 8) & 0xff;
722 digest
[ 5] = (l
>> 16) & 0xff;
724 l
= itoa64_to_int (buf
[ 8]) << 0;
725 l
|= itoa64_to_int (buf
[ 9]) << 6;
726 l
|= itoa64_to_int (buf
[10]) << 12;
727 l
|= itoa64_to_int (buf
[11]) << 18;
729 digest
[ 6] = (l
>> 0) & 0xff;
730 digest
[ 7] = (l
>> 8) & 0xff;
731 digest
[ 8] = (l
>> 16) & 0xff;
733 l
= itoa64_to_int (buf
[12]) << 0;
734 l
|= itoa64_to_int (buf
[13]) << 6;
735 l
|= itoa64_to_int (buf
[14]) << 12;
736 l
|= itoa64_to_int (buf
[15]) << 18;
738 digest
[ 9] = (l
>> 0) & 0xff;
739 digest
[10] = (l
>> 8) & 0xff;
740 digest
[11] = (l
>> 16) & 0xff;
742 l
= itoa64_to_int (buf
[16]) << 0;
743 l
|= itoa64_to_int (buf
[17]) << 6;
744 l
|= itoa64_to_int (buf
[18]) << 12;
745 l
|= itoa64_to_int (buf
[19]) << 18;
747 digest
[12] = (l
>> 0) & 0xff;
748 digest
[13] = (l
>> 8) & 0xff;
749 digest
[14] = (l
>> 16) & 0xff;
751 l
= itoa64_to_int (buf
[20]) << 0;
752 l
|= itoa64_to_int (buf
[21]) << 6;
754 digest
[15] = (l
>> 0) & 0xff;
757 void phpass_encode (u8 digest
[16], u8 buf
[22])
761 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
763 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
766 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
768 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
770 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
773 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
775 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
777 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[11] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
784 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[15] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
791 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[19] = int_to_itoa64 (l
& 0x3f);
796 l
= (digest
[15] << 0);
798 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[21] = int_to_itoa64 (l
& 0x3f);
802 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
806 l
= itoa64_to_int (buf
[ 0]) << 0;
807 l
|= itoa64_to_int (buf
[ 1]) << 6;
808 l
|= itoa64_to_int (buf
[ 2]) << 12;
809 l
|= itoa64_to_int (buf
[ 3]) << 18;
811 digest
[ 0] = (l
>> 16) & 0xff;
812 digest
[ 6] = (l
>> 8) & 0xff;
813 digest
[12] = (l
>> 0) & 0xff;
815 l
= itoa64_to_int (buf
[ 4]) << 0;
816 l
|= itoa64_to_int (buf
[ 5]) << 6;
817 l
|= itoa64_to_int (buf
[ 6]) << 12;
818 l
|= itoa64_to_int (buf
[ 7]) << 18;
820 digest
[ 1] = (l
>> 16) & 0xff;
821 digest
[ 7] = (l
>> 8) & 0xff;
822 digest
[13] = (l
>> 0) & 0xff;
824 l
= itoa64_to_int (buf
[ 8]) << 0;
825 l
|= itoa64_to_int (buf
[ 9]) << 6;
826 l
|= itoa64_to_int (buf
[10]) << 12;
827 l
|= itoa64_to_int (buf
[11]) << 18;
829 digest
[ 2] = (l
>> 16) & 0xff;
830 digest
[ 8] = (l
>> 8) & 0xff;
831 digest
[14] = (l
>> 0) & 0xff;
833 l
= itoa64_to_int (buf
[12]) << 0;
834 l
|= itoa64_to_int (buf
[13]) << 6;
835 l
|= itoa64_to_int (buf
[14]) << 12;
836 l
|= itoa64_to_int (buf
[15]) << 18;
838 digest
[ 3] = (l
>> 16) & 0xff;
839 digest
[ 9] = (l
>> 8) & 0xff;
840 digest
[15] = (l
>> 0) & 0xff;
842 l
= itoa64_to_int (buf
[16]) << 0;
843 l
|= itoa64_to_int (buf
[17]) << 6;
844 l
|= itoa64_to_int (buf
[18]) << 12;
845 l
|= itoa64_to_int (buf
[19]) << 18;
847 digest
[ 4] = (l
>> 16) & 0xff;
848 digest
[10] = (l
>> 8) & 0xff;
849 digest
[ 5] = (l
>> 0) & 0xff;
851 l
= itoa64_to_int (buf
[20]) << 0;
852 l
|= itoa64_to_int (buf
[21]) << 6;
854 digest
[11] = (l
>> 0) & 0xff;
857 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
861 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
863 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
866 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
870 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
873 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
877 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
884 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
891 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 l
= (digest
[11] << 0);
898 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
902 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
906 l
= itoa64_to_int (buf
[ 0]) << 0;
907 l
|= itoa64_to_int (buf
[ 1]) << 6;
908 l
|= itoa64_to_int (buf
[ 2]) << 12;
909 l
|= itoa64_to_int (buf
[ 3]) << 18;
911 digest
[ 0] = (l
>> 16) & 0xff;
912 digest
[21] = (l
>> 8) & 0xff;
913 digest
[42] = (l
>> 0) & 0xff;
915 l
= itoa64_to_int (buf
[ 4]) << 0;
916 l
|= itoa64_to_int (buf
[ 5]) << 6;
917 l
|= itoa64_to_int (buf
[ 6]) << 12;
918 l
|= itoa64_to_int (buf
[ 7]) << 18;
920 digest
[22] = (l
>> 16) & 0xff;
921 digest
[43] = (l
>> 8) & 0xff;
922 digest
[ 1] = (l
>> 0) & 0xff;
924 l
= itoa64_to_int (buf
[ 8]) << 0;
925 l
|= itoa64_to_int (buf
[ 9]) << 6;
926 l
|= itoa64_to_int (buf
[10]) << 12;
927 l
|= itoa64_to_int (buf
[11]) << 18;
929 digest
[44] = (l
>> 16) & 0xff;
930 digest
[ 2] = (l
>> 8) & 0xff;
931 digest
[23] = (l
>> 0) & 0xff;
933 l
= itoa64_to_int (buf
[12]) << 0;
934 l
|= itoa64_to_int (buf
[13]) << 6;
935 l
|= itoa64_to_int (buf
[14]) << 12;
936 l
|= itoa64_to_int (buf
[15]) << 18;
938 digest
[ 3] = (l
>> 16) & 0xff;
939 digest
[24] = (l
>> 8) & 0xff;
940 digest
[45] = (l
>> 0) & 0xff;
942 l
= itoa64_to_int (buf
[16]) << 0;
943 l
|= itoa64_to_int (buf
[17]) << 6;
944 l
|= itoa64_to_int (buf
[18]) << 12;
945 l
|= itoa64_to_int (buf
[19]) << 18;
947 digest
[25] = (l
>> 16) & 0xff;
948 digest
[46] = (l
>> 8) & 0xff;
949 digest
[ 4] = (l
>> 0) & 0xff;
951 l
= itoa64_to_int (buf
[20]) << 0;
952 l
|= itoa64_to_int (buf
[21]) << 6;
953 l
|= itoa64_to_int (buf
[22]) << 12;
954 l
|= itoa64_to_int (buf
[23]) << 18;
956 digest
[47] = (l
>> 16) & 0xff;
957 digest
[ 5] = (l
>> 8) & 0xff;
958 digest
[26] = (l
>> 0) & 0xff;
960 l
= itoa64_to_int (buf
[24]) << 0;
961 l
|= itoa64_to_int (buf
[25]) << 6;
962 l
|= itoa64_to_int (buf
[26]) << 12;
963 l
|= itoa64_to_int (buf
[27]) << 18;
965 digest
[ 6] = (l
>> 16) & 0xff;
966 digest
[27] = (l
>> 8) & 0xff;
967 digest
[48] = (l
>> 0) & 0xff;
969 l
= itoa64_to_int (buf
[28]) << 0;
970 l
|= itoa64_to_int (buf
[29]) << 6;
971 l
|= itoa64_to_int (buf
[30]) << 12;
972 l
|= itoa64_to_int (buf
[31]) << 18;
974 digest
[28] = (l
>> 16) & 0xff;
975 digest
[49] = (l
>> 8) & 0xff;
976 digest
[ 7] = (l
>> 0) & 0xff;
978 l
= itoa64_to_int (buf
[32]) << 0;
979 l
|= itoa64_to_int (buf
[33]) << 6;
980 l
|= itoa64_to_int (buf
[34]) << 12;
981 l
|= itoa64_to_int (buf
[35]) << 18;
983 digest
[50] = (l
>> 16) & 0xff;
984 digest
[ 8] = (l
>> 8) & 0xff;
985 digest
[29] = (l
>> 0) & 0xff;
987 l
= itoa64_to_int (buf
[36]) << 0;
988 l
|= itoa64_to_int (buf
[37]) << 6;
989 l
|= itoa64_to_int (buf
[38]) << 12;
990 l
|= itoa64_to_int (buf
[39]) << 18;
992 digest
[ 9] = (l
>> 16) & 0xff;
993 digest
[30] = (l
>> 8) & 0xff;
994 digest
[51] = (l
>> 0) & 0xff;
996 l
= itoa64_to_int (buf
[40]) << 0;
997 l
|= itoa64_to_int (buf
[41]) << 6;
998 l
|= itoa64_to_int (buf
[42]) << 12;
999 l
|= itoa64_to_int (buf
[43]) << 18;
1001 digest
[31] = (l
>> 16) & 0xff;
1002 digest
[52] = (l
>> 8) & 0xff;
1003 digest
[10] = (l
>> 0) & 0xff;
1005 l
= itoa64_to_int (buf
[44]) << 0;
1006 l
|= itoa64_to_int (buf
[45]) << 6;
1007 l
|= itoa64_to_int (buf
[46]) << 12;
1008 l
|= itoa64_to_int (buf
[47]) << 18;
1010 digest
[53] = (l
>> 16) & 0xff;
1011 digest
[11] = (l
>> 8) & 0xff;
1012 digest
[32] = (l
>> 0) & 0xff;
1014 l
= itoa64_to_int (buf
[48]) << 0;
1015 l
|= itoa64_to_int (buf
[49]) << 6;
1016 l
|= itoa64_to_int (buf
[50]) << 12;
1017 l
|= itoa64_to_int (buf
[51]) << 18;
1019 digest
[12] = (l
>> 16) & 0xff;
1020 digest
[33] = (l
>> 8) & 0xff;
1021 digest
[54] = (l
>> 0) & 0xff;
1023 l
= itoa64_to_int (buf
[52]) << 0;
1024 l
|= itoa64_to_int (buf
[53]) << 6;
1025 l
|= itoa64_to_int (buf
[54]) << 12;
1026 l
|= itoa64_to_int (buf
[55]) << 18;
1028 digest
[34] = (l
>> 16) & 0xff;
1029 digest
[55] = (l
>> 8) & 0xff;
1030 digest
[13] = (l
>> 0) & 0xff;
1032 l
= itoa64_to_int (buf
[56]) << 0;
1033 l
|= itoa64_to_int (buf
[57]) << 6;
1034 l
|= itoa64_to_int (buf
[58]) << 12;
1035 l
|= itoa64_to_int (buf
[59]) << 18;
1037 digest
[56] = (l
>> 16) & 0xff;
1038 digest
[14] = (l
>> 8) & 0xff;
1039 digest
[35] = (l
>> 0) & 0xff;
1041 l
= itoa64_to_int (buf
[60]) << 0;
1042 l
|= itoa64_to_int (buf
[61]) << 6;
1043 l
|= itoa64_to_int (buf
[62]) << 12;
1044 l
|= itoa64_to_int (buf
[63]) << 18;
1046 digest
[15] = (l
>> 16) & 0xff;
1047 digest
[36] = (l
>> 8) & 0xff;
1048 digest
[57] = (l
>> 0) & 0xff;
1050 l
= itoa64_to_int (buf
[64]) << 0;
1051 l
|= itoa64_to_int (buf
[65]) << 6;
1052 l
|= itoa64_to_int (buf
[66]) << 12;
1053 l
|= itoa64_to_int (buf
[67]) << 18;
1055 digest
[37] = (l
>> 16) & 0xff;
1056 digest
[58] = (l
>> 8) & 0xff;
1057 digest
[16] = (l
>> 0) & 0xff;
1059 l
= itoa64_to_int (buf
[68]) << 0;
1060 l
|= itoa64_to_int (buf
[69]) << 6;
1061 l
|= itoa64_to_int (buf
[70]) << 12;
1062 l
|= itoa64_to_int (buf
[71]) << 18;
1064 digest
[59] = (l
>> 16) & 0xff;
1065 digest
[17] = (l
>> 8) & 0xff;
1066 digest
[38] = (l
>> 0) & 0xff;
1068 l
= itoa64_to_int (buf
[72]) << 0;
1069 l
|= itoa64_to_int (buf
[73]) << 6;
1070 l
|= itoa64_to_int (buf
[74]) << 12;
1071 l
|= itoa64_to_int (buf
[75]) << 18;
1073 digest
[18] = (l
>> 16) & 0xff;
1074 digest
[39] = (l
>> 8) & 0xff;
1075 digest
[60] = (l
>> 0) & 0xff;
1077 l
= itoa64_to_int (buf
[76]) << 0;
1078 l
|= itoa64_to_int (buf
[77]) << 6;
1079 l
|= itoa64_to_int (buf
[78]) << 12;
1080 l
|= itoa64_to_int (buf
[79]) << 18;
1082 digest
[40] = (l
>> 16) & 0xff;
1083 digest
[61] = (l
>> 8) & 0xff;
1084 digest
[19] = (l
>> 0) & 0xff;
1086 l
= itoa64_to_int (buf
[80]) << 0;
1087 l
|= itoa64_to_int (buf
[81]) << 6;
1088 l
|= itoa64_to_int (buf
[82]) << 12;
1089 l
|= itoa64_to_int (buf
[83]) << 18;
1091 digest
[62] = (l
>> 16) & 0xff;
1092 digest
[20] = (l
>> 8) & 0xff;
1093 digest
[41] = (l
>> 0) & 0xff;
1095 l
= itoa64_to_int (buf
[84]) << 0;
1096 l
|= itoa64_to_int (buf
[85]) << 6;
1098 digest
[63] = (l
>> 0) & 0xff;
1101 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1105 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1107 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1110 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1114 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1117 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1121 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1128 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1135 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1142 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1149 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1156 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1163 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1170 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1177 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1184 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1191 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1198 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1205 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1212 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1219 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1226 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1233 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1240 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1247 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 l
= 0 | 0 | (digest
[63] << 0);
1254 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1258 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1262 l
= itoa64_to_int (buf
[ 0]) << 0;
1263 l
|= itoa64_to_int (buf
[ 1]) << 6;
1264 l
|= itoa64_to_int (buf
[ 2]) << 12;
1265 l
|= itoa64_to_int (buf
[ 3]) << 18;
1267 digest
[ 2] = (l
>> 0) & 0xff;
1268 digest
[ 1] = (l
>> 8) & 0xff;
1269 digest
[ 0] = (l
>> 16) & 0xff;
1271 l
= itoa64_to_int (buf
[ 4]) << 0;
1272 l
|= itoa64_to_int (buf
[ 5]) << 6;
1273 l
|= itoa64_to_int (buf
[ 6]) << 12;
1274 l
|= itoa64_to_int (buf
[ 7]) << 18;
1276 digest
[ 5] = (l
>> 0) & 0xff;
1277 digest
[ 4] = (l
>> 8) & 0xff;
1278 digest
[ 3] = (l
>> 16) & 0xff;
1280 l
= itoa64_to_int (buf
[ 8]) << 0;
1281 l
|= itoa64_to_int (buf
[ 9]) << 6;
1282 l
|= itoa64_to_int (buf
[10]) << 12;
1283 l
|= itoa64_to_int (buf
[11]) << 18;
1285 digest
[ 8] = (l
>> 0) & 0xff;
1286 digest
[ 7] = (l
>> 8) & 0xff;
1287 digest
[ 6] = (l
>> 16) & 0xff;
1289 l
= itoa64_to_int (buf
[12]) << 0;
1290 l
|= itoa64_to_int (buf
[13]) << 6;
1291 l
|= itoa64_to_int (buf
[14]) << 12;
1292 l
|= itoa64_to_int (buf
[15]) << 18;
1294 digest
[11] = (l
>> 0) & 0xff;
1295 digest
[10] = (l
>> 8) & 0xff;
1296 digest
[ 9] = (l
>> 16) & 0xff;
1298 l
= itoa64_to_int (buf
[16]) << 0;
1299 l
|= itoa64_to_int (buf
[17]) << 6;
1300 l
|= itoa64_to_int (buf
[18]) << 12;
1301 l
|= itoa64_to_int (buf
[19]) << 18;
1303 digest
[14] = (l
>> 0) & 0xff;
1304 digest
[13] = (l
>> 8) & 0xff;
1305 digest
[12] = (l
>> 16) & 0xff;
1307 l
= itoa64_to_int (buf
[20]) << 0;
1308 l
|= itoa64_to_int (buf
[21]) << 6;
1309 l
|= itoa64_to_int (buf
[22]) << 12;
1310 l
|= itoa64_to_int (buf
[23]) << 18;
1312 digest
[17] = (l
>> 0) & 0xff;
1313 digest
[16] = (l
>> 8) & 0xff;
1314 digest
[15] = (l
>> 16) & 0xff;
1316 l
= itoa64_to_int (buf
[24]) << 0;
1317 l
|= itoa64_to_int (buf
[25]) << 6;
1318 l
|= itoa64_to_int (buf
[26]) << 12;
1320 digest
[19] = (l
>> 8) & 0xff;
1321 digest
[18] = (l
>> 16) & 0xff;
1324 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1328 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1330 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1333 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1335 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1337 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1340 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1342 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1344 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[11] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1351 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[15] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1358 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[19] = int_to_itoa64 (l
& 0x3f);
1363 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1365 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[23] = int_to_itoa64 (l
& 0x3f);
1370 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1372 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1374 buf
[26] = int_to_itoa64 (l
& 0x3f);
1377 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1381 l
= itoa64_to_int (buf
[ 0]) << 0;
1382 l
|= itoa64_to_int (buf
[ 1]) << 6;
1383 l
|= itoa64_to_int (buf
[ 2]) << 12;
1384 l
|= itoa64_to_int (buf
[ 3]) << 18;
1386 digest
[ 2] = (l
>> 0) & 0xff;
1387 digest
[ 1] = (l
>> 8) & 0xff;
1388 digest
[ 0] = (l
>> 16) & 0xff;
1390 l
= itoa64_to_int (buf
[ 4]) << 0;
1391 l
|= itoa64_to_int (buf
[ 5]) << 6;
1392 l
|= itoa64_to_int (buf
[ 6]) << 12;
1393 l
|= itoa64_to_int (buf
[ 7]) << 18;
1395 digest
[ 5] = (l
>> 0) & 0xff;
1396 digest
[ 4] = (l
>> 8) & 0xff;
1397 digest
[ 3] = (l
>> 16) & 0xff;
1399 l
= itoa64_to_int (buf
[ 8]) << 0;
1400 l
|= itoa64_to_int (buf
[ 9]) << 6;
1401 l
|= itoa64_to_int (buf
[10]) << 12;
1402 l
|= itoa64_to_int (buf
[11]) << 18;
1404 digest
[ 8] = (l
>> 0) & 0xff;
1405 digest
[ 7] = (l
>> 8) & 0xff;
1406 digest
[ 6] = (l
>> 16) & 0xff;
1408 l
= itoa64_to_int (buf
[12]) << 0;
1409 l
|= itoa64_to_int (buf
[13]) << 6;
1410 l
|= itoa64_to_int (buf
[14]) << 12;
1411 l
|= itoa64_to_int (buf
[15]) << 18;
1413 digest
[11] = (l
>> 0) & 0xff;
1414 digest
[10] = (l
>> 8) & 0xff;
1415 digest
[ 9] = (l
>> 16) & 0xff;
1417 l
= itoa64_to_int (buf
[16]) << 0;
1418 l
|= itoa64_to_int (buf
[17]) << 6;
1419 l
|= itoa64_to_int (buf
[18]) << 12;
1420 l
|= itoa64_to_int (buf
[19]) << 18;
1422 digest
[14] = (l
>> 0) & 0xff;
1423 digest
[13] = (l
>> 8) & 0xff;
1424 digest
[12] = (l
>> 16) & 0xff;
1426 l
= itoa64_to_int (buf
[20]) << 0;
1427 l
|= itoa64_to_int (buf
[21]) << 6;
1428 l
|= itoa64_to_int (buf
[22]) << 12;
1429 l
|= itoa64_to_int (buf
[23]) << 18;
1431 digest
[17] = (l
>> 0) & 0xff;
1432 digest
[16] = (l
>> 8) & 0xff;
1433 digest
[15] = (l
>> 16) & 0xff;
1435 l
= itoa64_to_int (buf
[24]) << 0;
1436 l
|= itoa64_to_int (buf
[25]) << 6;
1437 l
|= itoa64_to_int (buf
[26]) << 12;
1438 l
|= itoa64_to_int (buf
[27]) << 18;
1440 digest
[20] = (l
>> 0) & 0xff;
1441 digest
[19] = (l
>> 8) & 0xff;
1442 digest
[18] = (l
>> 16) & 0xff;
1444 l
= itoa64_to_int (buf
[28]) << 0;
1445 l
|= itoa64_to_int (buf
[29]) << 6;
1446 l
|= itoa64_to_int (buf
[30]) << 12;
1447 l
|= itoa64_to_int (buf
[31]) << 18;
1449 digest
[23] = (l
>> 0) & 0xff;
1450 digest
[22] = (l
>> 8) & 0xff;
1451 digest
[21] = (l
>> 16) & 0xff;
1453 l
= itoa64_to_int (buf
[32]) << 0;
1454 l
|= itoa64_to_int (buf
[33]) << 6;
1455 l
|= itoa64_to_int (buf
[34]) << 12;
1456 l
|= itoa64_to_int (buf
[35]) << 18;
1458 digest
[26] = (l
>> 0) & 0xff;
1459 digest
[25] = (l
>> 8) & 0xff;
1460 digest
[24] = (l
>> 16) & 0xff;
1462 l
= itoa64_to_int (buf
[36]) << 0;
1463 l
|= itoa64_to_int (buf
[37]) << 6;
1464 l
|= itoa64_to_int (buf
[38]) << 12;
1465 l
|= itoa64_to_int (buf
[39]) << 18;
1467 digest
[29] = (l
>> 0) & 0xff;
1468 digest
[28] = (l
>> 8) & 0xff;
1469 digest
[27] = (l
>> 16) & 0xff;
1471 l
= itoa64_to_int (buf
[40]) << 0;
1472 l
|= itoa64_to_int (buf
[41]) << 6;
1473 l
|= itoa64_to_int (buf
[42]) << 12;
1475 //digest[32] = (l >> 0) & 0xff;
1476 digest
[31] = (l
>> 8) & 0xff;
1477 digest
[30] = (l
>> 16) & 0xff;
1480 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1484 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1486 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1489 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1491 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1493 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1496 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1498 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1500 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[11] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1507 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[15] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1514 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[19] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1521 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[23] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1528 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[27] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1535 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[31] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1542 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[35] = int_to_itoa64 (l
& 0x3f);
1547 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1549 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[39] = int_to_itoa64 (l
& 0x3f);
1554 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1556 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1558 buf
[42] = int_to_itoa64 (l
& 0x3f);
1561 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1565 l
= itoa64_to_int (buf
[ 0]) << 0;
1566 l
|= itoa64_to_int (buf
[ 1]) << 6;
1567 l
|= itoa64_to_int (buf
[ 2]) << 12;
1568 l
|= itoa64_to_int (buf
[ 3]) << 18;
1570 digest
[ 2] = (l
>> 0) & 0xff;
1571 digest
[ 1] = (l
>> 8) & 0xff;
1572 digest
[ 0] = (l
>> 16) & 0xff;
1574 l
= itoa64_to_int (buf
[ 4]) << 0;
1575 l
|= itoa64_to_int (buf
[ 5]) << 6;
1576 l
|= itoa64_to_int (buf
[ 6]) << 12;
1577 l
|= itoa64_to_int (buf
[ 7]) << 18;
1579 digest
[ 5] = (l
>> 0) & 0xff;
1580 digest
[ 4] = (l
>> 8) & 0xff;
1581 digest
[ 3] = (l
>> 16) & 0xff;
1583 l
= itoa64_to_int (buf
[ 8]) << 0;
1584 l
|= itoa64_to_int (buf
[ 9]) << 6;
1585 l
|= itoa64_to_int (buf
[10]) << 12;
1586 l
|= itoa64_to_int (buf
[11]) << 18;
1588 digest
[ 8] = (l
>> 0) & 0xff;
1589 digest
[ 7] = (l
>> 8) & 0xff;
1590 digest
[ 6] = (l
>> 16) & 0xff;
1592 l
= itoa64_to_int (buf
[12]) << 0;
1593 l
|= itoa64_to_int (buf
[13]) << 6;
1594 l
|= itoa64_to_int (buf
[14]) << 12;
1595 l
|= itoa64_to_int (buf
[15]) << 18;
1597 digest
[11] = (l
>> 0) & 0xff;
1598 digest
[10] = (l
>> 8) & 0xff;
1599 digest
[ 9] = (l
>> 16) & 0xff;
1601 l
= itoa64_to_int (buf
[16]) << 0;
1602 l
|= itoa64_to_int (buf
[17]) << 6;
1603 l
|= itoa64_to_int (buf
[18]) << 12;
1604 l
|= itoa64_to_int (buf
[19]) << 18;
1606 digest
[14] = (l
>> 0) & 0xff;
1607 digest
[13] = (l
>> 8) & 0xff;
1608 digest
[12] = (l
>> 16) & 0xff;
1610 l
= itoa64_to_int (buf
[20]) << 0;
1611 l
|= itoa64_to_int (buf
[21]) << 6;
1612 l
|= itoa64_to_int (buf
[22]) << 12;
1613 l
|= itoa64_to_int (buf
[23]) << 18;
1615 digest
[17] = (l
>> 0) & 0xff;
1616 digest
[16] = (l
>> 8) & 0xff;
1617 digest
[15] = (l
>> 16) & 0xff;
1619 l
= itoa64_to_int (buf
[24]) << 0;
1620 l
|= itoa64_to_int (buf
[25]) << 6;
1621 l
|= itoa64_to_int (buf
[26]) << 12;
1622 l
|= itoa64_to_int (buf
[27]) << 18;
1624 digest
[20] = (l
>> 0) & 0xff;
1625 digest
[19] = (l
>> 8) & 0xff;
1626 digest
[18] = (l
>> 16) & 0xff;
1628 l
= itoa64_to_int (buf
[28]) << 0;
1629 l
|= itoa64_to_int (buf
[29]) << 6;
1630 l
|= itoa64_to_int (buf
[30]) << 12;
1631 l
|= itoa64_to_int (buf
[31]) << 18;
1633 digest
[23] = (l
>> 0) & 0xff;
1634 digest
[22] = (l
>> 8) & 0xff;
1635 digest
[21] = (l
>> 16) & 0xff;
1637 l
= itoa64_to_int (buf
[32]) << 0;
1638 l
|= itoa64_to_int (buf
[33]) << 6;
1639 l
|= itoa64_to_int (buf
[34]) << 12;
1640 l
|= itoa64_to_int (buf
[35]) << 18;
1642 digest
[26] = (l
>> 0) & 0xff;
1643 digest
[25] = (l
>> 8) & 0xff;
1644 digest
[24] = (l
>> 16) & 0xff;
1646 l
= itoa64_to_int (buf
[36]) << 0;
1647 l
|= itoa64_to_int (buf
[37]) << 6;
1648 l
|= itoa64_to_int (buf
[38]) << 12;
1649 l
|= itoa64_to_int (buf
[39]) << 18;
1651 digest
[29] = (l
>> 0) & 0xff;
1652 digest
[28] = (l
>> 8) & 0xff;
1653 digest
[27] = (l
>> 16) & 0xff;
1655 l
= itoa64_to_int (buf
[40]) << 0;
1656 l
|= itoa64_to_int (buf
[41]) << 6;
1657 l
|= itoa64_to_int (buf
[42]) << 12;
1658 l
|= itoa64_to_int (buf
[43]) << 18;
1660 digest
[32] = (l
>> 0) & 0xff;
1661 digest
[31] = (l
>> 8) & 0xff;
1662 digest
[30] = (l
>> 16) & 0xff;
1664 l
= itoa64_to_int (buf
[44]) << 0;
1665 l
|= itoa64_to_int (buf
[45]) << 6;
1666 l
|= itoa64_to_int (buf
[46]) << 12;
1667 l
|= itoa64_to_int (buf
[47]) << 18;
1669 digest
[35] = (l
>> 0) & 0xff;
1670 digest
[34] = (l
>> 8) & 0xff;
1671 digest
[33] = (l
>> 16) & 0xff;
1673 l
= itoa64_to_int (buf
[48]) << 0;
1674 l
|= itoa64_to_int (buf
[49]) << 6;
1675 l
|= itoa64_to_int (buf
[50]) << 12;
1676 l
|= itoa64_to_int (buf
[51]) << 18;
1678 digest
[38] = (l
>> 0) & 0xff;
1679 digest
[37] = (l
>> 8) & 0xff;
1680 digest
[36] = (l
>> 16) & 0xff;
1682 l
= itoa64_to_int (buf
[52]) << 0;
1683 l
|= itoa64_to_int (buf
[53]) << 6;
1684 l
|= itoa64_to_int (buf
[54]) << 12;
1685 l
|= itoa64_to_int (buf
[55]) << 18;
1687 digest
[41] = (l
>> 0) & 0xff;
1688 digest
[40] = (l
>> 8) & 0xff;
1689 digest
[39] = (l
>> 16) & 0xff;
1691 l
= itoa64_to_int (buf
[56]) << 0;
1692 l
|= itoa64_to_int (buf
[57]) << 6;
1693 l
|= itoa64_to_int (buf
[58]) << 12;
1694 l
|= itoa64_to_int (buf
[59]) << 18;
1696 digest
[44] = (l
>> 0) & 0xff;
1697 digest
[43] = (l
>> 8) & 0xff;
1698 digest
[42] = (l
>> 16) & 0xff;
1700 l
= itoa64_to_int (buf
[60]) << 0;
1701 l
|= itoa64_to_int (buf
[61]) << 6;
1702 l
|= itoa64_to_int (buf
[62]) << 12;
1703 l
|= itoa64_to_int (buf
[63]) << 18;
1705 digest
[47] = (l
>> 0) & 0xff;
1706 digest
[46] = (l
>> 8) & 0xff;
1707 digest
[45] = (l
>> 16) & 0xff;
1709 l
= itoa64_to_int (buf
[64]) << 0;
1710 l
|= itoa64_to_int (buf
[65]) << 6;
1711 l
|= itoa64_to_int (buf
[66]) << 12;
1712 l
|= itoa64_to_int (buf
[67]) << 18;
1714 digest
[50] = (l
>> 0) & 0xff;
1715 digest
[49] = (l
>> 8) & 0xff;
1716 digest
[48] = (l
>> 16) & 0xff;
1718 l
= itoa64_to_int (buf
[68]) << 0;
1719 l
|= itoa64_to_int (buf
[69]) << 6;
1720 l
|= itoa64_to_int (buf
[70]) << 12;
1721 l
|= itoa64_to_int (buf
[71]) << 18;
1723 digest
[53] = (l
>> 0) & 0xff;
1724 digest
[52] = (l
>> 8) & 0xff;
1725 digest
[51] = (l
>> 16) & 0xff;
1727 l
= itoa64_to_int (buf
[72]) << 0;
1728 l
|= itoa64_to_int (buf
[73]) << 6;
1729 l
|= itoa64_to_int (buf
[74]) << 12;
1730 l
|= itoa64_to_int (buf
[75]) << 18;
1732 digest
[56] = (l
>> 0) & 0xff;
1733 digest
[55] = (l
>> 8) & 0xff;
1734 digest
[54] = (l
>> 16) & 0xff;
1736 l
= itoa64_to_int (buf
[76]) << 0;
1737 l
|= itoa64_to_int (buf
[77]) << 6;
1738 l
|= itoa64_to_int (buf
[78]) << 12;
1739 l
|= itoa64_to_int (buf
[79]) << 18;
1741 digest
[59] = (l
>> 0) & 0xff;
1742 digest
[58] = (l
>> 8) & 0xff;
1743 digest
[57] = (l
>> 16) & 0xff;
1745 l
= itoa64_to_int (buf
[80]) << 0;
1746 l
|= itoa64_to_int (buf
[81]) << 6;
1747 l
|= itoa64_to_int (buf
[82]) << 12;
1748 l
|= itoa64_to_int (buf
[83]) << 18;
1750 digest
[62] = (l
>> 0) & 0xff;
1751 digest
[61] = (l
>> 8) & 0xff;
1752 digest
[60] = (l
>> 16) & 0xff;
1754 l
= itoa64_to_int (buf
[84]) << 0;
1755 l
|= itoa64_to_int (buf
[85]) << 6;
1757 digest
[63] = (l
>> 16) & 0xff;
1760 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1764 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1766 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1769 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1771 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1773 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1776 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1778 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1780 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[11] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1787 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[15] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1794 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[19] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1801 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[23] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1808 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[27] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1815 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[31] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1822 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[35] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1829 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[39] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1836 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[43] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1843 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[47] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1850 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[51] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1857 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[55] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1864 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[59] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1871 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[63] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1878 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[67] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1885 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[71] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1892 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[75] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1899 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[79] = int_to_itoa64 (l
& 0x3f);
1904 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1906 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[83] = int_to_itoa64 (l
& 0x3f);
1911 l
= 0 | 0 | (digest
[63] << 16);
1913 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1917 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1921 l
= itoa64_to_int (buf
[ 0]) << 0;
1922 l
|= itoa64_to_int (buf
[ 1]) << 6;
1923 l
|= itoa64_to_int (buf
[ 2]) << 12;
1924 l
|= itoa64_to_int (buf
[ 3]) << 18;
1926 digest
[ 0] = (l
>> 16) & 0xff;
1927 digest
[10] = (l
>> 8) & 0xff;
1928 digest
[20] = (l
>> 0) & 0xff;
1930 l
= itoa64_to_int (buf
[ 4]) << 0;
1931 l
|= itoa64_to_int (buf
[ 5]) << 6;
1932 l
|= itoa64_to_int (buf
[ 6]) << 12;
1933 l
|= itoa64_to_int (buf
[ 7]) << 18;
1935 digest
[21] = (l
>> 16) & 0xff;
1936 digest
[ 1] = (l
>> 8) & 0xff;
1937 digest
[11] = (l
>> 0) & 0xff;
1939 l
= itoa64_to_int (buf
[ 8]) << 0;
1940 l
|= itoa64_to_int (buf
[ 9]) << 6;
1941 l
|= itoa64_to_int (buf
[10]) << 12;
1942 l
|= itoa64_to_int (buf
[11]) << 18;
1944 digest
[12] = (l
>> 16) & 0xff;
1945 digest
[22] = (l
>> 8) & 0xff;
1946 digest
[ 2] = (l
>> 0) & 0xff;
1948 l
= itoa64_to_int (buf
[12]) << 0;
1949 l
|= itoa64_to_int (buf
[13]) << 6;
1950 l
|= itoa64_to_int (buf
[14]) << 12;
1951 l
|= itoa64_to_int (buf
[15]) << 18;
1953 digest
[ 3] = (l
>> 16) & 0xff;
1954 digest
[13] = (l
>> 8) & 0xff;
1955 digest
[23] = (l
>> 0) & 0xff;
1957 l
= itoa64_to_int (buf
[16]) << 0;
1958 l
|= itoa64_to_int (buf
[17]) << 6;
1959 l
|= itoa64_to_int (buf
[18]) << 12;
1960 l
|= itoa64_to_int (buf
[19]) << 18;
1962 digest
[24] = (l
>> 16) & 0xff;
1963 digest
[ 4] = (l
>> 8) & 0xff;
1964 digest
[14] = (l
>> 0) & 0xff;
1966 l
= itoa64_to_int (buf
[20]) << 0;
1967 l
|= itoa64_to_int (buf
[21]) << 6;
1968 l
|= itoa64_to_int (buf
[22]) << 12;
1969 l
|= itoa64_to_int (buf
[23]) << 18;
1971 digest
[15] = (l
>> 16) & 0xff;
1972 digest
[25] = (l
>> 8) & 0xff;
1973 digest
[ 5] = (l
>> 0) & 0xff;
1975 l
= itoa64_to_int (buf
[24]) << 0;
1976 l
|= itoa64_to_int (buf
[25]) << 6;
1977 l
|= itoa64_to_int (buf
[26]) << 12;
1978 l
|= itoa64_to_int (buf
[27]) << 18;
1980 digest
[ 6] = (l
>> 16) & 0xff;
1981 digest
[16] = (l
>> 8) & 0xff;
1982 digest
[26] = (l
>> 0) & 0xff;
1984 l
= itoa64_to_int (buf
[28]) << 0;
1985 l
|= itoa64_to_int (buf
[29]) << 6;
1986 l
|= itoa64_to_int (buf
[30]) << 12;
1987 l
|= itoa64_to_int (buf
[31]) << 18;
1989 digest
[27] = (l
>> 16) & 0xff;
1990 digest
[ 7] = (l
>> 8) & 0xff;
1991 digest
[17] = (l
>> 0) & 0xff;
1993 l
= itoa64_to_int (buf
[32]) << 0;
1994 l
|= itoa64_to_int (buf
[33]) << 6;
1995 l
|= itoa64_to_int (buf
[34]) << 12;
1996 l
|= itoa64_to_int (buf
[35]) << 18;
1998 digest
[18] = (l
>> 16) & 0xff;
1999 digest
[28] = (l
>> 8) & 0xff;
2000 digest
[ 8] = (l
>> 0) & 0xff;
2002 l
= itoa64_to_int (buf
[36]) << 0;
2003 l
|= itoa64_to_int (buf
[37]) << 6;
2004 l
|= itoa64_to_int (buf
[38]) << 12;
2005 l
|= itoa64_to_int (buf
[39]) << 18;
2007 digest
[ 9] = (l
>> 16) & 0xff;
2008 digest
[19] = (l
>> 8) & 0xff;
2009 digest
[29] = (l
>> 0) & 0xff;
2011 l
= itoa64_to_int (buf
[40]) << 0;
2012 l
|= itoa64_to_int (buf
[41]) << 6;
2013 l
|= itoa64_to_int (buf
[42]) << 12;
2015 digest
[31] = (l
>> 8) & 0xff;
2016 digest
[30] = (l
>> 0) & 0xff;
2019 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2023 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2025 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2028 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2032 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2035 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2039 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2046 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2053 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2060 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2067 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2074 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2081 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2088 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2095 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2097 buf
[42] = int_to_itoa64 (l
& 0x3f);
2100 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2104 l
= itoa64_to_int (buf
[ 0]) << 0;
2105 l
|= itoa64_to_int (buf
[ 1]) << 6;
2106 l
|= itoa64_to_int (buf
[ 2]) << 12;
2107 l
|= itoa64_to_int (buf
[ 3]) << 18;
2109 digest
[ 0] = (l
>> 0) & 0xff;
2110 digest
[ 1] = (l
>> 8) & 0xff;
2111 digest
[ 2] = (l
>> 16) & 0xff;
2113 l
= itoa64_to_int (buf
[ 4]) << 0;
2114 l
|= itoa64_to_int (buf
[ 5]) << 6;
2115 l
|= itoa64_to_int (buf
[ 6]) << 12;
2116 l
|= itoa64_to_int (buf
[ 7]) << 18;
2118 digest
[ 3] = (l
>> 0) & 0xff;
2119 digest
[ 4] = (l
>> 8) & 0xff;
2120 digest
[ 5] = (l
>> 16) & 0xff;
2122 l
= itoa64_to_int (buf
[ 8]) << 0;
2123 l
|= itoa64_to_int (buf
[ 9]) << 6;
2124 l
|= itoa64_to_int (buf
[10]) << 12;
2125 l
|= itoa64_to_int (buf
[11]) << 18;
2127 digest
[ 6] = (l
>> 0) & 0xff;
2128 digest
[ 7] = (l
>> 8) & 0xff;
2129 digest
[ 8] = (l
>> 16) & 0xff;
2131 l
= itoa64_to_int (buf
[12]) << 0;
2132 l
|= itoa64_to_int (buf
[13]) << 6;
2133 l
|= itoa64_to_int (buf
[14]) << 12;
2134 l
|= itoa64_to_int (buf
[15]) << 18;
2136 digest
[ 9] = (l
>> 0) & 0xff;
2137 digest
[10] = (l
>> 8) & 0xff;
2138 digest
[11] = (l
>> 16) & 0xff;
2140 l
= itoa64_to_int (buf
[16]) << 0;
2141 l
|= itoa64_to_int (buf
[17]) << 6;
2142 l
|= itoa64_to_int (buf
[18]) << 12;
2143 l
|= itoa64_to_int (buf
[19]) << 18;
2145 digest
[12] = (l
>> 0) & 0xff;
2146 digest
[13] = (l
>> 8) & 0xff;
2147 digest
[14] = (l
>> 16) & 0xff;
2149 l
= itoa64_to_int (buf
[20]) << 0;
2150 l
|= itoa64_to_int (buf
[21]) << 6;
2151 l
|= itoa64_to_int (buf
[22]) << 12;
2152 l
|= itoa64_to_int (buf
[23]) << 18;
2154 digest
[15] = (l
>> 0) & 0xff;
2155 digest
[16] = (l
>> 8) & 0xff;
2156 digest
[17] = (l
>> 16) & 0xff;
2158 l
= itoa64_to_int (buf
[24]) << 0;
2159 l
|= itoa64_to_int (buf
[25]) << 6;
2160 l
|= itoa64_to_int (buf
[26]) << 12;
2161 l
|= itoa64_to_int (buf
[27]) << 18;
2163 digest
[18] = (l
>> 0) & 0xff;
2164 digest
[19] = (l
>> 8) & 0xff;
2165 digest
[20] = (l
>> 16) & 0xff;
2167 l
= itoa64_to_int (buf
[28]) << 0;
2168 l
|= itoa64_to_int (buf
[29]) << 6;
2169 l
|= itoa64_to_int (buf
[30]) << 12;
2170 l
|= itoa64_to_int (buf
[31]) << 18;
2172 digest
[21] = (l
>> 0) & 0xff;
2173 digest
[22] = (l
>> 8) & 0xff;
2174 digest
[23] = (l
>> 16) & 0xff;
2176 l
= itoa64_to_int (buf
[32]) << 0;
2177 l
|= itoa64_to_int (buf
[33]) << 6;
2178 l
|= itoa64_to_int (buf
[34]) << 12;
2179 l
|= itoa64_to_int (buf
[35]) << 18;
2181 digest
[24] = (l
>> 0) & 0xff;
2182 digest
[25] = (l
>> 8) & 0xff;
2183 digest
[26] = (l
>> 16) & 0xff;
2185 l
= itoa64_to_int (buf
[36]) << 0;
2186 l
|= itoa64_to_int (buf
[37]) << 6;
2187 l
|= itoa64_to_int (buf
[38]) << 12;
2188 l
|= itoa64_to_int (buf
[39]) << 18;
2190 digest
[27] = (l
>> 0) & 0xff;
2191 digest
[28] = (l
>> 8) & 0xff;
2192 digest
[29] = (l
>> 16) & 0xff;
2194 l
= itoa64_to_int (buf
[40]) << 0;
2195 l
|= itoa64_to_int (buf
[41]) << 6;
2196 l
|= itoa64_to_int (buf
[42]) << 12;
2197 l
|= itoa64_to_int (buf
[43]) << 18;
2199 digest
[30] = (l
>> 0) & 0xff;
2200 digest
[31] = (l
>> 8) & 0xff;
2201 digest
[32] = (l
>> 16) & 0xff;
2236 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2240 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2242 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2245 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2247 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2249 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2252 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2254 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2256 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[11] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2263 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[15] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2270 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[19] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2277 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[23] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2284 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[27] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2291 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[31] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2298 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[35] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2305 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[39] = int_to_itoa64 (l
& 0x3f);
2310 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2312 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2315 //buf[43] = int_to_itoa64 (l & 0x3f);
2323 static struct termio savemodes
;
2324 static int havemodes
= 0;
2328 struct termio modmodes
;
2330 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2334 modmodes
= savemodes
;
2335 modmodes
.c_lflag
&= ~ICANON
;
2336 modmodes
.c_cc
[VMIN
] = 1;
2337 modmodes
.c_cc
[VTIME
] = 0;
2339 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2348 FD_SET (fileno (stdin
), &rfds
);
2355 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2357 if (retval
== 0) return 0;
2358 if (retval
== -1) return -1;
2365 if (!havemodes
) return 0;
2367 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2372 static struct termios savemodes
;
2373 static int havemodes
= 0;
2377 struct termios modmodes
;
2379 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2383 modmodes
= savemodes
;
2384 modmodes
.c_lflag
&= ~ICANON
;
2385 modmodes
.c_cc
[VMIN
] = 1;
2386 modmodes
.c_cc
[VTIME
] = 0;
2388 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2397 FD_SET (fileno (stdin
), &rfds
);
2404 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2406 if (retval
== 0) return 0;
2407 if (retval
== -1) return -1;
2414 if (!havemodes
) return 0;
2416 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2421 static DWORD saveMode
= 0;
2425 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2427 GetConsoleMode (stdinHandle
, &saveMode
);
2428 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2435 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2437 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2439 if (rc
== WAIT_TIMEOUT
) return 0;
2440 if (rc
== WAIT_ABANDONED
) return -1;
2441 if (rc
== WAIT_FAILED
) return -1;
2443 // The whole ReadConsoleInput () part is a workaround.
2444 // For some unknown reason, maybe a mingw bug, a random signal
2445 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2446 // Then it wants to read with getche () a keyboard input
2447 // which has never been made.
2449 INPUT_RECORD buf
[100];
2453 memset (buf
, 0, sizeof (buf
));
2455 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2457 FlushConsoleInputBuffer (stdinHandle
);
2459 for (uint i
= 0; i
< num
; i
++)
2461 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2463 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2465 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2467 return KeyEvent
.uChar
.AsciiChar
;
2475 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2477 SetConsoleMode (stdinHandle
, saveMode
);
2487 #define MSG_ENOMEM "Insufficient memory available"
2489 void *mycalloc (size_t nmemb
, size_t size
)
2491 void *p
= calloc (nmemb
, size
);
2495 log_error ("ERROR: %s", MSG_ENOMEM
);
2503 void *mymalloc (size_t size
)
2505 void *p
= malloc (size
);
2509 log_error ("ERROR: %s", MSG_ENOMEM
);
2514 memset (p
, 0, size
);
2519 void myfree (void *ptr
)
2521 if (ptr
== NULL
) return;
2526 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2528 void *p
= realloc (ptr
, oldsz
+ add
);
2532 log_error ("ERROR: %s", MSG_ENOMEM
);
2537 memset ((char *) p
+ oldsz
, 0, add
);
2542 char *mystrdup (const char *s
)
2544 const size_t len
= strlen (s
);
2546 char *b
= (char *) mymalloc (len
+ 1);
2553 FILE *logfile_open (char *logfile
)
2555 FILE *fp
= fopen (logfile
, "ab");
2565 void logfile_close (FILE *fp
)
2567 if (fp
== stdout
) return;
2572 void logfile_append (const char *fmt
, ...)
2574 if (data
.logfile_disable
== 1) return;
2576 FILE *fp
= logfile_open (data
.logfile
);
2582 vfprintf (fp
, fmt
, ap
);
2593 int logfile_generate_id ()
2595 const int n
= rand ();
2604 char *logfile_generate_topid ()
2606 const int id
= logfile_generate_id ();
2608 char *topid
= (char *) mymalloc (1 + 16 + 1);
2610 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2615 char *logfile_generate_subid ()
2617 const int id
= logfile_generate_id ();
2619 char *subid
= (char *) mymalloc (1 + 16 + 1);
2621 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2633 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2635 FlushFileBuffers (h
);
2644 #if defined(_WIN) && defined(HAVE_NVAPI)
2645 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2649 if (hc_NvAPI_EnumPhysicalGPUs (nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2653 log_info ("WARN: No NvAPI adapters found");
2660 #endif // _WIN && HAVE_NVAPI
2662 #if defined(LINUX) && defined(HAVE_NVML)
2663 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2667 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2669 if (hc_NVML_nvmlDeviceGetHandleByIndex (data
.hm_dll_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2671 // can be used to determine if the device by index matches the cuda device by index
2672 // char name[100]; memset (name, 0, sizeof (name));
2673 // hc_NVML_nvmlDeviceGetName (data.hm_dll_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2680 log_info ("WARN: No NVML adapters found");
2687 #endif // LINUX && HAVE_NVML
2689 #if defined(HAVE_ADL) || defined(HAVE_NVML)
2690 void hm_close (HM_LIB hm_dll
)
2696 FreeLibrary (hm_dll
);
2701 HM_LIB
hm_init (const cl_uint vendor_id
)
2703 HM_LIB hm_dll
= NULL
;
2706 if (vendor_id
== VENDOR_ID_AMD
)
2709 hm_dll
= dlopen ("libatiadlxx.so", RTLD_LAZY
| RTLD_GLOBAL
);
2712 hm_dll
= LoadLibrary ("atiadlxx.dll");
2716 hm_dll
= LoadLibrary ("atiadlxy.dll");
2723 #if defined(LINUX) && defined(HAVE_NVML)
2724 if (vendor_id
== VENDOR_ID_NV
)
2726 hm_dll
= dlopen ("libnvidia-ml.so", RTLD_LAZY
| RTLD_GLOBAL
);
2732 #endif // HAVE_ADL || HAVE_NVML
2735 int get_adapters_num_amd (HM_LIB hm_dll_amd
, int *iNumberAdapters
)
2737 if (hc_ADL_Adapter_NumberOfAdapters_Get (hm_dll_amd
, iNumberAdapters
) != ADL_OK
) return -1;
2739 if (iNumberAdapters
== 0)
2741 log_info ("WARN: No ADL adapters found.");
2750 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2752 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2753 ADLODParameters lpOdParameters;
2755 lpOdParameters.iSize = sizeof (ADLODParameters);
2756 size_t plevels_size = 0;
2758 if (hc_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2760 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2761 __func__, iAdapterIndex,
2762 lpOdParameters.iNumberOfPerformanceLevels,
2763 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2764 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2766 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2768 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2770 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2772 if (hc_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2774 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2775 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2776 __func__, iAdapterIndex, j,
2777 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2779 myfree (lpOdPerformanceLevels);
2785 LPAdapterInfo
hm_get_adapter_info_amd (HM_LIB hm_dll_amd
, int iNumberAdapters
)
2787 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2789 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2791 if (hc_ADL_Adapter_AdapterInfo_Get (hm_dll_amd
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2793 return lpAdapterInfo
;
2798 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2801 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2805 for (uint i = 0; i < num_adl_adapters; i++)
2807 int opencl_bus_num = hm_device[i].busid;
2808 int opencl_dev_num = hm_device[i].devid;
2810 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2818 if (idx >= DEVICES_MAX) return -1;
2823 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2825 for (uint i = 0; i < opencl_num_devices; i++)
2827 cl_device_topology_amd device_topology;
2829 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2831 hm_device[i].busid = device_topology.pcie.bus;
2832 hm_device[i].devid = device_topology.pcie.device;
2837 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2839 // basically bubble sort
2841 for (int i
= 0; i
< num_adl_adapters
; i
++)
2843 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2845 // get info of adapter [x]
2847 u32 adapter_index_x
= valid_adl_device_list
[j
];
2848 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2850 u32 bus_num_x
= info_x
.iBusNumber
;
2851 u32 dev_num_x
= info_x
.iDeviceNumber
;
2853 // get info of adapter [y]
2855 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2856 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2858 u32 bus_num_y
= info_y
.iBusNumber
;
2859 u32 dev_num_y
= info_y
.iDeviceNumber
;
2863 if (bus_num_y
< bus_num_x
)
2867 else if (bus_num_y
== bus_num_x
)
2869 if (dev_num_y
< dev_num_x
)
2877 u32 temp
= valid_adl_device_list
[j
+ 1];
2879 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2880 valid_adl_device_list
[j
+ 0] = temp
;
2886 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2888 *num_adl_adapters
= 0;
2890 u32
*adl_adapters
= NULL
;
2892 int *bus_numbers
= NULL
;
2893 int *device_numbers
= NULL
;
2895 for (int i
= 0; i
< iNumberAdapters
; i
++)
2897 AdapterInfo info
= lpAdapterInfo
[i
];
2899 if (strlen (info
.strUDID
) < 1) continue;
2902 if (info
.iVendorID
!= 1002) continue;
2904 if (info
.iVendorID
!= 0x1002) continue;
2907 if (info
.iBusNumber
< 0) continue;
2908 if (info
.iDeviceNumber
< 0) continue;
2912 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2914 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2921 if (found
) continue;
2923 // add it to the list
2925 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2927 adl_adapters
[*num_adl_adapters
] = i
;
2929 // rest is just bookkeeping
2931 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2932 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2934 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2935 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2937 (*num_adl_adapters
)++;
2940 myfree (bus_numbers
);
2941 myfree (device_numbers
);
2943 // sort the list by increasing bus id, device id number
2945 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2947 return adl_adapters
;
2950 int hm_check_fanspeed_control (HM_LIB hm_dll_amd
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2952 // loop through all valid devices
2954 for (int i
= 0; i
< num_adl_adapters
; i
++)
2956 u32 adapter_index
= valid_adl_device_list
[i
];
2960 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2962 // unfortunately this doesn't work since bus id and dev id are not unique
2963 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2964 // if (opencl_device_index == -1) continue;
2966 int opencl_device_index
= i
;
2968 // if (hm_show_performance_level (hm_dll_amd, info.iAdapterIndex) != 0) return -1;
2970 // get fanspeed info
2972 if (hm_device
[opencl_device_index
].od_version
== 5)
2974 ADLFanSpeedInfo FanSpeedInfo
;
2976 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2978 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2980 if (hc_ADL_Overdrive5_FanSpeedInfo_Get (hm_dll_amd
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2982 // check read and write capability in fanspeedinfo
2984 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2985 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2987 hm_device
[opencl_device_index
].fan_supported
= 1;
2991 hm_device
[opencl_device_index
].fan_supported
= 0;
2994 else // od_version == 6
2996 ADLOD6FanSpeedInfo faninfo
;
2998 memset (&faninfo
, 0, sizeof (faninfo
));
3000 if (hc_ADL_Overdrive6_FanSpeed_Get (hm_dll_amd
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
3002 // check read capability in fanspeedinfo
3004 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
3006 hm_device
[opencl_device_index
].fan_supported
= 1;
3010 hm_device
[opencl_device_index
].fan_supported
= 0;
3018 int hm_get_overdrive_version (HM_LIB hm_dll_amd
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3020 for (int i
= 0; i
< num_adl_adapters
; i
++)
3022 u32 adapter_index
= valid_adl_device_list
[i
];
3026 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3028 // get overdrive version
3030 int od_supported
= 0;
3034 if (hc_ADL_Overdrive_Caps (hm_dll_amd
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3036 // store the overdrive version in hm_device
3038 // unfortunately this doesn't work since bus id and dev id are not unique
3039 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3040 // if (opencl_device_index == -1) continue;
3042 int opencl_device_index
= i
;
3044 hm_device
[opencl_device_index
].od_version
= od_version
;
3050 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3052 for (int i
= 0; i
< num_adl_adapters
; i
++)
3054 u32 adapter_index
= valid_adl_device_list
[i
];
3058 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3060 // store the iAdapterIndex in hm_device
3062 // unfortunately this doesn't work since bus id and dev id are not unique
3063 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3064 // if (opencl_device_index == -1) continue;
3066 int opencl_device_index
= i
;
3068 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3071 return num_adl_adapters
;
3075 int hm_get_temperature_with_device_id (const uint device_id
)
3077 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3080 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3082 if (data
.hm_dll_amd
)
3084 if (data
.hm_device
[device_id
].od_version
== 5)
3086 ADLTemperature Temperature
;
3088 Temperature
.iSize
= sizeof (ADLTemperature
);
3090 if (hc_ADL_Overdrive5_Temperature_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3092 return Temperature
.iTemperature
/ 1000;
3094 else if (data
.hm_device
[device_id
].od_version
== 6)
3096 int Temperature
= 0;
3098 if (hc_ADL_Overdrive6_Temperature_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3100 return Temperature
/ 1000;
3106 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3107 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3109 #if defined(LINUX) && defined(HAVE_NVML)
3110 int temperature
= 0;
3112 hc_NVML_nvmlDeviceGetTemperature (data
.hm_dll_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3117 #if defined(WIN) && defined(HAVE_NVAPI)
3118 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3120 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3121 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3122 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3123 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3125 if (hc_NvAPI_GPU_GetThermalSettings (data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3127 return pThermalSettings
.sensor
[0].currentTemp
;
3128 #endif // WIN && HAVE_NVAPI
3130 #endif // HAVE_NVML || HAVE_NVAPI
3135 int hm_get_fanspeed_with_device_id (const uint device_id
)
3137 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3138 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3140 if (data
.hm_device
[device_id
].fan_supported
== 1)
3143 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3145 if (data
.hm_dll_amd
)
3147 if (data
.hm_device
[device_id
].od_version
== 5)
3149 ADLFanSpeedValue lpFanSpeedValue
;
3151 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3153 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3154 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3155 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3157 if (hc_ADL_Overdrive5_FanSpeed_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3159 return lpFanSpeedValue
.iFanSpeed
;
3161 else // od_version == 6
3163 ADLOD6FanSpeedInfo faninfo
;
3165 memset (&faninfo
, 0, sizeof (faninfo
));
3167 if (hc_ADL_Overdrive6_FanSpeed_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3169 return faninfo
.iFanSpeedPercent
;
3175 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3176 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3178 #if defined(LINUX) && defined(HAVE_NVML)
3181 hc_NVML_nvmlDeviceGetFanSpeed (data
.hm_dll_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3186 #if defined(WIN) && defined(HAVE_NVAPI)
3189 hc_NvAPI_GPU_GetTachReading (data
.hm_device
[device_id
].adapter_index
.nv
, &speed
);
3194 #endif // HAVE_NVML || HAVE_NVAPI
3200 int hm_get_utilization_with_device_id (const uint device_id
)
3202 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3205 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3207 if (data
.hm_dll_amd
)
3209 ADLPMActivity PMActivity
;
3211 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3213 if (hc_ADL_Overdrive_CurrentActivity_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3215 return PMActivity
.iActivityPercent
;
3220 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3221 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3223 #if defined(LINUX) && defined(HAVE_NVML)
3224 nvmlUtilization_t utilization
;
3226 hc_NVML_nvmlDeviceGetUtilizationRates (data
.hm_dll_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3228 return utilization
.gpu
;
3231 #if defined(WIN) && defined(HAVE_NVAPI)
3232 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3234 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3236 if (hc_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3238 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3241 #endif // HAVE_NVML || HAVE_NVAPI
3247 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3249 if (data
.hm_device
[device_id
].fan_supported
== 1)
3251 if (data
.hm_dll_amd
)
3253 if (data
.hm_device
[device_id
].od_version
== 5)
3255 ADLFanSpeedValue lpFanSpeedValue
;
3257 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3259 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3260 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3261 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3262 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3264 if (hc_ADL_Overdrive5_FanSpeed_Set (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3268 else // od_version == 6
3270 ADLOD6FanSpeedValue fan_speed_value
;
3272 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3274 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3275 fan_speed_value
.iFanSpeed
= fanspeed
;
3277 if (hc_ADL_Overdrive6_FanSpeed_Set (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3288 // helper function for status display
3290 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3292 #define VALUE_NOT_AVAILABLE "N/A"
3296 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3300 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3303 #endif // HAVE_HWMON
3309 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3311 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3313 if (css_cnt
> SP_PW_MAX
)
3315 log_error ("ERROR: mask length is too long");
3320 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3322 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3324 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3325 uint cs_len
= css
[css_pos
].cs_len
;
3327 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3329 uint c
= cs_buf
[cs_pos
] & 0xff;
3336 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3338 cs_t
*cs
= &css
[css_cnt
];
3340 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3342 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3346 for (i
= 0; i
< cs
->cs_len
; i
++)
3348 const uint u
= cs
->cs_buf
[i
];
3353 for (i
= 0; i
< in_len
; i
++)
3355 uint u
= in_buf
[i
] & 0xff;
3357 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3359 if (css_uniq
[u
] == 1) continue;
3363 cs
->cs_buf
[cs
->cs_len
] = u
;
3371 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3375 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3377 uint p0
= in_buf
[in_pos
] & 0xff;
3379 if (interpret
== 1 && p0
== '?')
3383 if (in_pos
== in_len
) break;
3385 uint p1
= in_buf
[in_pos
] & 0xff;
3389 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3391 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3393 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3395 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3397 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3399 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3401 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3402 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3404 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3405 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3407 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3408 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3410 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3411 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3413 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3415 default: log_error ("Syntax error: %s", in_buf
);
3421 if (data
.hex_charset
)
3425 if (in_pos
== in_len
)
3427 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3432 uint p1
= in_buf
[in_pos
] & 0xff;
3434 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3436 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3443 chr
= hex_convert (p1
) << 0;
3444 chr
|= hex_convert (p0
) << 4;
3446 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3452 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3458 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3462 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3464 sum
*= css
[css_pos
].cs_len
;
3470 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3472 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3477 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3479 char p0
= mask_buf
[mask_pos
];
3485 if (mask_pos
== mask_len
) break;
3487 char p1
= mask_buf
[mask_pos
];
3493 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3495 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3497 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3499 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3501 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3503 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3505 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3506 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3508 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3509 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3511 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3512 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3514 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3515 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3517 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3519 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3525 if (data
.hex_charset
)
3529 // if there is no 2nd hex character, show an error:
3531 if (mask_pos
== mask_len
)
3533 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3538 char p1
= mask_buf
[mask_pos
];
3540 // if they are not valid hex character, show an error:
3542 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3544 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3551 chr
|= hex_convert (p1
) << 0;
3552 chr
|= hex_convert (p0
) << 4;
3554 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3560 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3567 log_error ("ERROR: invalid mask length (0)");
3577 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3579 for (int i
= 0; i
< css_cnt
; i
++)
3581 uint len
= css
[i
].cs_len
;
3582 u64 next
= val
/ len
;
3583 uint pos
= val
% len
;
3584 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3589 void mp_cut_at (char *mask
, uint max
)
3593 uint mask_len
= strlen (mask
);
3595 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3597 if (mask
[i
] == '?') i
++;
3603 void mp_setup_sys (cs_t
*mp_sys
)
3607 uint donec
[CHARSIZ
] = { 0 };
3609 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3610 mp_sys
[0].cs_buf
[pos
++] = chr
;
3611 mp_sys
[0].cs_len
= pos
; }
3613 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3614 mp_sys
[1].cs_buf
[pos
++] = chr
;
3615 mp_sys
[1].cs_len
= pos
; }
3617 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3618 mp_sys
[2].cs_buf
[pos
++] = chr
;
3619 mp_sys
[2].cs_len
= pos
; }
3621 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3622 mp_sys
[3].cs_buf
[pos
++] = chr
;
3623 mp_sys
[3].cs_len
= pos
; }
3625 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3626 mp_sys
[4].cs_len
= pos
; }
3628 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3629 mp_sys
[5].cs_len
= pos
; }
3632 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3634 FILE *fp
= fopen (buf
, "rb");
3636 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3638 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3642 char mp_file
[1024] = { 0 };
3644 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3648 len
= in_superchop (mp_file
);
3652 log_info ("WARNING: charset file corrupted");
3654 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3658 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3663 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3665 mp_usr
[index
].cs_len
= 0;
3667 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3670 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3672 char *new_mask_buf
= (char *) mymalloc (256);
3678 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3680 if (css_pos
== len
) break;
3682 char p0
= mask_buf
[mask_pos
];
3684 new_mask_buf
[mask_pos
] = p0
;
3690 if (mask_pos
== mask_len
) break;
3692 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3696 if (data
.hex_charset
)
3700 if (mask_pos
== mask_len
)
3702 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3707 char p1
= mask_buf
[mask_pos
];
3709 // if they are not valid hex character, show an error:
3711 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3713 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3718 new_mask_buf
[mask_pos
] = p1
;
3723 if (css_pos
== len
) return (new_mask_buf
);
3725 myfree (new_mask_buf
);
3734 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3740 for (i
= start
; i
< stop
; i
++)
3742 sum
*= root_css_buf
[i
].cs_len
;
3748 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3752 cs_t
*cs
= &root_css_buf
[start
];
3756 for (i
= start
; i
< stop
; i
++)
3758 const u64 m
= v
% cs
->cs_len
;
3759 const u64 d
= v
/ cs
->cs_len
;
3763 const uint k
= cs
->cs_buf
[m
];
3765 pw_buf
[i
- start
] = (char) k
;
3767 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3771 int sp_comp_val (const void *p1
, const void *p2
)
3773 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3774 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3776 return b2
->val
- b1
->val
;
3779 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
)
3786 * Initialize hcstats
3789 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3791 u64
*root_stats_ptr
= root_stats_buf
;
3793 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3795 for (i
= 0; i
< SP_PW_MAX
; i
++)
3797 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3799 root_stats_ptr
+= CHARSIZ
;
3802 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3804 u64
*markov_stats_ptr
= markov_stats_buf
;
3806 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3808 for (i
= 0; i
< SP_PW_MAX
; i
++)
3810 for (j
= 0; j
< CHARSIZ
; j
++)
3812 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3814 markov_stats_ptr
+= CHARSIZ
;
3824 char hcstat_tmp
[256] = { 0 };
3826 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3828 hcstat
= hcstat_tmp
;
3831 FILE *fd
= fopen (hcstat
, "rb");
3835 log_error ("%s: %s", hcstat
, strerror (errno
));
3840 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3842 log_error ("%s: Could not load data", hcstat
);
3849 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3851 log_error ("%s: Could not load data", hcstat
);
3861 * Markov modifier of hcstat_table on user request
3866 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3867 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3872 /* Add all stats to first position */
3874 for (i
= 1; i
< SP_PW_MAX
; i
++)
3876 u64
*out
= root_stats_buf_by_pos
[0];
3877 u64
*in
= root_stats_buf_by_pos
[i
];
3879 for (j
= 0; j
< CHARSIZ
; j
++)
3885 for (i
= 1; i
< SP_PW_MAX
; i
++)
3887 u64
*out
= markov_stats_buf_by_key
[0][0];
3888 u64
*in
= markov_stats_buf_by_key
[i
][0];
3890 for (j
= 0; j
< CHARSIZ
; j
++)
3892 for (k
= 0; k
< CHARSIZ
; k
++)
3899 /* copy them to all pw_positions */
3901 for (i
= 1; i
< SP_PW_MAX
; i
++)
3903 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3906 for (i
= 1; i
< SP_PW_MAX
; i
++)
3908 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3916 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3918 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3920 for (i
= 0; i
< SP_PW_MAX
; i
++)
3922 root_table_buf_by_pos
[i
] = root_table_ptr
;
3924 root_table_ptr
+= CHARSIZ
;
3927 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3929 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3931 for (i
= 0; i
< SP_PW_MAX
; i
++)
3933 for (j
= 0; j
< CHARSIZ
; j
++)
3935 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3937 markov_table_ptr
+= CHARSIZ
;
3942 * Convert hcstat to tables
3945 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3947 uint key
= i
% CHARSIZ
;
3949 root_table_buf
[i
].key
= key
;
3950 root_table_buf
[i
].val
= root_stats_buf
[i
];
3953 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3955 uint key
= i
% CHARSIZ
;
3957 markov_table_buf
[i
].key
= key
;
3958 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3961 myfree (root_stats_buf
);
3962 myfree (markov_stats_buf
);
3968 for (i
= 0; i
< SP_PW_MAX
; i
++)
3970 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3973 for (i
= 0; i
< SP_PW_MAX
; i
++)
3975 for (j
= 0; j
< CHARSIZ
; j
++)
3977 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3982 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
])
3985 * Convert tables to css
3988 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3990 uint pw_pos
= i
/ CHARSIZ
;
3992 cs_t
*cs
= &root_css_buf
[pw_pos
];
3994 if (cs
->cs_len
== threshold
) continue;
3996 uint key
= root_table_buf
[i
].key
;
3998 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4000 cs
->cs_buf
[cs
->cs_len
] = key
;
4006 * Convert table to css
4009 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4011 uint c
= i
/ CHARSIZ
;
4013 cs_t
*cs
= &markov_css_buf
[c
];
4015 if (cs
->cs_len
== threshold
) continue;
4017 uint pw_pos
= c
/ CHARSIZ
;
4019 uint key
= markov_table_buf
[i
].key
;
4021 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4023 cs
->cs_buf
[cs
->cs_len
] = key
;
4029 for (uint i = 0; i < 8; i++)
4031 for (uint j = 0x20; j < 0x80; j++)
4033 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4035 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4037 for (uint k = 0; k < 10; k++)
4039 printf (" %u\n", ptr->cs_buf[k]);
4046 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4048 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4050 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4060 for (uint j
= 1; j
< CHARSIZ
; j
++)
4070 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4072 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4074 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4076 out
+= CHARSIZ
* CHARSIZ
;
4077 in
+= CHARSIZ
* CHARSIZ
;
4079 for (uint j
= 0; j
< CHARSIZ
; j
++)
4086 for (uint k
= 1; k
< CHARSIZ
; k
++)
4098 * mixed shared functions
4101 void dump_hex (const u8
*s
, const int sz
)
4103 for (int i
= 0; i
< sz
; i
++)
4105 log_info_nn ("%02x ", s
[i
]);
4111 void usage_mini_print (const char *progname
)
4113 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4116 void usage_big_print (const char *progname
)
4118 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4121 char *get_exec_path ()
4123 int exec_path_len
= 1024;
4125 char *exec_path
= (char *) mymalloc (exec_path_len
);
4129 char tmp
[32] = { 0 };
4131 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4133 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4137 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4141 uint size
= exec_path_len
;
4143 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4145 log_error("! executable path buffer too small\n");
4150 const int len
= strlen (exec_path
);
4153 #error Your Operating System is not supported or detected
4161 char *get_install_dir (const char *progname
)
4163 char *install_dir
= mystrdup (progname
);
4164 char *last_slash
= NULL
;
4166 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4170 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4176 install_dir
[0] = '.';
4180 return (install_dir
);
4183 char *get_profile_dir (const char *homedir
)
4185 #define DOT_HASHCAT ".hashcat"
4187 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
);
4189 char *profile_dir
= (char *) mymalloc (len
+ 1);
4191 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4196 char *get_session_dir (const char *profile_dir
)
4198 #define SESSIONS_FOLDER "sessions"
4200 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
);
4202 char *session_dir
= (char *) mymalloc (len
+ 1);
4204 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4209 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4213 FILE *fd
= fopen (filename
, "rb");
4217 log_error ("%s: %s", filename
, strerror (errno
));
4222 #define MAX_KEY_SIZE (1024 * 1024)
4224 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4226 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4232 for (int fpos
= 0; fpos
< nread
; fpos
++)
4234 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4236 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4237 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4238 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4239 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4241 if (kpos
>= 64) kpos
= 0;
4247 void set_cpu_affinity (char *cpu_affinity
)
4250 DWORD_PTR aff_mask
= 0;
4258 char *devices
= strdup (cpu_affinity
);
4260 char *next
= strtok (devices
, ",");
4264 uint cpu_id
= atoi (next
);
4279 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4285 aff_mask
|= 1 << (cpu_id
- 1);
4287 CPU_SET ((cpu_id
- 1), &cpuset
);
4290 } while ((next
= strtok (NULL
, ",")) != NULL
);
4296 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4297 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4299 pthread_t thread
= pthread_self ();
4300 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4304 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4306 char *element
, *end
;
4308 end
= (char *) base
+ nmemb
* size
;
4310 for (element
= (char *) base
; element
< end
; element
+= size
)
4311 if (!compar (element
, key
))
4317 int sort_by_salt (const void *v1
, const void *v2
)
4319 const salt_t
*s1
= (const salt_t
*) v1
;
4320 const salt_t
*s2
= (const salt_t
*) v2
;
4322 const int res1
= s1
->salt_len
- s2
->salt_len
;
4324 if (res1
!= 0) return (res1
);
4326 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4328 if (res2
!= 0) return (res2
);
4336 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4337 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4344 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4345 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4351 int sort_by_salt_buf (const void *v1
, const void *v2
)
4353 const pot_t
*p1
= (const pot_t
*) v1
;
4354 const pot_t
*p2
= (const pot_t
*) v2
;
4356 const hash_t
*h1
= &p1
->hash
;
4357 const hash_t
*h2
= &p2
->hash
;
4359 const salt_t
*s1
= h1
->salt
;
4360 const salt_t
*s2
= h2
->salt
;
4366 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4367 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4373 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4375 const hash_t
*h1
= (const hash_t
*) v1
;
4376 const hash_t
*h2
= (const hash_t
*) v2
;
4378 const salt_t
*s1
= h1
->salt
;
4379 const salt_t
*s2
= h2
->salt
;
4381 // testphase: this should work
4386 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4387 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4390 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4391 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4392 if (s1->salt_len > s2->salt_len) return ( 1);
4393 if (s1->salt_len < s2->salt_len) return (-1);
4395 uint n = s1->salt_len;
4399 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4400 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4407 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4409 const hash_t
*h1
= (const hash_t
*) v1
;
4410 const hash_t
*h2
= (const hash_t
*) v2
;
4412 const salt_t
*s1
= h1
->salt
;
4413 const salt_t
*s2
= h2
->salt
;
4415 // 12 - 2 (since last 2 uints contain the digest)
4420 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4421 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4427 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4429 const hash_t
*h1
= (const hash_t
*) v1
;
4430 const hash_t
*h2
= (const hash_t
*) v2
;
4432 const void *d1
= h1
->digest
;
4433 const void *d2
= h2
->digest
;
4435 return data
.sort_by_digest (d1
, d2
);
4438 int sort_by_hash (const void *v1
, const void *v2
)
4440 const hash_t
*h1
= (const hash_t
*) v1
;
4441 const hash_t
*h2
= (const hash_t
*) v2
;
4445 const salt_t
*s1
= h1
->salt
;
4446 const salt_t
*s2
= h2
->salt
;
4448 int res
= sort_by_salt (s1
, s2
);
4450 if (res
!= 0) return (res
);
4453 const void *d1
= h1
->digest
;
4454 const void *d2
= h2
->digest
;
4456 return data
.sort_by_digest (d1
, d2
);
4459 int sort_by_pot (const void *v1
, const void *v2
)
4461 const pot_t
*p1
= (const pot_t
*) v1
;
4462 const pot_t
*p2
= (const pot_t
*) v2
;
4464 const hash_t
*h1
= &p1
->hash
;
4465 const hash_t
*h2
= &p2
->hash
;
4467 return sort_by_hash (h1
, h2
);
4470 int sort_by_mtime (const void *p1
, const void *p2
)
4472 const char **f1
= (const char **) p1
;
4473 const char **f2
= (const char **) p2
;
4475 struct stat s1
; stat (*f1
, &s1
);
4476 struct stat s2
; stat (*f2
, &s2
);
4478 return s2
.st_mtime
- s1
.st_mtime
;
4481 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4483 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4484 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4486 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4489 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4491 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4492 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4494 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4497 int sort_by_stringptr (const void *p1
, const void *p2
)
4499 const char **s1
= (const char **) p1
;
4500 const char **s2
= (const char **) p2
;
4502 return strcmp (*s1
, *s2
);
4505 int sort_by_dictstat (const void *s1
, const void *s2
)
4507 dictstat_t
*d1
= (dictstat_t
*) s1
;
4508 dictstat_t
*d2
= (dictstat_t
*) s2
;
4511 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4513 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4516 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4519 int sort_by_bitmap (const void *p1
, const void *p2
)
4521 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4522 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4524 return b1
->collisions
- b2
->collisions
;
4527 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4529 const u32
*d1
= (const u32
*) v1
;
4530 const u32
*d2
= (const u32
*) v2
;
4536 if (d1
[n
] > d2
[n
]) return ( 1);
4537 if (d1
[n
] < d2
[n
]) return (-1);
4543 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4545 const u32
*d1
= (const u32
*) v1
;
4546 const u32
*d2
= (const u32
*) v2
;
4552 if (d1
[n
] > d2
[n
]) return ( 1);
4553 if (d1
[n
] < d2
[n
]) return (-1);
4559 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4561 const u32
*d1
= (const u32
*) v1
;
4562 const u32
*d2
= (const u32
*) v2
;
4568 if (d1
[n
] > d2
[n
]) return ( 1);
4569 if (d1
[n
] < d2
[n
]) return (-1);
4575 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4577 const u32
*d1
= (const u32
*) v1
;
4578 const u32
*d2
= (const u32
*) v2
;
4584 if (d1
[n
] > d2
[n
]) return ( 1);
4585 if (d1
[n
] < d2
[n
]) return (-1);
4591 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4593 const u32
*d1
= (const u32
*) v1
;
4594 const u32
*d2
= (const u32
*) v2
;
4600 if (d1
[n
] > d2
[n
]) return ( 1);
4601 if (d1
[n
] < d2
[n
]) return (-1);
4607 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4609 const u32
*d1
= (const u32
*) v1
;
4610 const u32
*d2
= (const u32
*) v2
;
4616 if (d1
[n
] > d2
[n
]) return ( 1);
4617 if (d1
[n
] < d2
[n
]) return (-1);
4623 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4625 const u32
*d1
= (const u32
*) v1
;
4626 const u32
*d2
= (const u32
*) v2
;
4632 if (d1
[n
] > d2
[n
]) return ( 1);
4633 if (d1
[n
] < d2
[n
]) return (-1);
4639 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4641 const u32
*d1
= (const u32
*) v1
;
4642 const u32
*d2
= (const u32
*) v2
;
4648 if (d1
[n
] > d2
[n
]) return ( 1);
4649 if (d1
[n
] < d2
[n
]) return (-1);
4655 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4657 const u64
*d1
= (const u64
*) v1
;
4658 const u64
*d2
= (const u64
*) v2
;
4664 if (d1
[n
] > d2
[n
]) return ( 1);
4665 if (d1
[n
] < d2
[n
]) return (-1);
4671 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4673 const u64
*d1
= (const u64
*) v1
;
4674 const u64
*d2
= (const u64
*) v2
;
4680 if (d1
[n
] > d2
[n
]) return ( 1);
4681 if (d1
[n
] < d2
[n
]) return (-1);
4687 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4689 const u64
*d1
= (const u64
*) v1
;
4690 const u64
*d2
= (const u64
*) v2
;
4696 if (d1
[n
] > d2
[n
]) return ( 1);
4697 if (d1
[n
] < d2
[n
]) return (-1);
4703 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4705 const u32
*d1
= (const u32
*) v1
;
4706 const u32
*d2
= (const u32
*) v2
;
4708 const uint dgst_pos0
= data
.dgst_pos0
;
4709 const uint dgst_pos1
= data
.dgst_pos1
;
4710 const uint dgst_pos2
= data
.dgst_pos2
;
4711 const uint dgst_pos3
= data
.dgst_pos3
;
4713 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4714 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4715 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4716 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4717 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4718 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4719 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4720 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4725 void format_debug (char *debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
4727 uint outfile_autohex
= data
.outfile_autohex
;
4729 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4731 FILE *debug_fp
= NULL
;
4733 if (debug_file
!= NULL
)
4735 debug_fp
= fopen (debug_file
, "ab");
4742 if (debug_fp
== NULL
)
4744 log_info ("WARNING: Could not open debug-file for writing");
4748 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4750 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4752 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4755 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4757 if (debug_mode
== 4)
4759 fputc (':', debug_fp
);
4761 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4764 fputc ('\n', debug_fp
);
4766 if (debug_file
!= NULL
) fclose (debug_fp
);
4770 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4772 int needs_hexify
= 0;
4774 if (outfile_autohex
== 1)
4776 for (uint i
= 0; i
< plain_len
; i
++)
4778 if (plain_ptr
[i
] < 0x20)
4785 if (plain_ptr
[i
] > 0x7f)
4794 if (needs_hexify
== 1)
4796 fprintf (fp
, "$HEX[");
4798 for (uint i
= 0; i
< plain_len
; i
++)
4800 fprintf (fp
, "%02x", plain_ptr
[i
]);
4807 fwrite (plain_ptr
, plain_len
, 1, fp
);
4811 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const u64 crackpos
, unsigned char *username
, const uint user_len
)
4813 uint outfile_format
= data
.outfile_format
;
4815 char separator
= data
.separator
;
4817 if (outfile_format
& OUTFILE_FMT_HASH
)
4819 fprintf (out_fp
, "%s", out_buf
);
4821 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4823 fputc (separator
, out_fp
);
4826 else if (data
.username
)
4828 if (username
!= NULL
)
4830 for (uint i
= 0; i
< user_len
; i
++)
4832 fprintf (out_fp
, "%c", username
[i
]);
4835 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4837 fputc (separator
, out_fp
);
4842 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4844 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4846 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4848 fputc (separator
, out_fp
);
4852 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4854 for (uint i
= 0; i
< plain_len
; i
++)
4856 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4859 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4861 fputc (separator
, out_fp
);
4865 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4868 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4873 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4875 fprintf (out_fp
, "%llu", crackpos
);
4880 fputc ('\n', out_fp
);
4883 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4887 pot_key
.hash
.salt
= hashes_buf
->salt
;
4888 pot_key
.hash
.digest
= hashes_buf
->digest
;
4890 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4896 input_buf
[input_len
] = 0;
4899 unsigned char *username
= NULL
;
4904 user_t
*user
= hashes_buf
->hash_info
->user
;
4908 username
= (unsigned char *) (user
->user_name
);
4910 user_len
= user
->user_len
;
4914 // do output the line
4915 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4919 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4920 #define LM_MASKED_PLAIN "[notfound]"
4922 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4928 pot_left_key
.hash
.salt
= hash_left
->salt
;
4929 pot_left_key
.hash
.digest
= hash_left
->digest
;
4931 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4935 uint weak_hash_found
= 0;
4937 pot_t pot_right_key
;
4939 pot_right_key
.hash
.salt
= hash_right
->salt
;
4940 pot_right_key
.hash
.digest
= hash_right
->digest
;
4942 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4944 if (pot_right_ptr
== NULL
)
4946 // special case, if "weak hash"
4948 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4950 weak_hash_found
= 1;
4952 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4954 // in theory this is not needed, but we are paranoia:
4956 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4957 pot_right_ptr
->plain_len
= 0;
4961 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4963 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
4968 // at least one half was found:
4972 input_buf
[input_len
] = 0;
4976 unsigned char *username
= NULL
;
4981 user_t
*user
= hash_left
->hash_info
->user
;
4985 username
= (unsigned char *) (user
->user_name
);
4987 user_len
= user
->user_len
;
4991 // mask the part which was not found
4993 uint left_part_masked
= 0;
4994 uint right_part_masked
= 0;
4996 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
4998 if (pot_left_ptr
== NULL
)
5000 left_part_masked
= 1;
5002 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5004 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5006 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5007 pot_left_ptr
->plain_len
= mask_plain_len
;
5010 if (pot_right_ptr
== NULL
)
5012 right_part_masked
= 1;
5014 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5016 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5018 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5019 pot_right_ptr
->plain_len
= mask_plain_len
;
5022 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5026 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5028 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5030 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5032 // do output the line
5034 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5036 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5038 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5039 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5042 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5046 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5048 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5050 if (pot_ptr
== NULL
)
5054 input_buf
[input_len
] = 0;
5056 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5060 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5066 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5068 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5072 pot_t pot_right_key
;
5074 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5076 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5078 uint weak_hash_found
= 0;
5080 if (pot_right_ptr
== NULL
)
5082 // special case, if "weak hash"
5084 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5086 weak_hash_found
= 1;
5088 // we just need that pot_right_ptr is not a NULL pointer
5090 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5094 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5096 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5101 // ... at least one part was not cracked
5105 input_buf
[input_len
] = 0;
5107 // only show the hash part which is still not cracked
5109 uint user_len
= input_len
- 32;
5111 char *hash_output
= (char *) mymalloc (33);
5113 memcpy (hash_output
, input_buf
, input_len
);
5115 if (pot_left_ptr
!= NULL
)
5117 // only show right part (because left part was already found)
5119 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5121 hash_output
[user_len
+ 16] = 0;
5124 if (pot_right_ptr
!= NULL
)
5126 // only show left part (because right part was already found)
5128 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5130 hash_output
[user_len
+ 16] = 0;
5133 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5135 myfree (hash_output
);
5137 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5140 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5142 uint opencl_platforms_filter
= 0;
5144 if (opencl_platforms
)
5146 char *platforms
= strdup (opencl_platforms
);
5148 char *next
= strtok (platforms
, ",");
5152 int platform
= atoi (next
);
5154 if (platform
< 1 || platform
> 32)
5156 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5161 opencl_platforms_filter
|= 1 << (platform
- 1);
5163 } while ((next
= strtok (NULL
, ",")) != NULL
);
5169 opencl_platforms_filter
= -1;
5172 return opencl_platforms_filter
;
5175 u32
setup_devices_filter (char *opencl_devices
)
5177 u32 devices_filter
= 0;
5181 char *devices
= strdup (opencl_devices
);
5183 char *next
= strtok (devices
, ",");
5187 int device_id
= atoi (next
);
5189 if (device_id
< 1 || device_id
> 32)
5191 log_error ("ERROR: invalid device_id %u specified", device_id
);
5196 devices_filter
|= 1 << (device_id
- 1);
5198 } while ((next
= strtok (NULL
, ",")) != NULL
);
5204 devices_filter
= -1;
5207 return devices_filter
;
5210 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5212 cl_device_type device_types_filter
= 0;
5214 if (opencl_device_types
)
5216 char *device_types
= strdup (opencl_device_types
);
5218 char *next
= strtok (device_types
, ",");
5222 int device_type
= atoi (next
);
5224 if (device_type
< 1 || device_type
> 3)
5226 log_error ("ERROR: invalid device_type %u specified", device_type
);
5231 device_types_filter
|= 1 << device_type
;
5233 } while ((next
= strtok (NULL
, ",")) != NULL
);
5235 free (device_types
);
5239 // Do not use CPU by default, this often reduces GPU performance because
5240 // the CPU is too busy to handle GPU synchronization
5242 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5245 return device_types_filter
;
5248 u32
get_random_num (const u32 min
, const u32 max
)
5250 if (min
== max
) return (min
);
5252 return ((rand () % (max
- min
)) + min
);
5255 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5257 u32 quotient
= dividend
/ divisor
;
5259 if (dividend
% divisor
) quotient
++;
5264 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5266 u64 quotient
= dividend
/ divisor
;
5268 if (dividend
% divisor
) quotient
++;
5273 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5275 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5276 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5278 if (tm
->tm_year
- 70)
5280 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5281 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5283 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5285 else if (tm
->tm_yday
)
5287 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5288 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5290 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5292 else if (tm
->tm_hour
)
5294 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5295 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5297 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5299 else if (tm
->tm_min
)
5301 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5302 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5304 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5308 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5310 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5314 void format_speed_display (float val
, char *buf
, size_t len
)
5325 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5336 /* generate output */
5340 snprintf (buf
, len
- 1, "%.0f ", val
);
5344 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5348 void lowercase (u8
*buf
, int len
)
5350 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5353 void uppercase (u8
*buf
, int len
)
5355 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5358 int fgetl (FILE *fp
, char *line_buf
)
5364 const int c
= fgetc (fp
);
5366 if (c
== EOF
) break;
5368 line_buf
[line_len
] = (char) c
;
5372 if (line_len
== BUFSIZ
) line_len
--;
5374 if (c
== '\n') break;
5377 if (line_len
== 0) return 0;
5379 if (line_buf
[line_len
- 1] == '\n')
5383 line_buf
[line_len
] = 0;
5386 if (line_len
== 0) return 0;
5388 if (line_buf
[line_len
- 1] == '\r')
5392 line_buf
[line_len
] = 0;
5398 int in_superchop (char *buf
)
5400 int len
= strlen (buf
);
5404 if (buf
[len
- 1] == '\n')
5411 if (buf
[len
- 1] == '\r')
5426 char **scan_directory (const char *path
)
5428 char *tmp_path
= mystrdup (path
);
5430 size_t tmp_path_len
= strlen (tmp_path
);
5432 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5434 tmp_path
[tmp_path_len
- 1] = 0;
5436 tmp_path_len
= strlen (tmp_path
);
5439 char **files
= NULL
;
5445 if ((d
= opendir (tmp_path
)) != NULL
)
5451 memset (&e
, 0, sizeof (e
));
5452 struct dirent
*de
= NULL
;
5454 if (readdir_r (d
, &e
, &de
) != 0)
5456 log_error ("ERROR: readdir_r() failed");
5461 if (de
== NULL
) break;
5465 while ((de
= readdir (d
)) != NULL
)
5468 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5470 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5472 char *path_file
= (char *) mymalloc (path_size
+ 1);
5474 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5476 path_file
[path_size
] = 0;
5480 if ((d_test
= opendir (path_file
)) != NULL
)
5488 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5492 files
[num_files
- 1] = path_file
;
5498 else if (errno
== ENOTDIR
)
5500 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5504 files
[num_files
- 1] = mystrdup (path
);
5507 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5511 files
[num_files
- 1] = NULL
;
5518 int count_dictionaries (char **dictionary_files
)
5520 if (dictionary_files
== NULL
) return 0;
5524 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5532 char *stroptitype (const uint opti_type
)
5536 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5537 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5538 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5539 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5540 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5541 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5542 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5543 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5544 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5545 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5546 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5547 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5548 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5549 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5555 char *strparser (const uint parser_status
)
5557 switch (parser_status
)
5559 case PARSER_OK
: return ((char *) PA_000
); break;
5560 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5561 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5562 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5563 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5564 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5565 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5566 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5567 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5568 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5569 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5570 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5571 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5572 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5573 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5574 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5575 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5578 return ((char *) PA_255
);
5581 char *strhashtype (const uint hash_mode
)
5585 case 0: return ((char *) HT_00000
); break;
5586 case 10: return ((char *) HT_00010
); break;
5587 case 11: return ((char *) HT_00011
); break;
5588 case 12: return ((char *) HT_00012
); break;
5589 case 20: return ((char *) HT_00020
); break;
5590 case 21: return ((char *) HT_00021
); break;
5591 case 22: return ((char *) HT_00022
); break;
5592 case 23: return ((char *) HT_00023
); break;
5593 case 30: return ((char *) HT_00030
); break;
5594 case 40: return ((char *) HT_00040
); break;
5595 case 50: return ((char *) HT_00050
); break;
5596 case 60: return ((char *) HT_00060
); break;
5597 case 100: return ((char *) HT_00100
); break;
5598 case 101: return ((char *) HT_00101
); break;
5599 case 110: return ((char *) HT_00110
); break;
5600 case 111: return ((char *) HT_00111
); break;
5601 case 112: return ((char *) HT_00112
); break;
5602 case 120: return ((char *) HT_00120
); break;
5603 case 121: return ((char *) HT_00121
); break;
5604 case 122: return ((char *) HT_00122
); break;
5605 case 124: return ((char *) HT_00124
); break;
5606 case 130: return ((char *) HT_00130
); break;
5607 case 131: return ((char *) HT_00131
); break;
5608 case 132: return ((char *) HT_00132
); break;
5609 case 133: return ((char *) HT_00133
); break;
5610 case 140: return ((char *) HT_00140
); break;
5611 case 141: return ((char *) HT_00141
); break;
5612 case 150: return ((char *) HT_00150
); break;
5613 case 160: return ((char *) HT_00160
); break;
5614 case 190: return ((char *) HT_00190
); break;
5615 case 200: return ((char *) HT_00200
); break;
5616 case 300: return ((char *) HT_00300
); break;
5617 case 400: return ((char *) HT_00400
); break;
5618 case 500: return ((char *) HT_00500
); break;
5619 case 501: return ((char *) HT_00501
); break;
5620 case 900: return ((char *) HT_00900
); break;
5621 case 910: return ((char *) HT_00910
); break;
5622 case 1000: return ((char *) HT_01000
); break;
5623 case 1100: return ((char *) HT_01100
); break;
5624 case 1400: return ((char *) HT_01400
); break;
5625 case 1410: return ((char *) HT_01410
); break;
5626 case 1420: return ((char *) HT_01420
); break;
5627 case 1421: return ((char *) HT_01421
); break;
5628 case 1430: return ((char *) HT_01430
); break;
5629 case 1440: return ((char *) HT_01440
); break;
5630 case 1441: return ((char *) HT_01441
); break;
5631 case 1450: return ((char *) HT_01450
); break;
5632 case 1460: return ((char *) HT_01460
); break;
5633 case 1500: return ((char *) HT_01500
); break;
5634 case 1600: return ((char *) HT_01600
); break;
5635 case 1700: return ((char *) HT_01700
); break;
5636 case 1710: return ((char *) HT_01710
); break;
5637 case 1711: return ((char *) HT_01711
); break;
5638 case 1720: return ((char *) HT_01720
); break;
5639 case 1722: return ((char *) HT_01722
); break;
5640 case 1730: return ((char *) HT_01730
); break;
5641 case 1731: return ((char *) HT_01731
); break;
5642 case 1740: return ((char *) HT_01740
); break;
5643 case 1750: return ((char *) HT_01750
); break;
5644 case 1760: return ((char *) HT_01760
); break;
5645 case 1800: return ((char *) HT_01800
); break;
5646 case 2100: return ((char *) HT_02100
); break;
5647 case 2400: return ((char *) HT_02400
); break;
5648 case 2410: return ((char *) HT_02410
); break;
5649 case 2500: return ((char *) HT_02500
); break;
5650 case 2600: return ((char *) HT_02600
); break;
5651 case 2611: return ((char *) HT_02611
); break;
5652 case 2612: return ((char *) HT_02612
); break;
5653 case 2711: return ((char *) HT_02711
); break;
5654 case 2811: return ((char *) HT_02811
); break;
5655 case 3000: return ((char *) HT_03000
); break;
5656 case 3100: return ((char *) HT_03100
); break;
5657 case 3200: return ((char *) HT_03200
); break;
5658 case 3710: return ((char *) HT_03710
); break;
5659 case 3711: return ((char *) HT_03711
); break;
5660 case 3800: return ((char *) HT_03800
); break;
5661 case 4300: return ((char *) HT_04300
); break;
5662 case 4400: return ((char *) HT_04400
); break;
5663 case 4500: return ((char *) HT_04500
); break;
5664 case 4700: return ((char *) HT_04700
); break;
5665 case 4800: return ((char *) HT_04800
); break;
5666 case 4900: return ((char *) HT_04900
); break;
5667 case 5000: return ((char *) HT_05000
); break;
5668 case 5100: return ((char *) HT_05100
); break;
5669 case 5200: return ((char *) HT_05200
); break;
5670 case 5300: return ((char *) HT_05300
); break;
5671 case 5400: return ((char *) HT_05400
); break;
5672 case 5500: return ((char *) HT_05500
); break;
5673 case 5600: return ((char *) HT_05600
); break;
5674 case 5700: return ((char *) HT_05700
); break;
5675 case 5800: return ((char *) HT_05800
); break;
5676 case 6000: return ((char *) HT_06000
); break;
5677 case 6100: return ((char *) HT_06100
); break;
5678 case 6211: return ((char *) HT_06211
); break;
5679 case 6212: return ((char *) HT_06212
); break;
5680 case 6213: return ((char *) HT_06213
); break;
5681 case 6221: return ((char *) HT_06221
); break;
5682 case 6222: return ((char *) HT_06222
); break;
5683 case 6223: return ((char *) HT_06223
); break;
5684 case 6231: return ((char *) HT_06231
); break;
5685 case 6232: return ((char *) HT_06232
); break;
5686 case 6233: return ((char *) HT_06233
); break;
5687 case 6241: return ((char *) HT_06241
); break;
5688 case 6242: return ((char *) HT_06242
); break;
5689 case 6243: return ((char *) HT_06243
); break;
5690 case 6300: return ((char *) HT_06300
); break;
5691 case 6400: return ((char *) HT_06400
); break;
5692 case 6500: return ((char *) HT_06500
); break;
5693 case 6600: return ((char *) HT_06600
); break;
5694 case 6700: return ((char *) HT_06700
); break;
5695 case 6800: return ((char *) HT_06800
); break;
5696 case 6900: return ((char *) HT_06900
); break;
5697 case 7100: return ((char *) HT_07100
); break;
5698 case 7200: return ((char *) HT_07200
); break;
5699 case 7300: return ((char *) HT_07300
); break;
5700 case 7400: return ((char *) HT_07400
); break;
5701 case 7500: return ((char *) HT_07500
); break;
5702 case 7600: return ((char *) HT_07600
); break;
5703 case 7700: return ((char *) HT_07700
); break;
5704 case 7800: return ((char *) HT_07800
); break;
5705 case 7900: return ((char *) HT_07900
); break;
5706 case 8000: return ((char *) HT_08000
); break;
5707 case 8100: return ((char *) HT_08100
); break;
5708 case 8200: return ((char *) HT_08200
); break;
5709 case 8300: return ((char *) HT_08300
); break;
5710 case 8400: return ((char *) HT_08400
); break;
5711 case 8500: return ((char *) HT_08500
); break;
5712 case 8600: return ((char *) HT_08600
); break;
5713 case 8700: return ((char *) HT_08700
); break;
5714 case 8800: return ((char *) HT_08800
); break;
5715 case 8900: return ((char *) HT_08900
); break;
5716 case 9000: return ((char *) HT_09000
); break;
5717 case 9100: return ((char *) HT_09100
); break;
5718 case 9200: return ((char *) HT_09200
); break;
5719 case 9300: return ((char *) HT_09300
); break;
5720 case 9400: return ((char *) HT_09400
); break;
5721 case 9500: return ((char *) HT_09500
); break;
5722 case 9600: return ((char *) HT_09600
); break;
5723 case 9700: return ((char *) HT_09700
); break;
5724 case 9710: return ((char *) HT_09710
); break;
5725 case 9720: return ((char *) HT_09720
); break;
5726 case 9800: return ((char *) HT_09800
); break;
5727 case 9810: return ((char *) HT_09810
); break;
5728 case 9820: return ((char *) HT_09820
); break;
5729 case 9900: return ((char *) HT_09900
); break;
5730 case 10000: return ((char *) HT_10000
); break;
5731 case 10100: return ((char *) HT_10100
); break;
5732 case 10200: return ((char *) HT_10200
); break;
5733 case 10300: return ((char *) HT_10300
); break;
5734 case 10400: return ((char *) HT_10400
); break;
5735 case 10410: return ((char *) HT_10410
); break;
5736 case 10420: return ((char *) HT_10420
); break;
5737 case 10500: return ((char *) HT_10500
); break;
5738 case 10600: return ((char *) HT_10600
); break;
5739 case 10700: return ((char *) HT_10700
); break;
5740 case 10800: return ((char *) HT_10800
); break;
5741 case 10900: return ((char *) HT_10900
); break;
5742 case 11000: return ((char *) HT_11000
); break;
5743 case 11100: return ((char *) HT_11100
); break;
5744 case 11200: return ((char *) HT_11200
); break;
5745 case 11300: return ((char *) HT_11300
); break;
5746 case 11400: return ((char *) HT_11400
); break;
5747 case 11500: return ((char *) HT_11500
); break;
5748 case 11600: return ((char *) HT_11600
); break;
5749 case 11700: return ((char *) HT_11700
); break;
5750 case 11800: return ((char *) HT_11800
); break;
5751 case 11900: return ((char *) HT_11900
); break;
5752 case 12000: return ((char *) HT_12000
); break;
5753 case 12100: return ((char *) HT_12100
); break;
5754 case 12200: return ((char *) HT_12200
); break;
5755 case 12300: return ((char *) HT_12300
); break;
5756 case 12400: return ((char *) HT_12400
); break;
5757 case 12500: return ((char *) HT_12500
); break;
5758 case 12600: return ((char *) HT_12600
); break;
5759 case 12700: return ((char *) HT_12700
); break;
5760 case 12800: return ((char *) HT_12800
); break;
5761 case 12900: return ((char *) HT_12900
); break;
5762 case 13000: return ((char *) HT_13000
); break;
5765 return ((char *) "Unknown");
5768 char *strstatus (const uint devices_status
)
5770 switch (devices_status
)
5772 case STATUS_INIT
: return ((char *) ST_0000
); break;
5773 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5774 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5775 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5776 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5777 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5778 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5779 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5780 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5781 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5784 return ((char *) "Unknown");
5787 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5789 uint hash_type
= data
.hash_type
;
5790 uint hash_mode
= data
.hash_mode
;
5791 uint salt_type
= data
.salt_type
;
5792 uint opts_type
= data
.opts_type
;
5793 uint opti_type
= data
.opti_type
;
5794 uint dgst_size
= data
.dgst_size
;
5796 char *hashfile
= data
.hashfile
;
5800 uint digest_buf
[64] = { 0 };
5802 u64
*digest_buf64
= (u64
*) digest_buf
;
5804 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5806 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5808 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5814 case HASH_TYPE_DESCRYPT
:
5815 FP (digest_buf
[1], digest_buf
[0], tt
);
5818 case HASH_TYPE_DESRACF
:
5819 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5820 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5822 FP (digest_buf
[1], digest_buf
[0], tt
);
5826 FP (digest_buf
[1], digest_buf
[0], tt
);
5829 case HASH_TYPE_NETNTLM
:
5830 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5831 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5832 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5833 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5835 FP (digest_buf
[1], digest_buf
[0], tt
);
5836 FP (digest_buf
[3], digest_buf
[2], tt
);
5839 case HASH_TYPE_BSDICRYPT
:
5840 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5841 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5843 FP (digest_buf
[1], digest_buf
[0], tt
);
5848 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5853 digest_buf
[0] += MD4M_A
;
5854 digest_buf
[1] += MD4M_B
;
5855 digest_buf
[2] += MD4M_C
;
5856 digest_buf
[3] += MD4M_D
;
5860 digest_buf
[0] += MD5M_A
;
5861 digest_buf
[1] += MD5M_B
;
5862 digest_buf
[2] += MD5M_C
;
5863 digest_buf
[3] += MD5M_D
;
5866 case HASH_TYPE_SHA1
:
5867 digest_buf
[0] += SHA1M_A
;
5868 digest_buf
[1] += SHA1M_B
;
5869 digest_buf
[2] += SHA1M_C
;
5870 digest_buf
[3] += SHA1M_D
;
5871 digest_buf
[4] += SHA1M_E
;
5874 case HASH_TYPE_SHA256
:
5875 digest_buf
[0] += SHA256M_A
;
5876 digest_buf
[1] += SHA256M_B
;
5877 digest_buf
[2] += SHA256M_C
;
5878 digest_buf
[3] += SHA256M_D
;
5879 digest_buf
[4] += SHA256M_E
;
5880 digest_buf
[5] += SHA256M_F
;
5881 digest_buf
[6] += SHA256M_G
;
5882 digest_buf
[7] += SHA256M_H
;
5885 case HASH_TYPE_SHA384
:
5886 digest_buf64
[0] += SHA384M_A
;
5887 digest_buf64
[1] += SHA384M_B
;
5888 digest_buf64
[2] += SHA384M_C
;
5889 digest_buf64
[3] += SHA384M_D
;
5890 digest_buf64
[4] += SHA384M_E
;
5891 digest_buf64
[5] += SHA384M_F
;
5892 digest_buf64
[6] += 0;
5893 digest_buf64
[7] += 0;
5896 case HASH_TYPE_SHA512
:
5897 digest_buf64
[0] += SHA512M_A
;
5898 digest_buf64
[1] += SHA512M_B
;
5899 digest_buf64
[2] += SHA512M_C
;
5900 digest_buf64
[3] += SHA512M_D
;
5901 digest_buf64
[4] += SHA512M_E
;
5902 digest_buf64
[5] += SHA512M_F
;
5903 digest_buf64
[6] += SHA512M_G
;
5904 digest_buf64
[7] += SHA512M_H
;
5909 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5911 if (dgst_size
== DGST_SIZE_4_2
)
5913 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5915 else if (dgst_size
== DGST_SIZE_4_4
)
5917 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5919 else if (dgst_size
== DGST_SIZE_4_5
)
5921 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5923 else if (dgst_size
== DGST_SIZE_4_6
)
5925 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5927 else if (dgst_size
== DGST_SIZE_4_8
)
5929 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5931 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5933 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5935 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5937 else if (hash_type
== HASH_TYPE_SHA384
)
5939 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5941 else if (hash_type
== HASH_TYPE_SHA512
)
5943 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5945 else if (hash_type
== HASH_TYPE_GOST
)
5947 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5950 else if (dgst_size
== DGST_SIZE_4_64
)
5952 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5954 else if (dgst_size
== DGST_SIZE_8_25
)
5956 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5960 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5961 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5962 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5968 memset (&salt
, 0, sizeof (salt_t
));
5970 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5972 char *ptr
= (char *) salt
.salt_buf
;
5974 uint len
= salt
.salt_len
;
5976 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5982 case HASH_TYPE_NETNTLM
:
5984 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
5985 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
5987 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5993 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5995 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6003 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6005 uint max
= salt
.salt_len
/ 4;
6009 for (uint i
= 0; i
< max
; i
++)
6011 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6015 if (opts_type
& OPTS_TYPE_ST_HEX
)
6017 char tmp
[64] = { 0 };
6019 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6021 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6026 memcpy (ptr
, tmp
, len
);
6029 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6031 memset (ptr
+ len
, 0, memset_size
);
6033 salt
.salt_len
= len
;
6037 // some modes require special encoding
6040 uint out_buf_plain
[256] = { 0 };
6041 uint out_buf_salt
[256] = { 0 };
6043 char tmp_buf
[1024] = { 0 };
6045 char *ptr_plain
= (char *) out_buf_plain
;
6046 char *ptr_salt
= (char *) out_buf_salt
;
6048 if (hash_mode
== 22)
6050 char username
[30] = { 0 };
6052 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6054 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6056 u16
*ptr
= (u16
*) digest_buf
;
6058 tmp_buf
[ 0] = sig
[0];
6059 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6060 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6061 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6062 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6063 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6064 tmp_buf
[ 6] = sig
[1];
6065 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6066 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6067 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6068 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6069 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6070 tmp_buf
[12] = sig
[2];
6071 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6072 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6073 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6074 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6075 tmp_buf
[17] = sig
[3];
6076 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6077 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6078 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6079 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6080 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6081 tmp_buf
[23] = sig
[4];
6082 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6083 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6084 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6085 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6086 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6087 tmp_buf
[29] = sig
[5];
6089 snprintf (out_buf
, len
-1, "%s:%s",
6093 else if (hash_mode
== 23)
6095 // do not show the \nskyper\n part in output
6097 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6099 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6101 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6108 else if (hash_mode
== 101)
6110 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6112 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6113 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6114 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6115 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6116 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6118 memcpy (tmp_buf
, digest_buf
, 20);
6120 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6122 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6124 else if (hash_mode
== 111)
6126 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6128 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6129 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6130 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6131 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6132 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6134 memcpy (tmp_buf
, digest_buf
, 20);
6135 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6137 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6139 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6141 else if (hash_mode
== 122)
6143 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6144 (char *) salt
.salt_buf
,
6151 else if (hash_mode
== 124)
6153 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6154 (char *) salt
.salt_buf
,
6161 else if (hash_mode
== 131)
6163 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6164 (char *) salt
.salt_buf
,
6172 else if (hash_mode
== 132)
6174 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6175 (char *) salt
.salt_buf
,
6182 else if (hash_mode
== 133)
6184 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6186 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6187 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6188 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6189 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6190 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6192 memcpy (tmp_buf
, digest_buf
, 20);
6194 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6196 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6198 else if (hash_mode
== 141)
6200 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6202 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6204 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6206 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6208 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6209 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6210 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6211 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6212 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6214 memcpy (tmp_buf
, digest_buf
, 20);
6216 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6220 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6222 else if (hash_mode
== 400)
6224 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6226 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6227 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6228 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6229 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6231 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6233 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6235 else if (hash_mode
== 500)
6237 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6239 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6240 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6241 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6242 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6244 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6246 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6248 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6252 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6255 else if (hash_mode
== 501)
6257 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6259 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6260 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6262 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6264 else if (hash_mode
== 1421)
6266 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6268 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6284 else if (hash_mode
== 1441)
6286 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6288 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6290 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6292 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6294 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6295 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6296 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6297 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6298 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6299 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6300 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6301 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6303 memcpy (tmp_buf
, digest_buf
, 32);
6305 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6309 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6311 else if (hash_mode
== 1500)
6313 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6314 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6315 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6316 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6317 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6319 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6321 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6323 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6324 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6326 memcpy (tmp_buf
, digest_buf
, 8);
6328 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6330 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6334 else if (hash_mode
== 1600)
6336 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6338 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6339 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6340 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6341 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6343 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6345 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6347 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6351 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6354 else if (hash_mode
== 1711)
6356 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6358 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6359 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6360 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6361 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6362 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6363 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6364 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6365 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6367 memcpy (tmp_buf
, digest_buf
, 64);
6368 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6370 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6372 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6374 else if (hash_mode
== 1722)
6376 uint
*ptr
= digest_buf
;
6378 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6379 (unsigned char *) salt
.salt_buf
,
6389 else if (hash_mode
== 1731)
6391 uint
*ptr
= digest_buf
;
6393 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6394 (unsigned char *) salt
.salt_buf
,
6404 else if (hash_mode
== 1800)
6408 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6409 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6410 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6411 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6412 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6413 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6414 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6415 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6417 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6419 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6421 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6425 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6428 else if (hash_mode
== 2100)
6432 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6434 salt
.salt_iter
+ 1);
6436 uint signature_len
= strlen (out_buf
);
6438 pos
+= signature_len
;
6439 len
-= signature_len
;
6441 char *salt_ptr
= (char *) salt
.salt_buf
;
6443 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6445 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6446 byte_swap_32 (digest_buf
[0]),
6447 byte_swap_32 (digest_buf
[1]),
6448 byte_swap_32 (digest_buf
[2]),
6449 byte_swap_32 (digest_buf
[3]));
6451 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6453 memcpy (tmp_buf
, digest_buf
, 16);
6455 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6457 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6458 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6459 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6460 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6462 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6463 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6464 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6465 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6467 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6468 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6469 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6470 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6472 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6473 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6474 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6475 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6477 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6478 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6479 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6480 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6484 else if (hash_mode
== 2500)
6486 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6488 wpa_t
*wpa
= &wpas
[salt_pos
];
6490 uint pke
[25] = { 0 };
6492 char *pke_ptr
= (char *) pke
;
6494 for (uint i
= 0; i
< 25; i
++)
6496 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6499 unsigned char mac1
[6] = { 0 };
6500 unsigned char mac2
[6] = { 0 };
6502 memcpy (mac1
, pke_ptr
+ 23, 6);
6503 memcpy (mac2
, pke_ptr
+ 29, 6);
6505 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6506 (char *) salt
.salt_buf
,
6520 else if (hash_mode
== 4400)
6522 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6523 byte_swap_32 (digest_buf
[0]),
6524 byte_swap_32 (digest_buf
[1]),
6525 byte_swap_32 (digest_buf
[2]),
6526 byte_swap_32 (digest_buf
[3]));
6528 else if (hash_mode
== 4700)
6530 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6531 byte_swap_32 (digest_buf
[0]),
6532 byte_swap_32 (digest_buf
[1]),
6533 byte_swap_32 (digest_buf
[2]),
6534 byte_swap_32 (digest_buf
[3]),
6535 byte_swap_32 (digest_buf
[4]));
6537 else if (hash_mode
== 4800)
6539 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6541 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6546 byte_swap_32 (salt
.salt_buf
[0]),
6547 byte_swap_32 (salt
.salt_buf
[1]),
6548 byte_swap_32 (salt
.salt_buf
[2]),
6549 byte_swap_32 (salt
.salt_buf
[3]),
6552 else if (hash_mode
== 4900)
6554 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6555 byte_swap_32 (digest_buf
[0]),
6556 byte_swap_32 (digest_buf
[1]),
6557 byte_swap_32 (digest_buf
[2]),
6558 byte_swap_32 (digest_buf
[3]),
6559 byte_swap_32 (digest_buf
[4]));
6561 else if (hash_mode
== 5100)
6563 snprintf (out_buf
, len
-1, "%08x%08x",
6567 else if (hash_mode
== 5200)
6569 snprintf (out_buf
, len
-1, "%s", hashfile
);
6571 else if (hash_mode
== 5300)
6573 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6575 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6577 int buf_len
= len
-1;
6581 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6583 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6585 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6587 snprintf (out_buf
, buf_len
, ":");
6593 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6601 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6603 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6605 if ((i
== 0) || (i
== 5))
6607 snprintf (out_buf
, buf_len
, ":");
6613 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6621 for (uint i
= 0; i
< 4; i
++)
6625 snprintf (out_buf
, buf_len
, ":");
6631 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6637 else if (hash_mode
== 5400)
6639 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6641 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6643 int buf_len
= len
-1;
6647 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6649 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6651 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6653 snprintf (out_buf
, buf_len
, ":");
6659 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6667 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6669 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6671 if ((i
== 0) || (i
== 5))
6673 snprintf (out_buf
, buf_len
, ":");
6679 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6687 for (uint i
= 0; i
< 5; i
++)
6691 snprintf (out_buf
, buf_len
, ":");
6697 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6703 else if (hash_mode
== 5500)
6705 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6707 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6709 char user_buf
[64] = { 0 };
6710 char domain_buf
[64] = { 0 };
6711 char srvchall_buf
[1024] = { 0 };
6712 char clichall_buf
[1024] = { 0 };
6714 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6716 char *ptr
= (char *) netntlm
->userdomain_buf
;
6718 user_buf
[i
] = ptr
[j
];
6721 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6723 char *ptr
= (char *) netntlm
->userdomain_buf
;
6725 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6728 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6730 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6732 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6735 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6737 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6739 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6742 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6750 byte_swap_32 (salt
.salt_buf_pc
[0]),
6751 byte_swap_32 (salt
.salt_buf_pc
[1]),
6754 else if (hash_mode
== 5600)
6756 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6758 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6760 char user_buf
[64] = { 0 };
6761 char domain_buf
[64] = { 0 };
6762 char srvchall_buf
[1024] = { 0 };
6763 char clichall_buf
[1024] = { 0 };
6765 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6767 char *ptr
= (char *) netntlm
->userdomain_buf
;
6769 user_buf
[i
] = ptr
[j
];
6772 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6774 char *ptr
= (char *) netntlm
->userdomain_buf
;
6776 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6779 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6781 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6783 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6786 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6788 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6790 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6793 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6803 else if (hash_mode
== 5700)
6805 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6807 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6808 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6809 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6810 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6811 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6812 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6813 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6814 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6816 memcpy (tmp_buf
, digest_buf
, 32);
6818 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6822 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6824 else if (hash_mode
== 5800)
6826 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6827 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6828 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6829 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6830 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6832 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6839 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6841 snprintf (out_buf
, len
-1, "%s", hashfile
);
6843 else if (hash_mode
== 6300)
6845 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6847 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6848 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6849 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6850 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6852 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6854 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6856 else if (hash_mode
== 6400)
6858 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6860 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6862 else if (hash_mode
== 6500)
6864 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6866 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6868 else if (hash_mode
== 6600)
6870 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6872 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6874 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6875 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6877 uint buf_len
= len
- 1;
6879 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6882 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6884 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6889 else if (hash_mode
== 6700)
6891 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6893 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6895 else if (hash_mode
== 6800)
6897 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6899 else if (hash_mode
== 7100)
6901 uint
*ptr
= digest_buf
;
6903 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6905 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6907 uint esalt
[8] = { 0 };
6909 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6910 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6911 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6912 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6913 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6914 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6915 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6916 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6918 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",
6919 SIGNATURE_SHA512OSX
,
6921 esalt
[ 0], esalt
[ 1],
6922 esalt
[ 2], esalt
[ 3],
6923 esalt
[ 4], esalt
[ 5],
6924 esalt
[ 6], esalt
[ 7],
6932 ptr
[15], ptr
[14]);
6934 else if (hash_mode
== 7200)
6936 uint
*ptr
= digest_buf
;
6938 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6940 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6944 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6946 len_used
= strlen (out_buf
);
6948 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6950 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6952 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6955 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",
6963 ptr
[15], ptr
[14]);
6965 else if (hash_mode
== 7300)
6967 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6969 rakp_t
*rakp
= &rakps
[salt_pos
];
6971 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6973 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6976 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6983 else if (hash_mode
== 7400)
6985 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6987 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6988 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6989 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6990 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6991 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6992 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6993 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6994 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6996 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6998 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7000 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7004 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7007 else if (hash_mode
== 7500)
7009 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7011 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7013 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7014 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7016 char data
[128] = { 0 };
7018 char *ptr_data
= data
;
7020 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7022 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7025 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7027 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7032 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7034 (char *) krb5pa
->user
,
7035 (char *) krb5pa
->realm
,
7036 (char *) krb5pa
->salt
,
7039 else if (hash_mode
== 7700)
7041 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7042 (char *) salt
.salt_buf
,
7046 else if (hash_mode
== 7800)
7048 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7049 (char *) salt
.salt_buf
,
7056 else if (hash_mode
== 7900)
7058 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7062 char *tmp
= (char *) salt
.salt_buf_pc
;
7064 ptr_plain
[42] = tmp
[0];
7070 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7072 else if (hash_mode
== 8000)
7074 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7075 (unsigned char *) salt
.salt_buf
,
7085 else if (hash_mode
== 8100)
7087 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7088 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7090 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7091 (unsigned char *) salt
.salt_buf
,
7098 else if (hash_mode
== 8200)
7100 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7102 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7104 char data_buf
[4096] = { 0 };
7106 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7108 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7111 data_buf
[cloudkey
->data_len
* 2] = 0;
7113 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7114 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7115 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7116 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7117 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7118 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7119 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7120 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7122 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7123 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7124 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7125 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7127 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7143 else if (hash_mode
== 8300)
7145 char digest_buf_c
[34] = { 0 };
7147 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7149 digest_buf_c
[32] = 0;
7153 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7155 char domain_buf_c
[33] = { 0 };
7157 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7159 for (uint i
= 0; i
< salt_pc_len
; i
++)
7161 const char next
= domain_buf_c
[i
];
7163 domain_buf_c
[i
] = '.';
7168 domain_buf_c
[salt_pc_len
] = 0;
7172 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7174 else if (hash_mode
== 8500)
7176 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7178 else if (hash_mode
== 2612)
7180 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7182 (char *) salt
.salt_buf
,
7188 else if (hash_mode
== 3711)
7190 char *salt_ptr
= (char *) salt
.salt_buf
;
7192 salt_ptr
[salt
.salt_len
- 1] = 0;
7194 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7195 SIGNATURE_MEDIAWIKI_B
,
7202 else if (hash_mode
== 8800)
7204 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7206 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7208 char tmp
[3073] = { 0 };
7210 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7212 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7217 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7218 SIGNATURE_ANDROIDFDE
,
7219 byte_swap_32 (salt
.salt_buf
[0]),
7220 byte_swap_32 (salt
.salt_buf
[1]),
7221 byte_swap_32 (salt
.salt_buf
[2]),
7222 byte_swap_32 (salt
.salt_buf
[3]),
7223 byte_swap_32 (digest_buf
[0]),
7224 byte_swap_32 (digest_buf
[1]),
7225 byte_swap_32 (digest_buf
[2]),
7226 byte_swap_32 (digest_buf
[3]),
7229 else if (hash_mode
== 8900)
7231 uint N
= salt
.scrypt_N
;
7232 uint r
= salt
.scrypt_r
;
7233 uint p
= salt
.scrypt_p
;
7235 char base64_salt
[32] = { 0 };
7237 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7239 memset (tmp_buf
, 0, 46);
7241 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7242 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7243 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7244 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7245 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7246 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7247 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7248 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7249 digest_buf
[8] = 0; // needed for base64_encode ()
7251 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7253 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7261 else if (hash_mode
== 9000)
7263 snprintf (out_buf
, len
-1, "%s", hashfile
);
7265 else if (hash_mode
== 9200)
7269 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7271 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7273 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7277 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7278 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7279 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7280 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7281 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7282 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7283 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7284 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7285 digest_buf
[8] = 0; // needed for base64_encode ()
7287 char tmp_buf
[64] = { 0 };
7289 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7290 tmp_buf
[43] = 0; // cut it here
7294 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7296 else if (hash_mode
== 9300)
7298 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7299 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7300 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7301 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7302 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7303 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7304 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7305 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7306 digest_buf
[8] = 0; // needed for base64_encode ()
7308 char tmp_buf
[64] = { 0 };
7310 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7311 tmp_buf
[43] = 0; // cut it here
7313 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7315 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7317 else if (hash_mode
== 9400)
7319 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7321 office2007_t
*office2007
= &office2007s
[salt_pos
];
7323 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7324 SIGNATURE_OFFICE2007
,
7327 office2007
->keySize
,
7333 office2007
->encryptedVerifier
[0],
7334 office2007
->encryptedVerifier
[1],
7335 office2007
->encryptedVerifier
[2],
7336 office2007
->encryptedVerifier
[3],
7337 office2007
->encryptedVerifierHash
[0],
7338 office2007
->encryptedVerifierHash
[1],
7339 office2007
->encryptedVerifierHash
[2],
7340 office2007
->encryptedVerifierHash
[3],
7341 office2007
->encryptedVerifierHash
[4]);
7343 else if (hash_mode
== 9500)
7345 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7347 office2010_t
*office2010
= &office2010s
[salt_pos
];
7349 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,
7355 office2010
->encryptedVerifier
[0],
7356 office2010
->encryptedVerifier
[1],
7357 office2010
->encryptedVerifier
[2],
7358 office2010
->encryptedVerifier
[3],
7359 office2010
->encryptedVerifierHash
[0],
7360 office2010
->encryptedVerifierHash
[1],
7361 office2010
->encryptedVerifierHash
[2],
7362 office2010
->encryptedVerifierHash
[3],
7363 office2010
->encryptedVerifierHash
[4],
7364 office2010
->encryptedVerifierHash
[5],
7365 office2010
->encryptedVerifierHash
[6],
7366 office2010
->encryptedVerifierHash
[7]);
7368 else if (hash_mode
== 9600)
7370 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7372 office2013_t
*office2013
= &office2013s
[salt_pos
];
7374 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,
7380 office2013
->encryptedVerifier
[0],
7381 office2013
->encryptedVerifier
[1],
7382 office2013
->encryptedVerifier
[2],
7383 office2013
->encryptedVerifier
[3],
7384 office2013
->encryptedVerifierHash
[0],
7385 office2013
->encryptedVerifierHash
[1],
7386 office2013
->encryptedVerifierHash
[2],
7387 office2013
->encryptedVerifierHash
[3],
7388 office2013
->encryptedVerifierHash
[4],
7389 office2013
->encryptedVerifierHash
[5],
7390 office2013
->encryptedVerifierHash
[6],
7391 office2013
->encryptedVerifierHash
[7]);
7393 else if (hash_mode
== 9700)
7395 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7397 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7399 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7400 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7401 byte_swap_32 (salt
.salt_buf
[0]),
7402 byte_swap_32 (salt
.salt_buf
[1]),
7403 byte_swap_32 (salt
.salt_buf
[2]),
7404 byte_swap_32 (salt
.salt_buf
[3]),
7405 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7406 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7407 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7408 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7409 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7410 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7411 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7412 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7414 else if (hash_mode
== 9710)
7416 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7418 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7420 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7421 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7422 byte_swap_32 (salt
.salt_buf
[0]),
7423 byte_swap_32 (salt
.salt_buf
[1]),
7424 byte_swap_32 (salt
.salt_buf
[2]),
7425 byte_swap_32 (salt
.salt_buf
[3]),
7426 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7427 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7428 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7429 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7430 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7431 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7432 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7433 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7435 else if (hash_mode
== 9720)
7437 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7439 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7441 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7443 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7444 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7445 byte_swap_32 (salt
.salt_buf
[0]),
7446 byte_swap_32 (salt
.salt_buf
[1]),
7447 byte_swap_32 (salt
.salt_buf
[2]),
7448 byte_swap_32 (salt
.salt_buf
[3]),
7449 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7450 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7451 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7452 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7453 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7454 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7455 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7456 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7463 else if (hash_mode
== 9800)
7465 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7467 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7469 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7470 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7475 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7476 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7477 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7478 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7479 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7480 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7481 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7482 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7483 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7485 else if (hash_mode
== 9810)
7487 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7489 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7491 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7492 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7497 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7498 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7499 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7500 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7501 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7502 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7503 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7504 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7505 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7507 else if (hash_mode
== 9820)
7509 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7511 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7513 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7515 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7516 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7521 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7522 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7523 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7524 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7525 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7526 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7527 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7528 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7529 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7536 else if (hash_mode
== 10000)
7540 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7542 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7544 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7548 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7549 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7550 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7551 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7552 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7553 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7554 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7555 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7556 digest_buf
[8] = 0; // needed for base64_encode ()
7558 char tmp_buf
[64] = { 0 };
7560 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7564 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7566 else if (hash_mode
== 10100)
7568 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7573 byte_swap_32 (salt
.salt_buf
[0]),
7574 byte_swap_32 (salt
.salt_buf
[1]),
7575 byte_swap_32 (salt
.salt_buf
[2]),
7576 byte_swap_32 (salt
.salt_buf
[3]));
7578 else if (hash_mode
== 10200)
7580 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7582 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7586 char challenge
[100] = { 0 };
7588 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7592 char tmp_buf
[100] = { 0 };
7594 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7595 (char *) cram_md5
->user
,
7601 char response
[100] = { 0 };
7603 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7605 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7607 else if (hash_mode
== 10300)
7609 char tmp_buf
[100] = { 0 };
7611 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7612 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7614 uint tmp_len
= 20 + salt
.salt_len
;
7618 char base64_encoded
[100] = { 0 };
7620 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7622 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7624 else if (hash_mode
== 10400)
7626 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7628 pdf_t
*pdf
= &pdfs
[salt_pos
];
7630 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",
7638 byte_swap_32 (pdf
->id_buf
[0]),
7639 byte_swap_32 (pdf
->id_buf
[1]),
7640 byte_swap_32 (pdf
->id_buf
[2]),
7641 byte_swap_32 (pdf
->id_buf
[3]),
7643 byte_swap_32 (pdf
->u_buf
[0]),
7644 byte_swap_32 (pdf
->u_buf
[1]),
7645 byte_swap_32 (pdf
->u_buf
[2]),
7646 byte_swap_32 (pdf
->u_buf
[3]),
7647 byte_swap_32 (pdf
->u_buf
[4]),
7648 byte_swap_32 (pdf
->u_buf
[5]),
7649 byte_swap_32 (pdf
->u_buf
[6]),
7650 byte_swap_32 (pdf
->u_buf
[7]),
7652 byte_swap_32 (pdf
->o_buf
[0]),
7653 byte_swap_32 (pdf
->o_buf
[1]),
7654 byte_swap_32 (pdf
->o_buf
[2]),
7655 byte_swap_32 (pdf
->o_buf
[3]),
7656 byte_swap_32 (pdf
->o_buf
[4]),
7657 byte_swap_32 (pdf
->o_buf
[5]),
7658 byte_swap_32 (pdf
->o_buf
[6]),
7659 byte_swap_32 (pdf
->o_buf
[7])
7662 else if (hash_mode
== 10410)
7664 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7666 pdf_t
*pdf
= &pdfs
[salt_pos
];
7668 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",
7676 byte_swap_32 (pdf
->id_buf
[0]),
7677 byte_swap_32 (pdf
->id_buf
[1]),
7678 byte_swap_32 (pdf
->id_buf
[2]),
7679 byte_swap_32 (pdf
->id_buf
[3]),
7681 byte_swap_32 (pdf
->u_buf
[0]),
7682 byte_swap_32 (pdf
->u_buf
[1]),
7683 byte_swap_32 (pdf
->u_buf
[2]),
7684 byte_swap_32 (pdf
->u_buf
[3]),
7685 byte_swap_32 (pdf
->u_buf
[4]),
7686 byte_swap_32 (pdf
->u_buf
[5]),
7687 byte_swap_32 (pdf
->u_buf
[6]),
7688 byte_swap_32 (pdf
->u_buf
[7]),
7690 byte_swap_32 (pdf
->o_buf
[0]),
7691 byte_swap_32 (pdf
->o_buf
[1]),
7692 byte_swap_32 (pdf
->o_buf
[2]),
7693 byte_swap_32 (pdf
->o_buf
[3]),
7694 byte_swap_32 (pdf
->o_buf
[4]),
7695 byte_swap_32 (pdf
->o_buf
[5]),
7696 byte_swap_32 (pdf
->o_buf
[6]),
7697 byte_swap_32 (pdf
->o_buf
[7])
7700 else if (hash_mode
== 10420)
7702 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7704 pdf_t
*pdf
= &pdfs
[salt_pos
];
7706 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7708 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",
7716 byte_swap_32 (pdf
->id_buf
[0]),
7717 byte_swap_32 (pdf
->id_buf
[1]),
7718 byte_swap_32 (pdf
->id_buf
[2]),
7719 byte_swap_32 (pdf
->id_buf
[3]),
7721 byte_swap_32 (pdf
->u_buf
[0]),
7722 byte_swap_32 (pdf
->u_buf
[1]),
7723 byte_swap_32 (pdf
->u_buf
[2]),
7724 byte_swap_32 (pdf
->u_buf
[3]),
7725 byte_swap_32 (pdf
->u_buf
[4]),
7726 byte_swap_32 (pdf
->u_buf
[5]),
7727 byte_swap_32 (pdf
->u_buf
[6]),
7728 byte_swap_32 (pdf
->u_buf
[7]),
7730 byte_swap_32 (pdf
->o_buf
[0]),
7731 byte_swap_32 (pdf
->o_buf
[1]),
7732 byte_swap_32 (pdf
->o_buf
[2]),
7733 byte_swap_32 (pdf
->o_buf
[3]),
7734 byte_swap_32 (pdf
->o_buf
[4]),
7735 byte_swap_32 (pdf
->o_buf
[5]),
7736 byte_swap_32 (pdf
->o_buf
[6]),
7737 byte_swap_32 (pdf
->o_buf
[7]),
7745 else if (hash_mode
== 10500)
7747 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7749 pdf_t
*pdf
= &pdfs
[salt_pos
];
7751 if (pdf
->id_len
== 32)
7753 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",
7761 byte_swap_32 (pdf
->id_buf
[0]),
7762 byte_swap_32 (pdf
->id_buf
[1]),
7763 byte_swap_32 (pdf
->id_buf
[2]),
7764 byte_swap_32 (pdf
->id_buf
[3]),
7765 byte_swap_32 (pdf
->id_buf
[4]),
7766 byte_swap_32 (pdf
->id_buf
[5]),
7767 byte_swap_32 (pdf
->id_buf
[6]),
7768 byte_swap_32 (pdf
->id_buf
[7]),
7770 byte_swap_32 (pdf
->u_buf
[0]),
7771 byte_swap_32 (pdf
->u_buf
[1]),
7772 byte_swap_32 (pdf
->u_buf
[2]),
7773 byte_swap_32 (pdf
->u_buf
[3]),
7774 byte_swap_32 (pdf
->u_buf
[4]),
7775 byte_swap_32 (pdf
->u_buf
[5]),
7776 byte_swap_32 (pdf
->u_buf
[6]),
7777 byte_swap_32 (pdf
->u_buf
[7]),
7779 byte_swap_32 (pdf
->o_buf
[0]),
7780 byte_swap_32 (pdf
->o_buf
[1]),
7781 byte_swap_32 (pdf
->o_buf
[2]),
7782 byte_swap_32 (pdf
->o_buf
[3]),
7783 byte_swap_32 (pdf
->o_buf
[4]),
7784 byte_swap_32 (pdf
->o_buf
[5]),
7785 byte_swap_32 (pdf
->o_buf
[6]),
7786 byte_swap_32 (pdf
->o_buf
[7])
7791 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",
7799 byte_swap_32 (pdf
->id_buf
[0]),
7800 byte_swap_32 (pdf
->id_buf
[1]),
7801 byte_swap_32 (pdf
->id_buf
[2]),
7802 byte_swap_32 (pdf
->id_buf
[3]),
7804 byte_swap_32 (pdf
->u_buf
[0]),
7805 byte_swap_32 (pdf
->u_buf
[1]),
7806 byte_swap_32 (pdf
->u_buf
[2]),
7807 byte_swap_32 (pdf
->u_buf
[3]),
7808 byte_swap_32 (pdf
->u_buf
[4]),
7809 byte_swap_32 (pdf
->u_buf
[5]),
7810 byte_swap_32 (pdf
->u_buf
[6]),
7811 byte_swap_32 (pdf
->u_buf
[7]),
7813 byte_swap_32 (pdf
->o_buf
[0]),
7814 byte_swap_32 (pdf
->o_buf
[1]),
7815 byte_swap_32 (pdf
->o_buf
[2]),
7816 byte_swap_32 (pdf
->o_buf
[3]),
7817 byte_swap_32 (pdf
->o_buf
[4]),
7818 byte_swap_32 (pdf
->o_buf
[5]),
7819 byte_swap_32 (pdf
->o_buf
[6]),
7820 byte_swap_32 (pdf
->o_buf
[7])
7824 else if (hash_mode
== 10600)
7826 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7828 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7829 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7831 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7833 else if (hash_mode
== 10700)
7835 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7837 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7838 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7840 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7842 else if (hash_mode
== 10900)
7844 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7846 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7847 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7849 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7851 else if (hash_mode
== 11100)
7853 u32 salt_challenge
= salt
.salt_buf
[0];
7855 salt_challenge
= byte_swap_32 (salt_challenge
);
7857 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7859 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7860 SIGNATURE_POSTGRESQL_AUTH
,
7868 else if (hash_mode
== 11200)
7870 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7871 SIGNATURE_MYSQL_AUTH
,
7872 (unsigned char *) salt
.salt_buf
,
7879 else if (hash_mode
== 11300)
7881 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7883 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7885 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7886 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7887 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7889 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7890 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7891 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7893 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7895 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7897 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7900 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7902 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7904 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7907 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7909 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7911 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7914 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7915 SIGNATURE_BITCOIN_WALLET
,
7919 (unsigned char *) salt
.salt_buf
,
7927 free (cry_master_buf
);
7929 free (public_key_buf
);
7931 else if (hash_mode
== 11400)
7933 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7935 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7936 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7938 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7940 else if (hash_mode
== 11600)
7942 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7944 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7946 const uint data_len
= seven_zip
->data_len
;
7948 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7950 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7952 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
7954 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7957 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7958 SIGNATURE_SEVEN_ZIP
,
7962 (char *) seven_zip
->salt_buf
,
7964 seven_zip
->iv_buf
[0],
7965 seven_zip
->iv_buf
[1],
7966 seven_zip
->iv_buf
[2],
7967 seven_zip
->iv_buf
[3],
7969 seven_zip
->data_len
,
7970 seven_zip
->unpack_size
,
7975 else if (hash_mode
== 11700)
7977 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7987 else if (hash_mode
== 11800)
7989 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8007 else if (hash_mode
== 11900)
8009 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8011 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8012 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8014 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8016 else if (hash_mode
== 12000)
8018 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8020 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8021 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8023 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8025 else if (hash_mode
== 12100)
8027 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8029 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8030 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8032 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8034 else if (hash_mode
== 12200)
8036 uint
*ptr_digest
= digest_buf
;
8037 uint
*ptr_salt
= salt
.salt_buf
;
8039 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8046 else if (hash_mode
== 12300)
8048 uint
*ptr_digest
= digest_buf
;
8049 uint
*ptr_salt
= salt
.salt_buf
;
8051 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",
8052 ptr_digest
[ 0], ptr_digest
[ 1],
8053 ptr_digest
[ 2], ptr_digest
[ 3],
8054 ptr_digest
[ 4], ptr_digest
[ 5],
8055 ptr_digest
[ 6], ptr_digest
[ 7],
8056 ptr_digest
[ 8], ptr_digest
[ 9],
8057 ptr_digest
[10], ptr_digest
[11],
8058 ptr_digest
[12], ptr_digest
[13],
8059 ptr_digest
[14], ptr_digest
[15],
8065 else if (hash_mode
== 12400)
8067 // encode iteration count
8069 char salt_iter
[5] = { 0 };
8071 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8072 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8073 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8074 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8079 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8080 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8081 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8082 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8087 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8089 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8090 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8092 memcpy (tmp_buf
, digest_buf
, 8);
8094 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8098 // fill the resulting buffer
8100 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8102 else if (hash_mode
== 12500)
8104 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8106 byte_swap_32 (salt
.salt_buf
[0]),
8107 byte_swap_32 (salt
.salt_buf
[1]),
8113 else if (hash_mode
== 12600)
8115 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8116 digest_buf
[0] + salt
.salt_buf_pc
[0],
8117 digest_buf
[1] + salt
.salt_buf_pc
[1],
8118 digest_buf
[2] + salt
.salt_buf_pc
[2],
8119 digest_buf
[3] + salt
.salt_buf_pc
[3],
8120 digest_buf
[4] + salt
.salt_buf_pc
[4],
8121 digest_buf
[5] + salt
.salt_buf_pc
[5],
8122 digest_buf
[6] + salt
.salt_buf_pc
[6],
8123 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8125 else if (hash_mode
== 12700)
8127 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8129 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8130 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8132 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8134 else if (hash_mode
== 12800)
8136 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8138 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",
8151 byte_swap_32 (digest_buf
[0]),
8152 byte_swap_32 (digest_buf
[1]),
8153 byte_swap_32 (digest_buf
[2]),
8154 byte_swap_32 (digest_buf
[3]),
8155 byte_swap_32 (digest_buf
[4]),
8156 byte_swap_32 (digest_buf
[5]),
8157 byte_swap_32 (digest_buf
[6]),
8158 byte_swap_32 (digest_buf
[7])
8161 else if (hash_mode
== 12900)
8163 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",
8172 byte_swap_32 (digest_buf
[0]),
8173 byte_swap_32 (digest_buf
[1]),
8174 byte_swap_32 (digest_buf
[2]),
8175 byte_swap_32 (digest_buf
[3]),
8176 byte_swap_32 (digest_buf
[4]),
8177 byte_swap_32 (digest_buf
[5]),
8178 byte_swap_32 (digest_buf
[6]),
8179 byte_swap_32 (digest_buf
[7]),
8186 else if (hash_mode
== 13000)
8188 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8190 rar5_t
*rar5
= &rar5s
[salt_pos
];
8192 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8202 byte_swap_32 (digest_buf
[0]),
8203 byte_swap_32 (digest_buf
[1])
8208 if (hash_type
== HASH_TYPE_MD4
)
8210 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8216 else if (hash_type
== HASH_TYPE_MD5
)
8218 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8224 else if (hash_type
== HASH_TYPE_SHA1
)
8226 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8233 else if (hash_type
== HASH_TYPE_SHA256
)
8235 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8245 else if (hash_type
== HASH_TYPE_SHA384
)
8247 uint
*ptr
= digest_buf
;
8249 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8257 else if (hash_type
== HASH_TYPE_SHA512
)
8259 uint
*ptr
= digest_buf
;
8261 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8271 else if (hash_type
== HASH_TYPE_LM
)
8273 snprintf (out_buf
, len
-1, "%08x%08x",
8277 else if (hash_type
== HASH_TYPE_ORACLEH
)
8279 snprintf (out_buf
, len
-1, "%08X%08X",
8283 else if (hash_type
== HASH_TYPE_BCRYPT
)
8285 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8286 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8288 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8290 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8292 else if (hash_type
== HASH_TYPE_KECCAK
)
8294 uint
*ptr
= digest_buf
;
8296 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",
8324 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8326 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8328 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8335 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8337 digest_buf
[ 0] = digest_buf
[ 0];
8338 digest_buf
[ 1] = digest_buf
[ 1];
8339 digest_buf
[ 2] = digest_buf
[ 2];
8340 digest_buf
[ 3] = digest_buf
[ 3];
8341 digest_buf
[ 4] = digest_buf
[ 4];
8342 digest_buf
[ 5] = digest_buf
[ 5];
8343 digest_buf
[ 6] = digest_buf
[ 6];
8344 digest_buf
[ 7] = digest_buf
[ 7];
8345 digest_buf
[ 8] = digest_buf
[ 8];
8346 digest_buf
[ 9] = digest_buf
[ 9];
8347 digest_buf
[10] = digest_buf
[10];
8348 digest_buf
[11] = digest_buf
[11];
8349 digest_buf
[12] = digest_buf
[12];
8350 digest_buf
[13] = digest_buf
[13];
8351 digest_buf
[14] = digest_buf
[14];
8352 digest_buf
[15] = digest_buf
[15];
8354 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8372 else if (hash_type
== HASH_TYPE_GOST
)
8374 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8384 else if (hash_type
== HASH_TYPE_MYSQL
)
8386 snprintf (out_buf
, len
-1, "%08x%08x",
8390 else if (hash_type
== HASH_TYPE_LOTUS5
)
8392 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8398 else if (hash_type
== HASH_TYPE_LOTUS6
)
8400 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8401 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8402 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8403 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8405 char buf
[16] = { 0 };
8407 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8408 memcpy (buf
+ 5, digest_buf
, 9);
8412 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8414 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8417 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8419 else if (hash_type
== HASH_TYPE_LOTUS8
)
8421 char buf
[52] = { 0 };
8425 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8431 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8435 buf
[26] = salt
.salt_buf_pc
[0];
8436 buf
[27] = salt
.salt_buf_pc
[1];
8440 memcpy (buf
+ 28, digest_buf
, 8);
8442 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8446 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8448 else if (hash_type
== HASH_TYPE_CRC32
)
8450 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8454 if (salt_type
== SALT_TYPE_INTERN
)
8456 size_t pos
= strlen (out_buf
);
8458 out_buf
[pos
] = data
.separator
;
8460 char *ptr
= (char *) salt
.salt_buf
;
8462 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8464 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8468 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8470 memset (hccap
, 0, sizeof (hccap_t
));
8472 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8474 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8476 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8477 wpa_t
*wpa
= &wpas
[salt_pos
];
8479 hccap
->keyver
= wpa
->keyver
;
8481 hccap
->eapol_size
= wpa
->eapol_size
;
8483 if (wpa
->keyver
!= 1)
8485 uint eapol_tmp
[64] = { 0 };
8487 for (uint i
= 0; i
< 64; i
++)
8489 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8492 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8496 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8499 uint pke_tmp
[25] = { 0 };
8501 for (int i
= 5; i
< 25; i
++)
8503 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8506 char *pke_ptr
= (char *) pke_tmp
;
8508 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8509 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8510 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8511 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8513 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8515 uint dgst_size
= data
.dgst_size
;
8517 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8519 if (wpa
->keyver
!= 1)
8521 uint digest_tmp
[4] = { 0 };
8523 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8524 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8525 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8526 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8528 memcpy (hccap
->keymic
, digest_tmp
, 16);
8532 memcpy (hccap
->keymic
, digest_ptr
, 16);
8536 void SuspendThreads ()
8538 if (data
.devices_status
== STATUS_RUNNING
)
8540 hc_timer_set (&data
.timer_paused
);
8542 data
.devices_status
= STATUS_PAUSED
;
8544 log_info ("Paused");
8548 void ResumeThreads ()
8550 if (data
.devices_status
== STATUS_PAUSED
)
8554 hc_timer_get (data
.timer_paused
, ms_paused
);
8556 data
.ms_paused
+= ms_paused
;
8558 data
.devices_status
= STATUS_RUNNING
;
8560 log_info ("Resumed");
8566 if (data
.devices_status
!= STATUS_RUNNING
) return;
8568 data
.devices_status
= STATUS_BYPASS
;
8570 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8573 void stop_at_checkpoint ()
8575 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8577 if (data
.devices_status
!= STATUS_RUNNING
) return;
8580 // this feature only makes sense if --restore-disable was not specified
8582 if (data
.restore_disable
== 1)
8584 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8589 // check if monitoring of Restore Point updates should be enabled or disabled
8591 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8593 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8595 // save the current restore point value
8597 data
.checkpoint_cur_words
= get_lowest_words_done ();
8599 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8603 data
.devices_status
= STATUS_RUNNING
;
8605 // reset the global value for checkpoint checks
8607 data
.checkpoint_cur_words
= 0;
8609 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8615 if (data
.devices_status
== STATUS_INIT
) return;
8616 if (data
.devices_status
== STATUS_STARTING
) return;
8618 data
.devices_status
= STATUS_ABORTED
;
8623 if (data
.devices_status
== STATUS_INIT
) return;
8624 if (data
.devices_status
== STATUS_STARTING
) return;
8626 data
.devices_status
= STATUS_QUIT
;
8629 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8631 FILE *fp
= fopen (kernel_file
, "rb");
8637 memset (&st
, 0, sizeof (st
));
8639 stat (kernel_file
, &st
);
8641 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8643 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8645 if (num_read
!= (size_t) st
.st_size
)
8647 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8654 buf
[st
.st_size
] = 0;
8656 for (int i
= 0; i
< num_devices
; i
++)
8658 kernel_lengths
[i
] = (size_t) st
.st_size
;
8660 kernel_sources
[i
] = buf
;
8665 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8673 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8675 FILE *fp
= fopen (dst
, "wb");
8677 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8687 restore_data_t
*init_restore (int argc
, char **argv
)
8689 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8691 if (data
.restore_disable
== 0)
8693 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8697 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8701 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8710 char pidbin
[BUFSIZ
] = { 0 };
8712 int pidbin_len
= -1;
8715 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8717 FILE *fd
= fopen (pidbin
, "rb");
8721 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8723 pidbin
[pidbin_len
] = 0;
8727 char *argv0_r
= strrchr (argv
[0], '/');
8729 char *pidbin_r
= strrchr (pidbin
, '/');
8731 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8733 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8735 if (strcmp (argv0_r
, pidbin_r
) == 0)
8737 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8744 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8746 char pidbin2
[BUFSIZ
] = { 0 };
8748 int pidbin2_len
= -1;
8750 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8751 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8753 pidbin
[pidbin_len
] = 0;
8754 pidbin2
[pidbin2_len
] = 0;
8758 if (strcmp (pidbin
, pidbin2
) == 0)
8760 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8768 if (rd
->version_bin
< RESTORE_MIN
)
8770 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8777 memset (rd
, 0, sizeof (restore_data_t
));
8779 rd
->version_bin
= VERSION_BIN
;
8782 rd
->pid
= getpid ();
8784 rd
->pid
= GetCurrentProcessId ();
8787 if (getcwd (rd
->cwd
, 255) == NULL
)
8800 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8802 FILE *fp
= fopen (eff_restore_file
, "rb");
8806 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8811 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8813 log_error ("ERROR: cannot read %s", eff_restore_file
);
8818 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8820 for (uint i
= 0; i
< rd
->argc
; i
++)
8822 char buf
[BUFSIZ
] = { 0 };
8824 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8826 log_error ("ERROR: cannot read %s", eff_restore_file
);
8831 size_t len
= strlen (buf
);
8833 if (len
) buf
[len
- 1] = 0;
8835 rd
->argv
[i
] = mystrdup (buf
);
8840 char new_cwd
[1024] = { 0 };
8842 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8846 log_error ("Restore file is corrupted");
8849 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8851 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8853 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8858 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8861 if (chdir (rd
->cwd
))
8863 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8869 u64
get_lowest_words_done ()
8873 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8875 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8877 if (device_param
->skipped
) continue;
8879 const u64 words_done
= device_param
->words_done
;
8881 if (words_done
< words_cur
) words_cur
= words_done
;
8884 // It's possible that a device's workload isn't finished right after a restore-case.
8885 // In that case, this function would return 0 and overwrite the real restore point
8886 // There's also data.words_cur which is set to rd->words_cur but it changes while
8887 // the attack is running therefore we should stick to rd->words_cur.
8888 // Note that -s influences rd->words_cur we should keep a close look on that.
8890 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8895 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8897 u64 words_cur
= get_lowest_words_done ();
8899 rd
->words_cur
= words_cur
;
8901 FILE *fp
= fopen (new_restore_file
, "wb");
8905 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8910 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8912 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8917 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8919 for (uint i
= 0; i
< rd
->argc
; i
++)
8921 fprintf (fp
, "%s", rd
->argv
[i
]);
8927 fsync (fileno (fp
));
8932 void cycle_restore ()
8934 const char *eff_restore_file
= data
.eff_restore_file
;
8935 const char *new_restore_file
= data
.new_restore_file
;
8937 restore_data_t
*rd
= data
.rd
;
8939 write_restore (new_restore_file
, rd
);
8943 memset (&st
, 0, sizeof(st
));
8945 if (stat (eff_restore_file
, &st
) == 0)
8947 if (unlink (eff_restore_file
))
8949 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8953 if (rename (new_restore_file
, eff_restore_file
))
8955 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8959 void check_checkpoint ()
8961 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8963 u64 words_cur
= get_lowest_words_done ();
8965 if (words_cur
!= data
.checkpoint_cur_words
)
8975 uint
set_kernel_accel (uint hash_mode
)
8979 case 0: return GET_ACCEL (0);
8980 case 10: return GET_ACCEL (10);
8981 case 11: return GET_ACCEL (11);
8982 case 12: return GET_ACCEL (12);
8983 case 20: return GET_ACCEL (20);
8984 case 21: return GET_ACCEL (21);
8985 case 22: return GET_ACCEL (22);
8986 case 23: return GET_ACCEL (23);
8987 case 30: return GET_ACCEL (30);
8988 case 40: return GET_ACCEL (40);
8989 case 50: return GET_ACCEL (50);
8990 case 60: return GET_ACCEL (60);
8991 case 100: return GET_ACCEL (100);
8992 case 101: return GET_ACCEL (101);
8993 case 110: return GET_ACCEL (110);
8994 case 111: return GET_ACCEL (111);
8995 case 112: return GET_ACCEL (112);
8996 case 120: return GET_ACCEL (120);
8997 case 121: return GET_ACCEL (121);
8998 case 122: return GET_ACCEL (122);
8999 case 124: return GET_ACCEL (124);
9000 case 130: return GET_ACCEL (130);
9001 case 131: return GET_ACCEL (131);
9002 case 132: return GET_ACCEL (132);
9003 case 133: return GET_ACCEL (133);
9004 case 140: return GET_ACCEL (140);
9005 case 141: return GET_ACCEL (141);
9006 case 150: return GET_ACCEL (150);
9007 case 160: return GET_ACCEL (160);
9008 case 190: return GET_ACCEL (190);
9009 case 200: return GET_ACCEL (200);
9010 case 300: return GET_ACCEL (300);
9011 case 400: return GET_ACCEL (400);
9012 case 500: return GET_ACCEL (500);
9013 case 501: return GET_ACCEL (501);
9014 case 900: return GET_ACCEL (900);
9015 case 910: return GET_ACCEL (910);
9016 case 1000: return GET_ACCEL (1000);
9017 case 1100: return GET_ACCEL (1100);
9018 case 1400: return GET_ACCEL (1400);
9019 case 1410: return GET_ACCEL (1410);
9020 case 1420: return GET_ACCEL (1420);
9021 case 1421: return GET_ACCEL (1421);
9022 case 1430: return GET_ACCEL (1430);
9023 case 1440: return GET_ACCEL (1440);
9024 case 1441: return GET_ACCEL (1441);
9025 case 1450: return GET_ACCEL (1450);
9026 case 1460: return GET_ACCEL (1460);
9027 case 1500: return GET_ACCEL (1500);
9028 case 1600: return GET_ACCEL (1600);
9029 case 1700: return GET_ACCEL (1700);
9030 case 1710: return GET_ACCEL (1710);
9031 case 1711: return GET_ACCEL (1711);
9032 case 1720: return GET_ACCEL (1720);
9033 case 1722: return GET_ACCEL (1722);
9034 case 1730: return GET_ACCEL (1730);
9035 case 1731: return GET_ACCEL (1731);
9036 case 1740: return GET_ACCEL (1740);
9037 case 1750: return GET_ACCEL (1750);
9038 case 1760: return GET_ACCEL (1760);
9039 case 1800: return GET_ACCEL (1800);
9040 case 2100: return GET_ACCEL (2100);
9041 case 2400: return GET_ACCEL (2400);
9042 case 2410: return GET_ACCEL (2410);
9043 case 2500: return GET_ACCEL (2500);
9044 case 2600: return GET_ACCEL (2600);
9045 case 2611: return GET_ACCEL (2611);
9046 case 2612: return GET_ACCEL (2612);
9047 case 2711: return GET_ACCEL (2711);
9048 case 2811: return GET_ACCEL (2811);
9049 case 3000: return GET_ACCEL (3000);
9050 case 3100: return GET_ACCEL (3100);
9051 case 3200: return GET_ACCEL (3200);
9052 case 3710: return GET_ACCEL (3710);
9053 case 3711: return GET_ACCEL (3711);
9054 case 3800: return GET_ACCEL (3800);
9055 case 4300: return GET_ACCEL (4300);
9056 case 4400: return GET_ACCEL (4400);
9057 case 4500: return GET_ACCEL (4500);
9058 case 4700: return GET_ACCEL (4700);
9059 case 4800: return GET_ACCEL (4800);
9060 case 4900: return GET_ACCEL (4900);
9061 case 5000: return GET_ACCEL (5000);
9062 case 5100: return GET_ACCEL (5100);
9063 case 5200: return GET_ACCEL (5200);
9064 case 5300: return GET_ACCEL (5300);
9065 case 5400: return GET_ACCEL (5400);
9066 case 5500: return GET_ACCEL (5500);
9067 case 5600: return GET_ACCEL (5600);
9068 case 5700: return GET_ACCEL (5700);
9069 case 5800: return GET_ACCEL (5800);
9070 case 6000: return GET_ACCEL (6000);
9071 case 6100: return GET_ACCEL (6100);
9072 case 6211: return GET_ACCEL (6211);
9073 case 6212: return GET_ACCEL (6212);
9074 case 6213: return GET_ACCEL (6213);
9075 case 6221: return GET_ACCEL (6221);
9076 case 6222: return GET_ACCEL (6222);
9077 case 6223: return GET_ACCEL (6223);
9078 case 6231: return GET_ACCEL (6231);
9079 case 6232: return GET_ACCEL (6232);
9080 case 6233: return GET_ACCEL (6233);
9081 case 6241: return GET_ACCEL (6241);
9082 case 6242: return GET_ACCEL (6242);
9083 case 6243: return GET_ACCEL (6243);
9084 case 6300: return GET_ACCEL (6300);
9085 case 6400: return GET_ACCEL (6400);
9086 case 6500: return GET_ACCEL (6500);
9087 case 6600: return GET_ACCEL (6600);
9088 case 6700: return GET_ACCEL (6700);
9089 case 6800: return GET_ACCEL (6800);
9090 case 6900: return GET_ACCEL (6900);
9091 case 7100: return GET_ACCEL (7100);
9092 case 7200: return GET_ACCEL (7200);
9093 case 7300: return GET_ACCEL (7300);
9094 case 7400: return GET_ACCEL (7400);
9095 case 7500: return GET_ACCEL (7500);
9096 case 7600: return GET_ACCEL (7600);
9097 case 7700: return GET_ACCEL (7700);
9098 case 7800: return GET_ACCEL (7800);
9099 case 7900: return GET_ACCEL (7900);
9100 case 8000: return GET_ACCEL (8000);
9101 case 8100: return GET_ACCEL (8100);
9102 case 8200: return GET_ACCEL (8200);
9103 case 8300: return GET_ACCEL (8300);
9104 case 8400: return GET_ACCEL (8400);
9105 case 8500: return GET_ACCEL (8500);
9106 case 8600: return GET_ACCEL (8600);
9107 case 8700: return GET_ACCEL (8700);
9108 case 8800: return GET_ACCEL (8800);
9109 case 8900: return GET_ACCEL (8900);
9110 case 9000: return GET_ACCEL (9000);
9111 case 9100: return GET_ACCEL (9100);
9112 case 9200: return GET_ACCEL (9200);
9113 case 9300: return GET_ACCEL (9300);
9114 case 9400: return GET_ACCEL (9400);
9115 case 9500: return GET_ACCEL (9500);
9116 case 9600: return GET_ACCEL (9600);
9117 case 9700: return GET_ACCEL (9700);
9118 case 9710: return GET_ACCEL (9710);
9119 case 9720: return GET_ACCEL (9720);
9120 case 9800: return GET_ACCEL (9800);
9121 case 9810: return GET_ACCEL (9810);
9122 case 9820: return GET_ACCEL (9820);
9123 case 9900: return GET_ACCEL (9900);
9124 case 10000: return GET_ACCEL (10000);
9125 case 10100: return GET_ACCEL (10100);
9126 case 10200: return GET_ACCEL (10200);
9127 case 10300: return GET_ACCEL (10300);
9128 case 10400: return GET_ACCEL (10400);
9129 case 10410: return GET_ACCEL (10410);
9130 case 10420: return GET_ACCEL (10420);
9131 case 10500: return GET_ACCEL (10500);
9132 case 10600: return GET_ACCEL (10600);
9133 case 10700: return GET_ACCEL (10700);
9134 case 10800: return GET_ACCEL (10800);
9135 case 10900: return GET_ACCEL (10900);
9136 case 11000: return GET_ACCEL (11000);
9137 case 11100: return GET_ACCEL (11100);
9138 case 11200: return GET_ACCEL (11200);
9139 case 11300: return GET_ACCEL (11300);
9140 case 11400: return GET_ACCEL (11400);
9141 case 11500: return GET_ACCEL (11500);
9142 case 11600: return GET_ACCEL (11600);
9143 case 11700: return GET_ACCEL (11700);
9144 case 11800: return GET_ACCEL (11800);
9145 case 11900: return GET_ACCEL (11900);
9146 case 12000: return GET_ACCEL (12000);
9147 case 12100: return GET_ACCEL (12100);
9148 case 12200: return GET_ACCEL (12200);
9149 case 12300: return GET_ACCEL (12300);
9150 case 12400: return GET_ACCEL (12400);
9151 case 12500: return GET_ACCEL (12500);
9152 case 12600: return GET_ACCEL (12600);
9153 case 12700: return GET_ACCEL (12700);
9154 case 12800: return GET_ACCEL (12800);
9155 case 12900: return GET_ACCEL (12900);
9156 case 13000: return GET_ACCEL (13000);
9162 uint
set_kernel_loops (uint hash_mode
)
9166 case 0: return GET_LOOPS (0);
9167 case 10: return GET_LOOPS (10);
9168 case 11: return GET_LOOPS (11);
9169 case 12: return GET_LOOPS (12);
9170 case 20: return GET_LOOPS (20);
9171 case 21: return GET_LOOPS (21);
9172 case 22: return GET_LOOPS (22);
9173 case 23: return GET_LOOPS (23);
9174 case 30: return GET_LOOPS (30);
9175 case 40: return GET_LOOPS (40);
9176 case 50: return GET_LOOPS (50);
9177 case 60: return GET_LOOPS (60);
9178 case 100: return GET_LOOPS (100);
9179 case 101: return GET_LOOPS (101);
9180 case 110: return GET_LOOPS (110);
9181 case 111: return GET_LOOPS (111);
9182 case 112: return GET_LOOPS (112);
9183 case 120: return GET_LOOPS (120);
9184 case 121: return GET_LOOPS (121);
9185 case 122: return GET_LOOPS (122);
9186 case 124: return GET_LOOPS (124);
9187 case 130: return GET_LOOPS (130);
9188 case 131: return GET_LOOPS (131);
9189 case 132: return GET_LOOPS (132);
9190 case 133: return GET_LOOPS (133);
9191 case 140: return GET_LOOPS (140);
9192 case 141: return GET_LOOPS (141);
9193 case 150: return GET_LOOPS (150);
9194 case 160: return GET_LOOPS (160);
9195 case 190: return GET_LOOPS (190);
9196 case 200: return GET_LOOPS (200);
9197 case 300: return GET_LOOPS (300);
9198 case 400: return GET_LOOPS (400);
9199 case 500: return GET_LOOPS (500);
9200 case 501: return GET_LOOPS (501);
9201 case 900: return GET_LOOPS (900);
9202 case 910: return GET_LOOPS (910);
9203 case 1000: return GET_LOOPS (1000);
9204 case 1100: return GET_LOOPS (1100);
9205 case 1400: return GET_LOOPS (1400);
9206 case 1410: return GET_LOOPS (1410);
9207 case 1420: return GET_LOOPS (1420);
9208 case 1421: return GET_LOOPS (1421);
9209 case 1430: return GET_LOOPS (1430);
9210 case 1440: return GET_LOOPS (1440);
9211 case 1441: return GET_LOOPS (1441);
9212 case 1450: return GET_LOOPS (1450);
9213 case 1460: return GET_LOOPS (1460);
9214 case 1500: return GET_LOOPS (1500);
9215 case 1600: return GET_LOOPS (1600);
9216 case 1700: return GET_LOOPS (1700);
9217 case 1710: return GET_LOOPS (1710);
9218 case 1711: return GET_LOOPS (1711);
9219 case 1720: return GET_LOOPS (1720);
9220 case 1722: return GET_LOOPS (1722);
9221 case 1730: return GET_LOOPS (1730);
9222 case 1731: return GET_LOOPS (1731);
9223 case 1740: return GET_LOOPS (1740);
9224 case 1750: return GET_LOOPS (1750);
9225 case 1760: return GET_LOOPS (1760);
9226 case 1800: return GET_LOOPS (1800);
9227 case 2100: return GET_LOOPS (2100);
9228 case 2400: return GET_LOOPS (2400);
9229 case 2410: return GET_LOOPS (2410);
9230 case 2500: return GET_LOOPS (2500);
9231 case 2600: return GET_LOOPS (2600);
9232 case 2611: return GET_LOOPS (2611);
9233 case 2612: return GET_LOOPS (2612);
9234 case 2711: return GET_LOOPS (2711);
9235 case 2811: return GET_LOOPS (2811);
9236 case 3000: return GET_LOOPS (3000);
9237 case 3100: return GET_LOOPS (3100);
9238 case 3200: return GET_LOOPS (3200);
9239 case 3710: return GET_LOOPS (3710);
9240 case 3711: return GET_LOOPS (3711);
9241 case 3800: return GET_LOOPS (3800);
9242 case 4300: return GET_LOOPS (4300);
9243 case 4400: return GET_LOOPS (4400);
9244 case 4500: return GET_LOOPS (4500);
9245 case 4700: return GET_LOOPS (4700);
9246 case 4800: return GET_LOOPS (4800);
9247 case 4900: return GET_LOOPS (4900);
9248 case 5000: return GET_LOOPS (5000);
9249 case 5100: return GET_LOOPS (5100);
9250 case 5200: return GET_LOOPS (5200);
9251 case 5300: return GET_LOOPS (5300);
9252 case 5400: return GET_LOOPS (5400);
9253 case 5500: return GET_LOOPS (5500);
9254 case 5600: return GET_LOOPS (5600);
9255 case 5700: return GET_LOOPS (5700);
9256 case 5800: return GET_LOOPS (5800);
9257 case 6000: return GET_LOOPS (6000);
9258 case 6100: return GET_LOOPS (6100);
9259 case 6211: return GET_LOOPS (6211);
9260 case 6212: return GET_LOOPS (6212);
9261 case 6213: return GET_LOOPS (6213);
9262 case 6221: return GET_LOOPS (6221);
9263 case 6222: return GET_LOOPS (6222);
9264 case 6223: return GET_LOOPS (6223);
9265 case 6231: return GET_LOOPS (6231);
9266 case 6232: return GET_LOOPS (6232);
9267 case 6233: return GET_LOOPS (6233);
9268 case 6241: return GET_LOOPS (6241);
9269 case 6242: return GET_LOOPS (6242);
9270 case 6243: return GET_LOOPS (6243);
9271 case 6300: return GET_LOOPS (6300);
9272 case 6400: return GET_LOOPS (6400);
9273 case 6500: return GET_LOOPS (6500);
9274 case 6600: return GET_LOOPS (6600);
9275 case 6700: return GET_LOOPS (6700);
9276 case 6800: return GET_LOOPS (6800);
9277 case 6900: return GET_LOOPS (6900);
9278 case 7100: return GET_LOOPS (7100);
9279 case 7200: return GET_LOOPS (7200);
9280 case 7300: return GET_LOOPS (7300);
9281 case 7400: return GET_LOOPS (7400);
9282 case 7500: return GET_LOOPS (7500);
9283 case 7600: return GET_LOOPS (7600);
9284 case 7700: return GET_LOOPS (7700);
9285 case 7800: return GET_LOOPS (7800);
9286 case 7900: return GET_LOOPS (7900);
9287 case 8000: return GET_LOOPS (8000);
9288 case 8100: return GET_LOOPS (8100);
9289 case 8200: return GET_LOOPS (8200);
9290 case 8300: return GET_LOOPS (8300);
9291 case 8400: return GET_LOOPS (8400);
9292 case 8500: return GET_LOOPS (8500);
9293 case 8600: return GET_LOOPS (8600);
9294 case 8700: return GET_LOOPS (8700);
9295 case 8800: return GET_LOOPS (8800);
9296 case 8900: return GET_LOOPS (8900);
9297 case 9000: return GET_LOOPS (9000);
9298 case 9100: return GET_LOOPS (9100);
9299 case 9200: return GET_LOOPS (9200);
9300 case 9300: return GET_LOOPS (9300);
9301 case 9400: return GET_LOOPS (9400);
9302 case 9500: return GET_LOOPS (9500);
9303 case 9600: return GET_LOOPS (9600);
9304 case 9700: return GET_LOOPS (9700);
9305 case 9710: return GET_LOOPS (9710);
9306 case 9720: return GET_LOOPS (9720);
9307 case 9800: return GET_LOOPS (9800);
9308 case 9810: return GET_LOOPS (9810);
9309 case 9820: return GET_LOOPS (9820);
9310 case 9900: return GET_LOOPS (9900);
9311 case 10000: return GET_LOOPS (10000);
9312 case 10100: return GET_LOOPS (10100);
9313 case 10200: return GET_LOOPS (10200);
9314 case 10300: return GET_LOOPS (10300);
9315 case 10400: return GET_LOOPS (10400);
9316 case 10410: return GET_LOOPS (10410);
9317 case 10420: return GET_LOOPS (10420);
9318 case 10500: return GET_LOOPS (10500);
9319 case 10600: return GET_LOOPS (10600);
9320 case 10700: return GET_LOOPS (10700);
9321 case 10800: return GET_LOOPS (10800);
9322 case 10900: return GET_LOOPS (10900);
9323 case 11000: return GET_LOOPS (11000);
9324 case 11100: return GET_LOOPS (11100);
9325 case 11200: return GET_LOOPS (11200);
9326 case 11300: return GET_LOOPS (11300);
9327 case 11400: return GET_LOOPS (11400);
9328 case 11500: return GET_LOOPS (11500);
9329 case 11600: return GET_LOOPS (11600);
9330 case 11700: return GET_LOOPS (11700);
9331 case 11800: return GET_LOOPS (11800);
9332 case 11900: return GET_LOOPS (11900);
9333 case 12000: return GET_LOOPS (12000);
9334 case 12100: return GET_LOOPS (12100);
9335 case 12200: return GET_LOOPS (12200);
9336 case 12300: return GET_LOOPS (12300);
9337 case 12400: return GET_LOOPS (12400);
9338 case 12500: return GET_LOOPS (12500);
9339 case 12600: return GET_LOOPS (12600);
9340 case 12700: return GET_LOOPS (12700);
9341 case 12800: return GET_LOOPS (12800);
9342 case 12900: return GET_LOOPS (12900);
9343 case 13000: return GET_LOOPS (13000);
9353 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9355 u8 tmp
[256] = { 0 };
9357 if (salt_len
> sizeof (tmp
))
9362 memcpy (tmp
, in
, salt_len
);
9364 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9366 if ((salt_len
% 2) == 0)
9368 u32 new_salt_len
= salt_len
/ 2;
9370 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9375 tmp
[i
] = hex_convert (p1
) << 0;
9376 tmp
[i
] |= hex_convert (p0
) << 4;
9379 salt_len
= new_salt_len
;
9386 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9388 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9391 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9393 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9397 u32
*tmp_uint
= (u32
*) tmp
;
9399 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9400 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9401 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9402 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9403 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9404 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9405 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9406 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9407 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9408 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9410 salt_len
= salt_len
* 2;
9418 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9420 lowercase (tmp
, salt_len
);
9423 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9425 uppercase (tmp
, salt_len
);
9430 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9435 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9440 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9442 u32
*tmp_uint
= (uint
*) tmp
;
9448 for (u32 i
= 0; i
< max
; i
++)
9450 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9453 // Important: we may need to increase the length of memcpy since
9454 // we don't want to "loose" some swapped bytes (could happen if
9455 // they do not perfectly fit in the 4-byte blocks)
9456 // Memcpy does always copy the bytes in the BE order, but since
9457 // we swapped them, some important bytes could be in positions
9458 // we normally skip with the original len
9460 if (len
% 4) len
+= 4 - (len
% 4);
9463 memcpy (out
, tmp
, len
);
9468 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9470 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9472 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9474 u32
*digest
= (u32
*) hash_buf
->digest
;
9476 salt_t
*salt
= hash_buf
->salt
;
9478 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9480 char *iter_pos
= input_buf
+ 4;
9482 salt
->salt_iter
= 1 << atoi (iter_pos
);
9484 char *salt_pos
= strchr (iter_pos
, '$');
9486 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9492 salt
->salt_len
= salt_len
;
9494 u8 tmp_buf
[100] = { 0 };
9496 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9498 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9500 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9502 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9503 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9504 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9505 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9507 char *hash_pos
= salt_pos
+ 22;
9509 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9511 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9513 memcpy (digest
, tmp_buf
, 24);
9515 digest
[0] = byte_swap_32 (digest
[0]);
9516 digest
[1] = byte_swap_32 (digest
[1]);
9517 digest
[2] = byte_swap_32 (digest
[2]);
9518 digest
[3] = byte_swap_32 (digest
[3]);
9519 digest
[4] = byte_swap_32 (digest
[4]);
9520 digest
[5] = byte_swap_32 (digest
[5]);
9522 digest
[5] &= ~0xff; // its just 23 not 24 !
9527 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9529 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9531 u32
*digest
= (u32
*) hash_buf
->digest
;
9533 u8 tmp_buf
[100] = { 0 };
9535 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9537 memcpy (digest
, tmp_buf
, 32);
9539 digest
[0] = byte_swap_32 (digest
[0]);
9540 digest
[1] = byte_swap_32 (digest
[1]);
9541 digest
[2] = byte_swap_32 (digest
[2]);
9542 digest
[3] = byte_swap_32 (digest
[3]);
9543 digest
[4] = byte_swap_32 (digest
[4]);
9544 digest
[5] = byte_swap_32 (digest
[5]);
9545 digest
[6] = byte_swap_32 (digest
[6]);
9546 digest
[7] = byte_swap_32 (digest
[7]);
9548 digest
[0] -= SHA256M_A
;
9549 digest
[1] -= SHA256M_B
;
9550 digest
[2] -= SHA256M_C
;
9551 digest
[3] -= SHA256M_D
;
9552 digest
[4] -= SHA256M_E
;
9553 digest
[5] -= SHA256M_F
;
9554 digest
[6] -= SHA256M_G
;
9555 digest
[7] -= SHA256M_H
;
9560 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9562 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9564 u32
*digest
= (u32
*) hash_buf
->digest
;
9566 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9567 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9569 digest
[0] = byte_swap_32 (digest
[0]);
9570 digest
[1] = byte_swap_32 (digest
[1]);
9574 IP (digest
[0], digest
[1], tt
);
9576 digest
[0] = digest
[0];
9577 digest
[1] = digest
[1];
9584 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9586 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9588 u32
*digest
= (u32
*) hash_buf
->digest
;
9590 salt_t
*salt
= hash_buf
->salt
;
9592 char *hash_pos
= input_buf
+ 8;
9594 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9595 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9596 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9597 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9598 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9600 digest
[0] -= SHA1M_A
;
9601 digest
[1] -= SHA1M_B
;
9602 digest
[2] -= SHA1M_C
;
9603 digest
[3] -= SHA1M_D
;
9604 digest
[4] -= SHA1M_E
;
9608 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9610 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9612 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9614 salt
->salt_len
= salt_len
;
9619 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9621 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9623 u64
*digest
= (u64
*) hash_buf
->digest
;
9625 salt_t
*salt
= hash_buf
->salt
;
9627 char *hash_pos
= input_buf
+ 8;
9629 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9630 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9631 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9632 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9633 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9634 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9635 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9636 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9638 digest
[0] -= SHA512M_A
;
9639 digest
[1] -= SHA512M_B
;
9640 digest
[2] -= SHA512M_C
;
9641 digest
[3] -= SHA512M_D
;
9642 digest
[4] -= SHA512M_E
;
9643 digest
[5] -= SHA512M_F
;
9644 digest
[6] -= SHA512M_G
;
9645 digest
[7] -= SHA512M_H
;
9649 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9651 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9653 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9655 salt
->salt_len
= salt_len
;
9660 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9662 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9664 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9668 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9671 u32
*digest
= (u32
*) hash_buf
->digest
;
9673 salt_t
*salt
= hash_buf
->salt
;
9675 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9676 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9677 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9678 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9680 digest
[0] = byte_swap_32 (digest
[0]);
9681 digest
[1] = byte_swap_32 (digest
[1]);
9682 digest
[2] = byte_swap_32 (digest
[2]);
9683 digest
[3] = byte_swap_32 (digest
[3]);
9685 digest
[0] -= MD5M_A
;
9686 digest
[1] -= MD5M_B
;
9687 digest
[2] -= MD5M_C
;
9688 digest
[3] -= MD5M_D
;
9690 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9692 uint salt_len
= input_len
- 32 - 1;
9694 char *salt_buf
= input_buf
+ 32 + 1;
9696 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9698 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9700 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9702 salt
->salt_len
= salt_len
;
9707 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9709 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9711 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9715 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9720 char clean_input_buf
[32] = { 0 };
9722 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9723 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9725 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9729 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9735 clean_input_buf
[k
] = input_buf
[i
];
9743 u32
*digest
= (u32
*) hash_buf
->digest
;
9745 salt_t
*salt
= hash_buf
->salt
;
9747 u32 a
, b
, c
, d
, e
, f
;
9749 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9750 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9751 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9752 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9753 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9754 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9756 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9757 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9759 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9760 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9761 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9762 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9763 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9764 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9766 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9767 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9769 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9770 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9771 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9772 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9773 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9774 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9776 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9777 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9779 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9780 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9781 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9782 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9783 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9784 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9786 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9787 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9789 digest
[0] = byte_swap_32 (digest
[0]);
9790 digest
[1] = byte_swap_32 (digest
[1]);
9791 digest
[2] = byte_swap_32 (digest
[2]);
9792 digest
[3] = byte_swap_32 (digest
[3]);
9794 digest
[0] -= MD5M_A
;
9795 digest
[1] -= MD5M_B
;
9796 digest
[2] -= MD5M_C
;
9797 digest
[3] -= MD5M_D
;
9799 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9801 uint salt_len
= input_len
- 30 - 1;
9803 char *salt_buf
= input_buf
+ 30 + 1;
9805 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9807 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9809 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9810 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9812 salt
->salt_len
= salt_len
;
9814 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9816 salt
->salt_len
+= 22;
9821 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9823 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9825 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9829 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9832 u32
*digest
= (u32
*) hash_buf
->digest
;
9834 salt_t
*salt
= hash_buf
->salt
;
9836 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9837 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9838 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9839 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9840 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9842 digest
[0] -= SHA1M_A
;
9843 digest
[1] -= SHA1M_B
;
9844 digest
[2] -= SHA1M_C
;
9845 digest
[3] -= SHA1M_D
;
9846 digest
[4] -= SHA1M_E
;
9848 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9850 uint salt_len
= input_len
- 40 - 1;
9852 char *salt_buf
= input_buf
+ 40 + 1;
9854 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9856 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9858 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9860 salt
->salt_len
= salt_len
;
9865 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9867 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9869 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9873 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9876 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9878 char *iter_pos
= input_buf
+ 6;
9880 salt_t
*salt
= hash_buf
->salt
;
9882 uint iter
= atoi (iter_pos
);
9889 salt
->salt_iter
= iter
- 1;
9891 char *salt_pos
= strchr (iter_pos
, '#');
9893 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9897 char *digest_pos
= strchr (salt_pos
, '#');
9899 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9903 uint salt_len
= digest_pos
- salt_pos
- 1;
9905 u32
*digest
= (u32
*) hash_buf
->digest
;
9907 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9908 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9909 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9910 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9912 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9914 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9916 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9918 salt
->salt_len
= salt_len
;
9923 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9925 u32
*digest
= (u32
*) hash_buf
->digest
;
9927 salt_t
*salt
= hash_buf
->salt
;
9929 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9933 memcpy (&in
, input_buf
, input_len
);
9935 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9937 memcpy (digest
, in
.keymic
, 16);
9940 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9941 The phrase "Pairwise key expansion"
9942 Access Point Address (referred to as Authenticator Address AA)
9943 Supplicant Address (referred to as Supplicant Address SA)
9944 Access Point Nonce (referred to as Authenticator Anonce)
9945 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9948 uint salt_len
= strlen (in
.essid
);
9950 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9952 salt
->salt_len
= salt_len
;
9954 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9956 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9958 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9960 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9962 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9963 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9967 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9968 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9971 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9973 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9974 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9978 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9979 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9982 for (int i
= 0; i
< 25; i
++)
9984 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9987 wpa
->keyver
= in
.keyver
;
9989 if (wpa
->keyver
> 255)
9991 log_info ("ATTENTION!");
9992 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9993 log_info (" This could be due to a recent aircrack-ng bug.");
9994 log_info (" The key version was automatically reset to a reasonable value.");
9997 wpa
->keyver
&= 0xff;
10000 wpa
->eapol_size
= in
.eapol_size
;
10002 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10004 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10006 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10008 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10010 if (wpa
->keyver
== 1)
10016 digest
[0] = byte_swap_32 (digest
[0]);
10017 digest
[1] = byte_swap_32 (digest
[1]);
10018 digest
[2] = byte_swap_32 (digest
[2]);
10019 digest
[3] = byte_swap_32 (digest
[3]);
10021 for (int i
= 0; i
< 64; i
++)
10023 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10027 salt
->salt_buf
[10] = digest
[1];
10028 salt
->salt_buf
[11] = digest
[2];
10030 return (PARSER_OK
);
10033 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10035 u32
*digest
= (u32
*) hash_buf
->digest
;
10037 salt_t
*salt
= hash_buf
->salt
;
10039 if (input_len
== 0)
10041 log_error ("Password Safe v2 container not specified");
10046 FILE *fp
= fopen (input_buf
, "rb");
10050 log_error ("%s: %s", input_buf
, strerror (errno
));
10057 memset (&buf
, 0, sizeof (psafe2_hdr
));
10059 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10063 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10065 salt
->salt_buf
[0] = buf
.random
[0];
10066 salt
->salt_buf
[1] = buf
.random
[1];
10068 salt
->salt_len
= 8;
10069 salt
->salt_iter
= 1000;
10071 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10072 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10073 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10074 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10075 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10077 return (PARSER_OK
);
10080 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10082 u32
*digest
= (u32
*) hash_buf
->digest
;
10084 salt_t
*salt
= hash_buf
->salt
;
10086 if (input_len
== 0)
10088 log_error (".psafe3 not specified");
10093 FILE *fp
= fopen (input_buf
, "rb");
10097 log_error ("%s: %s", input_buf
, strerror (errno
));
10104 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10108 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10110 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10112 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10114 salt
->salt_iter
= in
.iterations
+ 1;
10116 salt
->salt_buf
[0] = in
.salt_buf
[0];
10117 salt
->salt_buf
[1] = in
.salt_buf
[1];
10118 salt
->salt_buf
[2] = in
.salt_buf
[2];
10119 salt
->salt_buf
[3] = in
.salt_buf
[3];
10120 salt
->salt_buf
[4] = in
.salt_buf
[4];
10121 salt
->salt_buf
[5] = in
.salt_buf
[5];
10122 salt
->salt_buf
[6] = in
.salt_buf
[6];
10123 salt
->salt_buf
[7] = in
.salt_buf
[7];
10125 salt
->salt_len
= 32;
10127 digest
[0] = in
.hash_buf
[0];
10128 digest
[1] = in
.hash_buf
[1];
10129 digest
[2] = in
.hash_buf
[2];
10130 digest
[3] = in
.hash_buf
[3];
10131 digest
[4] = in
.hash_buf
[4];
10132 digest
[5] = in
.hash_buf
[5];
10133 digest
[6] = in
.hash_buf
[6];
10134 digest
[7] = in
.hash_buf
[7];
10136 digest
[0] = byte_swap_32 (digest
[0]);
10137 digest
[1] = byte_swap_32 (digest
[1]);
10138 digest
[2] = byte_swap_32 (digest
[2]);
10139 digest
[3] = byte_swap_32 (digest
[3]);
10140 digest
[4] = byte_swap_32 (digest
[4]);
10141 digest
[5] = byte_swap_32 (digest
[5]);
10142 digest
[6] = byte_swap_32 (digest
[6]);
10143 digest
[7] = byte_swap_32 (digest
[7]);
10145 return (PARSER_OK
);
10148 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10150 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10152 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10154 u32
*digest
= (u32
*) hash_buf
->digest
;
10156 salt_t
*salt
= hash_buf
->salt
;
10158 char *iter_pos
= input_buf
+ 3;
10160 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10162 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10164 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10166 salt
->salt_iter
= salt_iter
;
10168 char *salt_pos
= iter_pos
+ 1;
10172 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10174 salt
->salt_len
= salt_len
;
10176 char *hash_pos
= salt_pos
+ salt_len
;
10178 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10180 return (PARSER_OK
);
10183 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10185 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10187 u32
*digest
= (u32
*) hash_buf
->digest
;
10189 salt_t
*salt
= hash_buf
->salt
;
10191 char *salt_pos
= input_buf
+ 3;
10193 uint iterations_len
= 0;
10195 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10199 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10201 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10202 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10206 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10210 iterations_len
+= 8;
10214 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10217 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10219 char *hash_pos
= strchr (salt_pos
, '$');
10221 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10223 uint salt_len
= hash_pos
- salt_pos
;
10225 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10227 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10229 salt
->salt_len
= salt_len
;
10233 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10235 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10237 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10239 return (PARSER_OK
);
10242 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10244 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10246 u32
*digest
= (u32
*) hash_buf
->digest
;
10248 salt_t
*salt
= hash_buf
->salt
;
10250 char *salt_pos
= input_buf
+ 6;
10252 uint iterations_len
= 0;
10254 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10258 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10260 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10261 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10265 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10269 iterations_len
+= 8;
10273 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10276 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10278 char *hash_pos
= strchr (salt_pos
, '$');
10280 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10282 uint salt_len
= hash_pos
- salt_pos
;
10284 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10286 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10288 salt
->salt_len
= salt_len
;
10292 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10294 return (PARSER_OK
);
10297 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10299 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10301 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10303 u32
*digest
= (u32
*) hash_buf
->digest
;
10305 salt_t
*salt
= hash_buf
->salt
;
10307 char *salt_pos
= input_buf
+ 14;
10309 char *hash_pos
= strchr (salt_pos
, '*');
10311 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10315 uint salt_len
= hash_pos
- salt_pos
- 1;
10317 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10319 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10321 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10323 salt
->salt_len
= salt_len
;
10325 u8 tmp_buf
[100] = { 0 };
10327 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10329 memcpy (digest
, tmp_buf
, 20);
10331 digest
[0] = byte_swap_32 (digest
[0]);
10332 digest
[1] = byte_swap_32 (digest
[1]);
10333 digest
[2] = byte_swap_32 (digest
[2]);
10334 digest
[3] = byte_swap_32 (digest
[3]);
10335 digest
[4] = byte_swap_32 (digest
[4]);
10337 digest
[0] -= SHA1M_A
;
10338 digest
[1] -= SHA1M_B
;
10339 digest
[2] -= SHA1M_C
;
10340 digest
[3] -= SHA1M_D
;
10341 digest
[4] -= SHA1M_E
;
10343 return (PARSER_OK
);
10346 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10348 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10350 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10352 if (c12
& 3) return (PARSER_HASH_VALUE
);
10354 u32
*digest
= (u32
*) hash_buf
->digest
;
10356 salt_t
*salt
= hash_buf
->salt
;
10358 // for ascii_digest
10359 salt
->salt_sign
[0] = input_buf
[0];
10360 salt
->salt_sign
[1] = input_buf
[1];
10362 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10363 | itoa64_to_int (input_buf
[1]) << 6;
10365 salt
->salt_len
= 2;
10367 u8 tmp_buf
[100] = { 0 };
10369 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10371 memcpy (digest
, tmp_buf
, 8);
10375 IP (digest
[0], digest
[1], tt
);
10380 return (PARSER_OK
);
10383 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10385 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10387 u32
*digest
= (u32
*) hash_buf
->digest
;
10389 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10390 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10391 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10392 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10394 digest
[0] = byte_swap_32 (digest
[0]);
10395 digest
[1] = byte_swap_32 (digest
[1]);
10396 digest
[2] = byte_swap_32 (digest
[2]);
10397 digest
[3] = byte_swap_32 (digest
[3]);
10399 digest
[0] -= MD4M_A
;
10400 digest
[1] -= MD4M_B
;
10401 digest
[2] -= MD4M_C
;
10402 digest
[3] -= MD4M_D
;
10404 return (PARSER_OK
);
10407 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10409 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10411 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10415 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10418 u32
*digest
= (u32
*) hash_buf
->digest
;
10420 salt_t
*salt
= hash_buf
->salt
;
10422 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10423 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10424 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10425 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10427 digest
[0] = byte_swap_32 (digest
[0]);
10428 digest
[1] = byte_swap_32 (digest
[1]);
10429 digest
[2] = byte_swap_32 (digest
[2]);
10430 digest
[3] = byte_swap_32 (digest
[3]);
10432 digest
[0] -= MD4M_A
;
10433 digest
[1] -= MD4M_B
;
10434 digest
[2] -= MD4M_C
;
10435 digest
[3] -= MD4M_D
;
10437 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10439 uint salt_len
= input_len
- 32 - 1;
10441 char *salt_buf
= input_buf
+ 32 + 1;
10443 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10445 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10447 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10449 salt
->salt_len
= salt_len
;
10451 return (PARSER_OK
);
10454 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10456 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10458 u32
*digest
= (u32
*) hash_buf
->digest
;
10460 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10461 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10462 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10463 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10465 digest
[0] = byte_swap_32 (digest
[0]);
10466 digest
[1] = byte_swap_32 (digest
[1]);
10467 digest
[2] = byte_swap_32 (digest
[2]);
10468 digest
[3] = byte_swap_32 (digest
[3]);
10470 digest
[0] -= MD5M_A
;
10471 digest
[1] -= MD5M_B
;
10472 digest
[2] -= MD5M_C
;
10473 digest
[3] -= MD5M_D
;
10475 return (PARSER_OK
);
10478 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10480 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10482 u32
*digest
= (u32
*) hash_buf
->digest
;
10484 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10485 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10489 digest
[0] = byte_swap_32 (digest
[0]);
10490 digest
[1] = byte_swap_32 (digest
[1]);
10492 return (PARSER_OK
);
10495 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10497 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10499 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10503 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10506 u32
*digest
= (u32
*) hash_buf
->digest
;
10508 salt_t
*salt
= hash_buf
->salt
;
10510 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10511 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10512 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10513 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10515 digest
[0] = byte_swap_32 (digest
[0]);
10516 digest
[1] = byte_swap_32 (digest
[1]);
10517 digest
[2] = byte_swap_32 (digest
[2]);
10518 digest
[3] = byte_swap_32 (digest
[3]);
10520 digest
[0] -= MD5M_A
;
10521 digest
[1] -= MD5M_B
;
10522 digest
[2] -= MD5M_C
;
10523 digest
[3] -= MD5M_D
;
10525 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10527 uint salt_len
= input_len
- 32 - 1;
10529 char *salt_buf
= input_buf
+ 32 + 1;
10531 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10533 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10535 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10537 salt
->salt_len
= salt_len
;
10539 return (PARSER_OK
);
10542 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10544 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10546 u32
*digest
= (u32
*) hash_buf
->digest
;
10548 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10549 | itoa64_to_int (input_buf
[ 1]) << 6
10550 | itoa64_to_int (input_buf
[ 2]) << 12
10551 | itoa64_to_int (input_buf
[ 3]) << 18;
10552 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10553 | itoa64_to_int (input_buf
[ 5]) << 6
10554 | itoa64_to_int (input_buf
[ 6]) << 12
10555 | itoa64_to_int (input_buf
[ 7]) << 18;
10556 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10557 | itoa64_to_int (input_buf
[ 9]) << 6
10558 | itoa64_to_int (input_buf
[10]) << 12
10559 | itoa64_to_int (input_buf
[11]) << 18;
10560 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10561 | itoa64_to_int (input_buf
[13]) << 6
10562 | itoa64_to_int (input_buf
[14]) << 12
10563 | itoa64_to_int (input_buf
[15]) << 18;
10565 digest
[0] -= MD5M_A
;
10566 digest
[1] -= MD5M_B
;
10567 digest
[2] -= MD5M_C
;
10568 digest
[3] -= MD5M_D
;
10570 digest
[0] &= 0x00ffffff;
10571 digest
[1] &= 0x00ffffff;
10572 digest
[2] &= 0x00ffffff;
10573 digest
[3] &= 0x00ffffff;
10575 return (PARSER_OK
);
10578 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10580 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10582 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10586 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10589 u32
*digest
= (u32
*) hash_buf
->digest
;
10591 salt_t
*salt
= hash_buf
->salt
;
10593 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10594 | itoa64_to_int (input_buf
[ 1]) << 6
10595 | itoa64_to_int (input_buf
[ 2]) << 12
10596 | itoa64_to_int (input_buf
[ 3]) << 18;
10597 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10598 | itoa64_to_int (input_buf
[ 5]) << 6
10599 | itoa64_to_int (input_buf
[ 6]) << 12
10600 | itoa64_to_int (input_buf
[ 7]) << 18;
10601 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10602 | itoa64_to_int (input_buf
[ 9]) << 6
10603 | itoa64_to_int (input_buf
[10]) << 12
10604 | itoa64_to_int (input_buf
[11]) << 18;
10605 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10606 | itoa64_to_int (input_buf
[13]) << 6
10607 | itoa64_to_int (input_buf
[14]) << 12
10608 | itoa64_to_int (input_buf
[15]) << 18;
10610 digest
[0] -= MD5M_A
;
10611 digest
[1] -= MD5M_B
;
10612 digest
[2] -= MD5M_C
;
10613 digest
[3] -= MD5M_D
;
10615 digest
[0] &= 0x00ffffff;
10616 digest
[1] &= 0x00ffffff;
10617 digest
[2] &= 0x00ffffff;
10618 digest
[3] &= 0x00ffffff;
10620 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10622 uint salt_len
= input_len
- 16 - 1;
10624 char *salt_buf
= input_buf
+ 16 + 1;
10626 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10628 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10630 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10632 salt
->salt_len
= salt_len
;
10634 return (PARSER_OK
);
10637 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10639 key
[0] = (nthash
[0] >> 0);
10640 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10641 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10642 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10643 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10644 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10645 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10646 key
[7] = (nthash
[6] << 1);
10658 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10660 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10662 u32
*digest
= (u32
*) hash_buf
->digest
;
10664 salt_t
*salt
= hash_buf
->salt
;
10666 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10672 char *user_pos
= input_buf
;
10674 char *unused_pos
= strchr (user_pos
, ':');
10676 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10678 uint user_len
= unused_pos
- user_pos
;
10680 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10684 char *domain_pos
= strchr (unused_pos
, ':');
10686 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10688 uint unused_len
= domain_pos
- unused_pos
;
10690 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10694 char *srvchall_pos
= strchr (domain_pos
, ':');
10696 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10698 uint domain_len
= srvchall_pos
- domain_pos
;
10700 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10704 char *hash_pos
= strchr (srvchall_pos
, ':');
10706 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10708 uint srvchall_len
= hash_pos
- srvchall_pos
;
10710 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10714 char *clichall_pos
= strchr (hash_pos
, ':');
10716 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10718 uint hash_len
= clichall_pos
- hash_pos
;
10720 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10724 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10726 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10729 * store some data for later use
10732 netntlm
->user_len
= user_len
* 2;
10733 netntlm
->domain_len
= domain_len
* 2;
10734 netntlm
->srvchall_len
= srvchall_len
/ 2;
10735 netntlm
->clichall_len
= clichall_len
/ 2;
10737 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10738 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10741 * handle username and domainname
10744 for (uint i
= 0; i
< user_len
; i
++)
10746 *userdomain_ptr
++ = user_pos
[i
];
10747 *userdomain_ptr
++ = 0;
10750 for (uint i
= 0; i
< domain_len
; i
++)
10752 *userdomain_ptr
++ = domain_pos
[i
];
10753 *userdomain_ptr
++ = 0;
10757 * handle server challenge encoding
10760 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10762 const char p0
= srvchall_pos
[i
+ 0];
10763 const char p1
= srvchall_pos
[i
+ 1];
10765 *chall_ptr
++ = hex_convert (p1
) << 0
10766 | hex_convert (p0
) << 4;
10770 * handle client challenge encoding
10773 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10775 const char p0
= clichall_pos
[i
+ 0];
10776 const char p1
= clichall_pos
[i
+ 1];
10778 *chall_ptr
++ = hex_convert (p1
) << 0
10779 | hex_convert (p0
) << 4;
10786 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10788 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10790 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10792 salt
->salt_len
= salt_len
;
10794 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10795 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10796 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10797 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10799 digest
[0] = byte_swap_32 (digest
[0]);
10800 digest
[1] = byte_swap_32 (digest
[1]);
10801 digest
[2] = byte_swap_32 (digest
[2]);
10802 digest
[3] = byte_swap_32 (digest
[3]);
10804 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10806 uint digest_tmp
[2] = { 0 };
10808 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10809 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10811 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10812 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10814 /* special case 2: ESS */
10816 if (srvchall_len
== 48)
10818 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10820 uint w
[16] = { 0 };
10822 w
[ 0] = netntlm
->chall_buf
[6];
10823 w
[ 1] = netntlm
->chall_buf
[7];
10824 w
[ 2] = netntlm
->chall_buf
[0];
10825 w
[ 3] = netntlm
->chall_buf
[1];
10829 uint dgst
[4] = { 0 };
10838 salt
->salt_buf
[0] = dgst
[0];
10839 salt
->salt_buf
[1] = dgst
[1];
10843 /* precompute netntlmv1 exploit start */
10845 for (uint i
= 0; i
< 0x10000; i
++)
10847 uint key_md4
[2] = { i
, 0 };
10848 uint key_des
[2] = { 0, 0 };
10850 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10852 uint Kc
[16] = { 0 };
10853 uint Kd
[16] = { 0 };
10855 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10857 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10859 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10861 if (data3
[0] != digest_tmp
[0]) continue;
10862 if (data3
[1] != digest_tmp
[1]) continue;
10864 salt
->salt_buf
[2] = i
;
10866 salt
->salt_len
= 24;
10871 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10872 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10874 /* precompute netntlmv1 exploit stop */
10878 IP (digest
[0], digest
[1], tt
);
10879 IP (digest
[2], digest
[3], tt
);
10881 digest
[0] = rotr32 (digest
[0], 29);
10882 digest
[1] = rotr32 (digest
[1], 29);
10883 digest
[2] = rotr32 (digest
[2], 29);
10884 digest
[3] = rotr32 (digest
[3], 29);
10886 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10888 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10889 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10891 return (PARSER_OK
);
10894 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10896 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10898 u32
*digest
= (u32
*) hash_buf
->digest
;
10900 salt_t
*salt
= hash_buf
->salt
;
10902 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10908 char *user_pos
= input_buf
;
10910 char *unused_pos
= strchr (user_pos
, ':');
10912 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10914 uint user_len
= unused_pos
- user_pos
;
10916 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10920 char *domain_pos
= strchr (unused_pos
, ':');
10922 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10924 uint unused_len
= domain_pos
- unused_pos
;
10926 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10930 char *srvchall_pos
= strchr (domain_pos
, ':');
10932 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10934 uint domain_len
= srvchall_pos
- domain_pos
;
10936 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10940 char *hash_pos
= strchr (srvchall_pos
, ':');
10942 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10944 uint srvchall_len
= hash_pos
- srvchall_pos
;
10946 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10950 char *clichall_pos
= strchr (hash_pos
, ':');
10952 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10954 uint hash_len
= clichall_pos
- hash_pos
;
10956 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10960 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10962 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10964 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10967 * store some data for later use
10970 netntlm
->user_len
= user_len
* 2;
10971 netntlm
->domain_len
= domain_len
* 2;
10972 netntlm
->srvchall_len
= srvchall_len
/ 2;
10973 netntlm
->clichall_len
= clichall_len
/ 2;
10975 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10976 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10979 * handle username and domainname
10982 for (uint i
= 0; i
< user_len
; i
++)
10984 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10985 *userdomain_ptr
++ = 0;
10988 for (uint i
= 0; i
< domain_len
; i
++)
10990 *userdomain_ptr
++ = domain_pos
[i
];
10991 *userdomain_ptr
++ = 0;
10994 *userdomain_ptr
++ = 0x80;
10997 * handle server challenge encoding
11000 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11002 const char p0
= srvchall_pos
[i
+ 0];
11003 const char p1
= srvchall_pos
[i
+ 1];
11005 *chall_ptr
++ = hex_convert (p1
) << 0
11006 | hex_convert (p0
) << 4;
11010 * handle client challenge encoding
11013 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11015 const char p0
= clichall_pos
[i
+ 0];
11016 const char p1
= clichall_pos
[i
+ 1];
11018 *chall_ptr
++ = hex_convert (p1
) << 0
11019 | hex_convert (p0
) << 4;
11022 *chall_ptr
++ = 0x80;
11025 * handle hash itself
11028 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11029 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11030 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11031 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11033 digest
[0] = byte_swap_32 (digest
[0]);
11034 digest
[1] = byte_swap_32 (digest
[1]);
11035 digest
[2] = byte_swap_32 (digest
[2]);
11036 digest
[3] = byte_swap_32 (digest
[3]);
11039 * reuse challange data as salt_buf, its the buffer that is most likely unique
11042 salt
->salt_buf
[0] = 0;
11043 salt
->salt_buf
[1] = 0;
11044 salt
->salt_buf
[2] = 0;
11045 salt
->salt_buf
[3] = 0;
11046 salt
->salt_buf
[4] = 0;
11047 salt
->salt_buf
[5] = 0;
11048 salt
->salt_buf
[6] = 0;
11049 salt
->salt_buf
[7] = 0;
11053 uptr
= (uint
*) netntlm
->userdomain_buf
;
11055 for (uint i
= 0; i
< 16; i
+= 16)
11057 md5_64 (uptr
, salt
->salt_buf
);
11060 uptr
= (uint
*) netntlm
->chall_buf
;
11062 for (uint i
= 0; i
< 256; i
+= 16)
11064 md5_64 (uptr
, salt
->salt_buf
);
11067 salt
->salt_len
= 16;
11069 return (PARSER_OK
);
11072 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11074 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11076 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11080 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11083 u32
*digest
= (u32
*) hash_buf
->digest
;
11085 salt_t
*salt
= hash_buf
->salt
;
11087 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11088 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11089 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11090 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11092 digest
[0] = byte_swap_32 (digest
[0]);
11093 digest
[1] = byte_swap_32 (digest
[1]);
11094 digest
[2] = byte_swap_32 (digest
[2]);
11095 digest
[3] = byte_swap_32 (digest
[3]);
11097 digest
[0] -= MD5M_A
;
11098 digest
[1] -= MD5M_B
;
11099 digest
[2] -= MD5M_C
;
11100 digest
[3] -= MD5M_D
;
11102 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11104 uint salt_len
= input_len
- 32 - 1;
11106 char *salt_buf
= input_buf
+ 32 + 1;
11108 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11110 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11112 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11114 salt
->salt_len
= salt_len
;
11116 return (PARSER_OK
);
11119 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11121 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11123 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11127 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11130 u32
*digest
= (u32
*) hash_buf
->digest
;
11132 salt_t
*salt
= hash_buf
->salt
;
11134 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11135 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11136 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11137 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11139 digest
[0] = byte_swap_32 (digest
[0]);
11140 digest
[1] = byte_swap_32 (digest
[1]);
11141 digest
[2] = byte_swap_32 (digest
[2]);
11142 digest
[3] = byte_swap_32 (digest
[3]);
11144 digest
[0] -= MD5M_A
;
11145 digest
[1] -= MD5M_B
;
11146 digest
[2] -= MD5M_C
;
11147 digest
[3] -= MD5M_D
;
11149 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11151 uint salt_len
= input_len
- 32 - 1;
11153 char *salt_buf
= input_buf
+ 32 + 1;
11155 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11157 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11159 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11161 salt
->salt_len
= salt_len
;
11163 return (PARSER_OK
);
11166 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11168 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11170 u32
*digest
= (u32
*) hash_buf
->digest
;
11172 salt_t
*salt
= hash_buf
->salt
;
11174 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11175 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11176 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11177 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11179 digest
[0] = byte_swap_32 (digest
[0]);
11180 digest
[1] = byte_swap_32 (digest
[1]);
11181 digest
[2] = byte_swap_32 (digest
[2]);
11182 digest
[3] = byte_swap_32 (digest
[3]);
11184 digest
[0] -= MD5M_A
;
11185 digest
[1] -= MD5M_B
;
11186 digest
[2] -= MD5M_C
;
11187 digest
[3] -= MD5M_D
;
11190 * This is a virtual salt. While the algorithm is basically not salted
11191 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11192 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11195 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11197 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11199 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11201 salt
->salt_len
= salt_len
;
11203 return (PARSER_OK
);
11206 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11208 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11210 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11214 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11217 u32
*digest
= (u32
*) hash_buf
->digest
;
11219 salt_t
*salt
= hash_buf
->salt
;
11221 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11222 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11223 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11224 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11226 digest
[0] = byte_swap_32 (digest
[0]);
11227 digest
[1] = byte_swap_32 (digest
[1]);
11228 digest
[2] = byte_swap_32 (digest
[2]);
11229 digest
[3] = byte_swap_32 (digest
[3]);
11231 digest
[0] -= MD5M_A
;
11232 digest
[1] -= MD5M_B
;
11233 digest
[2] -= MD5M_C
;
11234 digest
[3] -= MD5M_D
;
11236 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11238 uint salt_len
= input_len
- 32 - 1;
11240 char *salt_buf
= input_buf
+ 32 + 1;
11242 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11244 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11246 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11248 salt
->salt_len
= salt_len
;
11250 return (PARSER_OK
);
11253 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11255 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11257 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11261 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11264 u32
*digest
= (u32
*) hash_buf
->digest
;
11266 salt_t
*salt
= hash_buf
->salt
;
11268 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11269 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11270 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11271 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11273 digest
[0] = byte_swap_32 (digest
[0]);
11274 digest
[1] = byte_swap_32 (digest
[1]);
11275 digest
[2] = byte_swap_32 (digest
[2]);
11276 digest
[3] = byte_swap_32 (digest
[3]);
11278 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11280 uint salt_len
= input_len
- 32 - 1;
11282 char *salt_buf
= input_buf
+ 32 + 1;
11284 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11286 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11288 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11290 salt
->salt_len
= salt_len
;
11292 return (PARSER_OK
);
11295 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11297 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11299 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11303 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11306 u32
*digest
= (u32
*) hash_buf
->digest
;
11308 salt_t
*salt
= hash_buf
->salt
;
11310 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11311 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11312 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11313 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11315 digest
[0] = byte_swap_32 (digest
[0]);
11316 digest
[1] = byte_swap_32 (digest
[1]);
11317 digest
[2] = byte_swap_32 (digest
[2]);
11318 digest
[3] = byte_swap_32 (digest
[3]);
11320 digest
[0] -= MD4M_A
;
11321 digest
[1] -= MD4M_B
;
11322 digest
[2] -= MD4M_C
;
11323 digest
[3] -= MD4M_D
;
11325 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11327 uint salt_len
= input_len
- 32 - 1;
11329 char *salt_buf
= input_buf
+ 32 + 1;
11331 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11333 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11335 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11337 salt
->salt_len
= salt_len
;
11339 return (PARSER_OK
);
11342 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11344 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11346 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11350 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11353 u32
*digest
= (u32
*) hash_buf
->digest
;
11355 salt_t
*salt
= hash_buf
->salt
;
11357 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11358 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11359 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11360 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11362 digest
[0] = byte_swap_32 (digest
[0]);
11363 digest
[1] = byte_swap_32 (digest
[1]);
11364 digest
[2] = byte_swap_32 (digest
[2]);
11365 digest
[3] = byte_swap_32 (digest
[3]);
11367 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11369 uint salt_len
= input_len
- 32 - 1;
11371 char *salt_buf
= input_buf
+ 32 + 1;
11373 uint salt_pc_block
[16] = { 0 };
11375 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11377 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11379 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11381 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11383 salt_pc_block
[14] = salt_len
* 8;
11385 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11387 md5_64 (salt_pc_block
, salt_pc_digest
);
11389 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11390 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11391 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11392 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11394 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11396 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11398 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11400 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11401 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11402 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11403 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11405 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11407 return (PARSER_OK
);
11410 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11412 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11414 u32
*digest
= (u32
*) hash_buf
->digest
;
11416 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11417 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11418 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11419 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11420 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11422 digest
[0] -= SHA1M_A
;
11423 digest
[1] -= SHA1M_B
;
11424 digest
[2] -= SHA1M_C
;
11425 digest
[3] -= SHA1M_D
;
11426 digest
[4] -= SHA1M_E
;
11428 return (PARSER_OK
);
11431 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11433 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11435 u32
*digest
= (u32
*) hash_buf
->digest
;
11437 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11438 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11439 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11440 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11441 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11443 return (PARSER_OK
);
11446 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11448 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11450 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11454 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11457 u32
*digest
= (u32
*) hash_buf
->digest
;
11459 salt_t
*salt
= hash_buf
->salt
;
11461 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11462 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11463 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11464 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11465 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11467 digest
[0] -= SHA1M_A
;
11468 digest
[1] -= SHA1M_B
;
11469 digest
[2] -= SHA1M_C
;
11470 digest
[3] -= SHA1M_D
;
11471 digest
[4] -= SHA1M_E
;
11473 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11475 uint salt_len
= input_len
- 40 - 1;
11477 char *salt_buf
= input_buf
+ 40 + 1;
11479 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11481 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11483 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11485 salt
->salt_len
= salt_len
;
11487 return (PARSER_OK
);
11490 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11492 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11494 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11496 u32
*digest
= (u32
*) hash_buf
->digest
;
11498 u8 tmp_buf
[100] = { 0 };
11500 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11502 memcpy (digest
, tmp_buf
, 20);
11504 digest
[0] = byte_swap_32 (digest
[0]);
11505 digest
[1] = byte_swap_32 (digest
[1]);
11506 digest
[2] = byte_swap_32 (digest
[2]);
11507 digest
[3] = byte_swap_32 (digest
[3]);
11508 digest
[4] = byte_swap_32 (digest
[4]);
11510 digest
[0] -= SHA1M_A
;
11511 digest
[1] -= SHA1M_B
;
11512 digest
[2] -= SHA1M_C
;
11513 digest
[3] -= SHA1M_D
;
11514 digest
[4] -= SHA1M_E
;
11516 return (PARSER_OK
);
11519 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11521 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11523 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11525 u32
*digest
= (u32
*) hash_buf
->digest
;
11527 salt_t
*salt
= hash_buf
->salt
;
11529 u8 tmp_buf
[100] = { 0 };
11531 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11533 memcpy (digest
, tmp_buf
, 20);
11535 salt
->salt_len
= tmp_len
- 20;
11537 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11539 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11541 char *ptr
= (char *) salt
->salt_buf
;
11543 ptr
[salt
->salt_len
] = 0x80;
11546 digest
[0] = byte_swap_32 (digest
[0]);
11547 digest
[1] = byte_swap_32 (digest
[1]);
11548 digest
[2] = byte_swap_32 (digest
[2]);
11549 digest
[3] = byte_swap_32 (digest
[3]);
11550 digest
[4] = byte_swap_32 (digest
[4]);
11552 digest
[0] -= SHA1M_A
;
11553 digest
[1] -= SHA1M_B
;
11554 digest
[2] -= SHA1M_C
;
11555 digest
[3] -= SHA1M_D
;
11556 digest
[4] -= SHA1M_E
;
11558 return (PARSER_OK
);
11561 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11563 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11565 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11567 u32
*digest
= (u32
*) hash_buf
->digest
;
11569 salt_t
*salt
= hash_buf
->salt
;
11571 char *salt_buf
= input_buf
+ 6;
11575 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11577 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11579 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11581 salt
->salt_len
= salt_len
;
11583 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11585 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11586 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11587 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11588 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11589 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11591 digest
[0] -= SHA1M_A
;
11592 digest
[1] -= SHA1M_B
;
11593 digest
[2] -= SHA1M_C
;
11594 digest
[3] -= SHA1M_D
;
11595 digest
[4] -= SHA1M_E
;
11597 return (PARSER_OK
);
11600 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11602 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11604 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11606 u32
*digest
= (u32
*) hash_buf
->digest
;
11608 salt_t
*salt
= hash_buf
->salt
;
11610 char *salt_buf
= input_buf
+ 6;
11614 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11616 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11618 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11620 salt
->salt_len
= salt_len
;
11622 char *hash_pos
= input_buf
+ 6 + 8;
11624 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11625 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11626 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11627 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11628 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11630 digest
[0] -= SHA1M_A
;
11631 digest
[1] -= SHA1M_B
;
11632 digest
[2] -= SHA1M_C
;
11633 digest
[3] -= SHA1M_D
;
11634 digest
[4] -= SHA1M_E
;
11636 return (PARSER_OK
);
11639 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11641 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11643 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11645 u64
*digest
= (u64
*) hash_buf
->digest
;
11647 salt_t
*salt
= hash_buf
->salt
;
11649 char *salt_buf
= input_buf
+ 6;
11653 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11655 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11657 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11659 salt
->salt_len
= salt_len
;
11661 char *hash_pos
= input_buf
+ 6 + 8;
11663 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11664 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11665 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11666 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11667 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11668 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11669 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11670 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11672 digest
[0] -= SHA512M_A
;
11673 digest
[1] -= SHA512M_B
;
11674 digest
[2] -= SHA512M_C
;
11675 digest
[3] -= SHA512M_D
;
11676 digest
[4] -= SHA512M_E
;
11677 digest
[5] -= SHA512M_F
;
11678 digest
[6] -= SHA512M_G
;
11679 digest
[7] -= SHA512M_H
;
11681 return (PARSER_OK
);
11684 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11686 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11688 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11692 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11695 u32
*digest
= (u32
*) hash_buf
->digest
;
11697 salt_t
*salt
= hash_buf
->salt
;
11699 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11700 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11704 digest
[0] = byte_swap_32 (digest
[0]);
11705 digest
[1] = byte_swap_32 (digest
[1]);
11707 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11709 uint salt_len
= input_len
- 16 - 1;
11711 char *salt_buf
= input_buf
+ 16 + 1;
11713 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11715 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11717 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11719 salt
->salt_len
= salt_len
;
11721 return (PARSER_OK
);
11724 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11726 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11728 u32
*digest
= (u32
*) hash_buf
->digest
;
11730 salt_t
*salt
= hash_buf
->salt
;
11732 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11733 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11734 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11735 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11736 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11738 digest
[0] -= SHA1M_A
;
11739 digest
[1] -= SHA1M_B
;
11740 digest
[2] -= SHA1M_C
;
11741 digest
[3] -= SHA1M_D
;
11742 digest
[4] -= SHA1M_E
;
11744 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11746 uint salt_len
= input_len
- 40 - 1;
11748 char *salt_buf
= input_buf
+ 40 + 1;
11750 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11752 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11754 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11756 salt
->salt_len
= salt_len
;
11758 return (PARSER_OK
);
11761 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11763 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11765 u32
*digest
= (u32
*) hash_buf
->digest
;
11767 salt_t
*salt
= hash_buf
->salt
;
11769 char *hash_pos
= input_buf
;
11771 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11772 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11773 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11774 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11775 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11776 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11777 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11778 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11779 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11780 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11781 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11782 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11783 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11784 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11785 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11786 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11788 char *salt_pos
= input_buf
+ 128;
11790 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11791 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11792 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11793 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11795 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11796 salt
->salt_len
= 16;
11798 return (PARSER_OK
);
11801 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11803 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11805 u32
*digest
= (u32
*) hash_buf
->digest
;
11807 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11808 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11809 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11810 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11811 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11812 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11813 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11814 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11816 digest
[0] -= SHA256M_A
;
11817 digest
[1] -= SHA256M_B
;
11818 digest
[2] -= SHA256M_C
;
11819 digest
[3] -= SHA256M_D
;
11820 digest
[4] -= SHA256M_E
;
11821 digest
[5] -= SHA256M_F
;
11822 digest
[6] -= SHA256M_G
;
11823 digest
[7] -= SHA256M_H
;
11825 return (PARSER_OK
);
11828 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11830 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11832 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11836 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11839 u32
*digest
= (u32
*) hash_buf
->digest
;
11841 salt_t
*salt
= hash_buf
->salt
;
11843 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11844 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11845 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11846 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11847 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11848 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11849 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11850 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11852 digest
[0] -= SHA256M_A
;
11853 digest
[1] -= SHA256M_B
;
11854 digest
[2] -= SHA256M_C
;
11855 digest
[3] -= SHA256M_D
;
11856 digest
[4] -= SHA256M_E
;
11857 digest
[5] -= SHA256M_F
;
11858 digest
[6] -= SHA256M_G
;
11859 digest
[7] -= SHA256M_H
;
11861 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11863 uint salt_len
= input_len
- 64 - 1;
11865 char *salt_buf
= input_buf
+ 64 + 1;
11867 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11869 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11871 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11873 salt
->salt_len
= salt_len
;
11875 return (PARSER_OK
);
11878 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11880 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11882 u64
*digest
= (u64
*) hash_buf
->digest
;
11884 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11885 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11886 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11887 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11888 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11889 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11893 digest
[0] -= SHA384M_A
;
11894 digest
[1] -= SHA384M_B
;
11895 digest
[2] -= SHA384M_C
;
11896 digest
[3] -= SHA384M_D
;
11897 digest
[4] -= SHA384M_E
;
11898 digest
[5] -= SHA384M_F
;
11902 return (PARSER_OK
);
11905 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11907 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11909 u64
*digest
= (u64
*) hash_buf
->digest
;
11911 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11912 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11913 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11914 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11915 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11916 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11917 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11918 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11920 digest
[0] -= SHA512M_A
;
11921 digest
[1] -= SHA512M_B
;
11922 digest
[2] -= SHA512M_C
;
11923 digest
[3] -= SHA512M_D
;
11924 digest
[4] -= SHA512M_E
;
11925 digest
[5] -= SHA512M_F
;
11926 digest
[6] -= SHA512M_G
;
11927 digest
[7] -= SHA512M_H
;
11929 return (PARSER_OK
);
11932 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11934 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11936 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11940 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11943 u64
*digest
= (u64
*) hash_buf
->digest
;
11945 salt_t
*salt
= hash_buf
->salt
;
11947 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11948 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11949 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11950 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11951 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11952 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11953 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11954 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11956 digest
[0] -= SHA512M_A
;
11957 digest
[1] -= SHA512M_B
;
11958 digest
[2] -= SHA512M_C
;
11959 digest
[3] -= SHA512M_D
;
11960 digest
[4] -= SHA512M_E
;
11961 digest
[5] -= SHA512M_F
;
11962 digest
[6] -= SHA512M_G
;
11963 digest
[7] -= SHA512M_H
;
11965 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11967 uint salt_len
= input_len
- 128 - 1;
11969 char *salt_buf
= input_buf
+ 128 + 1;
11971 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11973 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11975 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11977 salt
->salt_len
= salt_len
;
11979 return (PARSER_OK
);
11982 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11984 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11986 u64
*digest
= (u64
*) hash_buf
->digest
;
11988 salt_t
*salt
= hash_buf
->salt
;
11990 char *salt_pos
= input_buf
+ 3;
11992 uint iterations_len
= 0;
11994 if (memcmp (salt_pos
, "rounds=", 7) == 0)
11998 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12000 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12001 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12005 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12009 iterations_len
+= 8;
12013 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12016 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12018 char *hash_pos
= strchr (salt_pos
, '$');
12020 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12022 uint salt_len
= hash_pos
- salt_pos
;
12024 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12026 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12028 salt
->salt_len
= salt_len
;
12032 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12034 return (PARSER_OK
);
12037 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12039 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12041 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12043 u64
*digest
= (u64
*) hash_buf
->digest
;
12045 salt_t
*salt
= hash_buf
->salt
;
12047 uint keccak_mdlen
= input_len
/ 2;
12049 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12051 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12053 digest
[i
] = byte_swap_64 (digest
[i
]);
12056 salt
->keccak_mdlen
= keccak_mdlen
;
12058 return (PARSER_OK
);
12061 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12063 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12065 u32
*digest
= (u32
*) hash_buf
->digest
;
12067 salt_t
*salt
= hash_buf
->salt
;
12069 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12072 * Parse that strange long line
12077 size_t in_len
[9] = { 0 };
12079 in_off
[0] = strtok (input_buf
, ":");
12081 in_len
[0] = strlen (in_off
[0]);
12085 for (i
= 1; i
< 9; i
++)
12087 in_off
[i
] = strtok (NULL
, ":");
12089 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12091 in_len
[i
] = strlen (in_off
[i
]);
12094 char *ptr
= (char *) ikepsk
->msg_buf
;
12096 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12097 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12098 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12099 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12100 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12101 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12105 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12107 ptr
= (char *) ikepsk
->nr_buf
;
12109 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12110 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12114 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12117 * Store to database
12122 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12123 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12124 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12125 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12127 digest
[0] = byte_swap_32 (digest
[0]);
12128 digest
[1] = byte_swap_32 (digest
[1]);
12129 digest
[2] = byte_swap_32 (digest
[2]);
12130 digest
[3] = byte_swap_32 (digest
[3]);
12132 salt
->salt_len
= 32;
12134 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12135 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12136 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12137 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12138 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12139 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12140 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12141 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12143 return (PARSER_OK
);
12146 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12148 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12150 u32
*digest
= (u32
*) hash_buf
->digest
;
12152 salt_t
*salt
= hash_buf
->salt
;
12154 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12157 * Parse that strange long line
12162 size_t in_len
[9] = { 0 };
12164 in_off
[0] = strtok (input_buf
, ":");
12166 in_len
[0] = strlen (in_off
[0]);
12170 for (i
= 1; i
< 9; i
++)
12172 in_off
[i
] = strtok (NULL
, ":");
12174 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12176 in_len
[i
] = strlen (in_off
[i
]);
12179 char *ptr
= (char *) ikepsk
->msg_buf
;
12181 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12182 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12183 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12184 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12185 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12186 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12190 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12192 ptr
= (char *) ikepsk
->nr_buf
;
12194 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12195 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12199 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12202 * Store to database
12207 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12208 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12209 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12210 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12211 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12213 salt
->salt_len
= 32;
12215 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12216 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12217 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12218 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12219 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12220 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12221 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12222 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12224 return (PARSER_OK
);
12227 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12229 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12231 u32
*digest
= (u32
*) hash_buf
->digest
;
12233 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12234 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12235 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12236 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12237 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12239 digest
[0] = byte_swap_32 (digest
[0]);
12240 digest
[1] = byte_swap_32 (digest
[1]);
12241 digest
[2] = byte_swap_32 (digest
[2]);
12242 digest
[3] = byte_swap_32 (digest
[3]);
12243 digest
[4] = byte_swap_32 (digest
[4]);
12245 return (PARSER_OK
);
12248 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12250 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12252 u32
*digest
= (u32
*) hash_buf
->digest
;
12254 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12255 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12256 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12257 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12258 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12259 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12260 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12261 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12262 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12263 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12264 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12265 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12266 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12267 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12268 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12269 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12271 return (PARSER_OK
);
12274 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12276 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12278 u32
*digest
= (u32
*) hash_buf
->digest
;
12280 salt_t
*salt
= hash_buf
->salt
;
12282 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12283 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12284 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12285 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12286 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12288 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12290 uint salt_len
= input_len
- 40 - 1;
12292 char *salt_buf
= input_buf
+ 40 + 1;
12294 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12296 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12298 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12300 salt
->salt_len
= salt_len
;
12302 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12304 return (PARSER_OK
);
12307 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12309 u32
*digest
= (u32
*) hash_buf
->digest
;
12311 salt_t
*salt
= hash_buf
->salt
;
12313 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12315 if (input_len
== 0)
12317 log_error ("TrueCrypt container not specified");
12322 FILE *fp
= fopen (input_buf
, "rb");
12326 log_error ("%s: %s", input_buf
, strerror (errno
));
12331 char buf
[512] = { 0 };
12333 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12337 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12339 memcpy (tc
->salt_buf
, buf
, 64);
12341 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12343 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12345 salt
->salt_len
= 4;
12347 salt
->salt_iter
= 1000 - 1;
12349 digest
[0] = tc
->data_buf
[0];
12351 return (PARSER_OK
);
12354 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12356 u32
*digest
= (u32
*) hash_buf
->digest
;
12358 salt_t
*salt
= hash_buf
->salt
;
12360 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12362 if (input_len
== 0)
12364 log_error ("TrueCrypt container not specified");
12369 FILE *fp
= fopen (input_buf
, "rb");
12373 log_error ("%s: %s", input_buf
, strerror (errno
));
12378 char buf
[512] = { 0 };
12380 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12384 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12386 memcpy (tc
->salt_buf
, buf
, 64);
12388 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12390 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12392 salt
->salt_len
= 4;
12394 salt
->salt_iter
= 2000 - 1;
12396 digest
[0] = tc
->data_buf
[0];
12398 return (PARSER_OK
);
12401 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12403 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12405 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12407 u32
*digest
= (u32
*) hash_buf
->digest
;
12409 salt_t
*salt
= hash_buf
->salt
;
12411 char *salt_pos
= input_buf
+ 6;
12413 char *hash_pos
= strchr (salt_pos
, '$');
12415 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12417 uint salt_len
= hash_pos
- salt_pos
;
12419 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12421 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12423 salt
->salt_len
= salt_len
;
12425 salt
->salt_iter
= 1000;
12429 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12431 return (PARSER_OK
);
12434 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12436 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12438 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12440 u32
*digest
= (u32
*) hash_buf
->digest
;
12442 salt_t
*salt
= hash_buf
->salt
;
12444 char *iter_pos
= input_buf
+ 7;
12446 char *salt_pos
= strchr (iter_pos
, '$');
12448 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12452 char *hash_pos
= strchr (salt_pos
, '$');
12454 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12456 uint salt_len
= hash_pos
- salt_pos
;
12458 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12460 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12462 salt
->salt_len
= salt_len
;
12464 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12466 salt
->salt_sign
[0] = atoi (salt_iter
);
12468 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12472 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12474 digest
[0] = byte_swap_32 (digest
[0]);
12475 digest
[1] = byte_swap_32 (digest
[1]);
12476 digest
[2] = byte_swap_32 (digest
[2]);
12477 digest
[3] = byte_swap_32 (digest
[3]);
12478 digest
[4] = byte_swap_32 (digest
[4]);
12480 return (PARSER_OK
);
12483 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12485 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12487 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12489 u32
*digest
= (u32
*) hash_buf
->digest
;
12491 salt_t
*salt
= hash_buf
->salt
;
12493 char *iter_pos
= input_buf
+ 9;
12495 char *salt_pos
= strchr (iter_pos
, '$');
12497 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12501 char *hash_pos
= strchr (salt_pos
, '$');
12503 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12505 uint salt_len
= hash_pos
- salt_pos
;
12507 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12509 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12511 salt
->salt_len
= salt_len
;
12513 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12515 salt
->salt_sign
[0] = atoi (salt_iter
);
12517 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12521 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12523 digest
[0] = byte_swap_32 (digest
[0]);
12524 digest
[1] = byte_swap_32 (digest
[1]);
12525 digest
[2] = byte_swap_32 (digest
[2]);
12526 digest
[3] = byte_swap_32 (digest
[3]);
12527 digest
[4] = byte_swap_32 (digest
[4]);
12528 digest
[5] = byte_swap_32 (digest
[5]);
12529 digest
[6] = byte_swap_32 (digest
[6]);
12530 digest
[7] = byte_swap_32 (digest
[7]);
12532 return (PARSER_OK
);
12535 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12537 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12539 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12541 u64
*digest
= (u64
*) hash_buf
->digest
;
12543 salt_t
*salt
= hash_buf
->salt
;
12545 char *iter_pos
= input_buf
+ 9;
12547 char *salt_pos
= strchr (iter_pos
, '$');
12549 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12553 char *hash_pos
= strchr (salt_pos
, '$');
12555 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12557 uint salt_len
= hash_pos
- salt_pos
;
12559 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12561 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12563 salt
->salt_len
= salt_len
;
12565 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12567 salt
->salt_sign
[0] = atoi (salt_iter
);
12569 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12573 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12575 digest
[0] = byte_swap_64 (digest
[0]);
12576 digest
[1] = byte_swap_64 (digest
[1]);
12577 digest
[2] = byte_swap_64 (digest
[2]);
12578 digest
[3] = byte_swap_64 (digest
[3]);
12579 digest
[4] = byte_swap_64 (digest
[4]);
12580 digest
[5] = byte_swap_64 (digest
[5]);
12581 digest
[6] = byte_swap_64 (digest
[6]);
12582 digest
[7] = byte_swap_64 (digest
[7]);
12584 return (PARSER_OK
);
12587 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12589 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12591 u32
*digest
= (u32
*) hash_buf
->digest
;
12593 salt_t
*salt
= hash_buf
->salt
;
12595 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12601 char *iterations_pos
= input_buf
;
12603 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12605 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12607 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12609 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12613 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12615 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12617 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12619 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12621 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12623 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12628 * pbkdf2 iterations
12631 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12634 * handle salt encoding
12637 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12639 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12641 const char p0
= saltbuf_pos
[i
+ 0];
12642 const char p1
= saltbuf_pos
[i
+ 1];
12644 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12645 | hex_convert (p0
) << 4;
12648 salt
->salt_len
= saltbuf_len
/ 2;
12651 * handle cipher encoding
12654 uint
*tmp
= (uint
*) mymalloc (32);
12656 char *cipherbuf_ptr
= (char *) tmp
;
12658 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12660 const char p0
= cipherbuf_pos
[i
+ 0];
12661 const char p1
= cipherbuf_pos
[i
+ 1];
12663 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12664 | hex_convert (p0
) << 4;
12667 // iv is stored at salt_buf 4 (length 16)
12668 // data is stored at salt_buf 8 (length 16)
12670 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12671 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12672 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12673 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12675 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12676 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12677 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12678 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12682 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12684 const char p0
= cipherbuf_pos
[j
+ 0];
12685 const char p1
= cipherbuf_pos
[j
+ 1];
12687 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12688 | hex_convert (p0
) << 4;
12695 digest
[0] = 0x10101010;
12696 digest
[1] = 0x10101010;
12697 digest
[2] = 0x10101010;
12698 digest
[3] = 0x10101010;
12700 return (PARSER_OK
);
12703 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12705 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12707 u32
*digest
= (u32
*) hash_buf
->digest
;
12709 salt_t
*salt
= hash_buf
->salt
;
12711 char *hashbuf_pos
= input_buf
;
12713 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12715 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12717 uint hash_len
= iterations_pos
- hashbuf_pos
;
12719 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12723 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12725 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12727 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12731 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12733 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12735 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12737 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12739 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12741 salt
->salt_len
= salt_len
;
12743 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12745 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12746 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12747 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12748 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12750 return (PARSER_OK
);
12753 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12755 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12757 u32
*digest
= (u32
*) hash_buf
->digest
;
12759 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12760 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12761 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12762 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12763 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12764 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12765 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12766 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12768 digest
[0] = byte_swap_32 (digest
[0]);
12769 digest
[1] = byte_swap_32 (digest
[1]);
12770 digest
[2] = byte_swap_32 (digest
[2]);
12771 digest
[3] = byte_swap_32 (digest
[3]);
12772 digest
[4] = byte_swap_32 (digest
[4]);
12773 digest
[5] = byte_swap_32 (digest
[5]);
12774 digest
[6] = byte_swap_32 (digest
[6]);
12775 digest
[7] = byte_swap_32 (digest
[7]);
12777 return (PARSER_OK
);
12780 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12782 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12784 u32
*digest
= (u32
*) hash_buf
->digest
;
12786 salt_t
*salt
= hash_buf
->salt
;
12788 char *salt_pos
= input_buf
+ 3;
12790 uint iterations_len
= 0;
12792 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12796 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12798 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12799 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12803 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12807 iterations_len
+= 8;
12811 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12814 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12816 char *hash_pos
= strchr (salt_pos
, '$');
12818 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12820 uint salt_len
= hash_pos
- salt_pos
;
12822 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12824 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12826 salt
->salt_len
= salt_len
;
12830 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12832 return (PARSER_OK
);
12835 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12837 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12839 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12841 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12843 u64
*digest
= (u64
*) hash_buf
->digest
;
12845 salt_t
*salt
= hash_buf
->salt
;
12847 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12849 char *iter_pos
= input_buf
+ 4;
12851 char *salt_pos
= strchr (iter_pos
, '$');
12853 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12857 char *hash_pos
= strchr (salt_pos
, '$');
12859 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12861 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12865 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12866 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12867 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12868 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12869 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12870 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12871 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12872 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12874 uint salt_len
= hash_pos
- salt_pos
- 1;
12876 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12878 salt
->salt_len
= salt_len
/ 2;
12880 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12881 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12882 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12883 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12884 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12885 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12886 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12887 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12889 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12890 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12891 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12892 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12893 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12894 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12895 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12896 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12897 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12898 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12900 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12902 salt
->salt_iter
= atoi (iter_pos
) - 1;
12904 return (PARSER_OK
);
12907 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12909 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12911 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12913 u32
*digest
= (u32
*) hash_buf
->digest
;
12915 salt_t
*salt
= hash_buf
->salt
;
12917 char *salt_pos
= input_buf
+ 14;
12919 char *hash_pos
= strchr (salt_pos
, '*');
12921 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12925 uint salt_len
= hash_pos
- salt_pos
- 1;
12927 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12929 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12931 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12933 salt
->salt_len
= salt_len
;
12935 u8 tmp_buf
[100] = { 0 };
12937 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
12939 memcpy (digest
, tmp_buf
, 32);
12941 digest
[0] = byte_swap_32 (digest
[0]);
12942 digest
[1] = byte_swap_32 (digest
[1]);
12943 digest
[2] = byte_swap_32 (digest
[2]);
12944 digest
[3] = byte_swap_32 (digest
[3]);
12945 digest
[4] = byte_swap_32 (digest
[4]);
12946 digest
[5] = byte_swap_32 (digest
[5]);
12947 digest
[6] = byte_swap_32 (digest
[6]);
12948 digest
[7] = byte_swap_32 (digest
[7]);
12950 digest
[0] -= SHA256M_A
;
12951 digest
[1] -= SHA256M_B
;
12952 digest
[2] -= SHA256M_C
;
12953 digest
[3] -= SHA256M_D
;
12954 digest
[4] -= SHA256M_E
;
12955 digest
[5] -= SHA256M_F
;
12956 digest
[6] -= SHA256M_G
;
12957 digest
[7] -= SHA256M_H
;
12959 return (PARSER_OK
);
12962 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12964 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12966 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12968 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12970 u64
*digest
= (u64
*) hash_buf
->digest
;
12972 salt_t
*salt
= hash_buf
->salt
;
12974 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12976 char *iter_pos
= input_buf
+ 19;
12978 char *salt_pos
= strchr (iter_pos
, '.');
12980 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12984 char *hash_pos
= strchr (salt_pos
, '.');
12986 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12988 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12992 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12993 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12994 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12995 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12996 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12997 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12998 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12999 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13001 uint salt_len
= hash_pos
- salt_pos
- 1;
13005 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13009 for (i
= 0; i
< salt_len
; i
++)
13011 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13014 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13015 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13017 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13019 salt
->salt_len
= salt_len
;
13021 salt
->salt_iter
= atoi (iter_pos
) - 1;
13023 return (PARSER_OK
);
13026 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13028 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13030 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13032 u64
*digest
= (u64
*) hash_buf
->digest
;
13034 salt_t
*salt
= hash_buf
->salt
;
13036 u8 tmp_buf
[120] = { 0 };
13038 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13040 memcpy (digest
, tmp_buf
, 64);
13042 digest
[0] = byte_swap_64 (digest
[0]);
13043 digest
[1] = byte_swap_64 (digest
[1]);
13044 digest
[2] = byte_swap_64 (digest
[2]);
13045 digest
[3] = byte_swap_64 (digest
[3]);
13046 digest
[4] = byte_swap_64 (digest
[4]);
13047 digest
[5] = byte_swap_64 (digest
[5]);
13048 digest
[6] = byte_swap_64 (digest
[6]);
13049 digest
[7] = byte_swap_64 (digest
[7]);
13051 digest
[0] -= SHA512M_A
;
13052 digest
[1] -= SHA512M_B
;
13053 digest
[2] -= SHA512M_C
;
13054 digest
[3] -= SHA512M_D
;
13055 digest
[4] -= SHA512M_E
;
13056 digest
[5] -= SHA512M_F
;
13057 digest
[6] -= SHA512M_G
;
13058 digest
[7] -= SHA512M_H
;
13060 salt
->salt_len
= tmp_len
- 64;
13062 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13064 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13066 char *ptr
= (char *) salt
->salt_buf
;
13068 ptr
[salt
->salt_len
] = 0x80;
13071 return (PARSER_OK
);
13074 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13076 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13078 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13082 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13085 u32
*digest
= (u32
*) hash_buf
->digest
;
13087 salt_t
*salt
= hash_buf
->salt
;
13089 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13090 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13091 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13092 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13094 digest
[0] = byte_swap_32 (digest
[0]);
13095 digest
[1] = byte_swap_32 (digest
[1]);
13096 digest
[2] = byte_swap_32 (digest
[2]);
13097 digest
[3] = byte_swap_32 (digest
[3]);
13099 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13101 uint salt_len
= input_len
- 32 - 1;
13103 char *salt_buf
= input_buf
+ 32 + 1;
13105 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13107 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13109 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13111 salt
->salt_len
= salt_len
;
13113 return (PARSER_OK
);
13116 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13118 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13120 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13124 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13127 u32
*digest
= (u32
*) hash_buf
->digest
;
13129 salt_t
*salt
= hash_buf
->salt
;
13131 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13132 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13133 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13134 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13135 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13137 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13139 uint salt_len
= input_len
- 40 - 1;
13141 char *salt_buf
= input_buf
+ 40 + 1;
13143 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13145 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13147 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13149 salt
->salt_len
= salt_len
;
13151 return (PARSER_OK
);
13154 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13156 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13158 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13162 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13165 u32
*digest
= (u32
*) hash_buf
->digest
;
13167 salt_t
*salt
= hash_buf
->salt
;
13169 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13170 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13171 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13172 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13173 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13174 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13175 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13176 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13178 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13180 uint salt_len
= input_len
- 64 - 1;
13182 char *salt_buf
= input_buf
+ 64 + 1;
13184 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13186 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13188 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13190 salt
->salt_len
= salt_len
;
13192 return (PARSER_OK
);
13195 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13197 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13199 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13203 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13206 u64
*digest
= (u64
*) hash_buf
->digest
;
13208 salt_t
*salt
= hash_buf
->salt
;
13210 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13211 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13212 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13213 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13214 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13215 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13216 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13217 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13219 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13221 uint salt_len
= input_len
- 128 - 1;
13223 char *salt_buf
= input_buf
+ 128 + 1;
13225 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13227 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13229 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13231 salt
->salt_len
= salt_len
;
13233 return (PARSER_OK
);
13236 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13238 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13240 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13242 u32
*digest
= (u32
*) hash_buf
->digest
;
13244 salt_t
*salt
= hash_buf
->salt
;
13246 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13252 char *user_pos
= input_buf
+ 10 + 1;
13254 char *realm_pos
= strchr (user_pos
, '$');
13256 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13258 uint user_len
= realm_pos
- user_pos
;
13260 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13264 char *salt_pos
= strchr (realm_pos
, '$');
13266 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13268 uint realm_len
= salt_pos
- realm_pos
;
13270 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13274 char *data_pos
= strchr (salt_pos
, '$');
13276 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13278 uint salt_len
= data_pos
- salt_pos
;
13280 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13284 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13286 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13292 memcpy (krb5pa
->user
, user_pos
, user_len
);
13293 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13294 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13296 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13298 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13300 const char p0
= data_pos
[i
+ 0];
13301 const char p1
= data_pos
[i
+ 1];
13303 *timestamp_ptr
++ = hex_convert (p1
) << 0
13304 | hex_convert (p0
) << 4;
13307 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13309 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13311 const char p0
= data_pos
[i
+ 0];
13312 const char p1
= data_pos
[i
+ 1];
13314 *checksum_ptr
++ = hex_convert (p1
) << 0
13315 | hex_convert (p0
) << 4;
13319 * copy some data to generic buffers to make sorting happy
13322 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13323 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13324 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13325 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13326 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13327 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13328 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13329 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13330 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13332 salt
->salt_len
= 36;
13334 digest
[0] = krb5pa
->checksum
[0];
13335 digest
[1] = krb5pa
->checksum
[1];
13336 digest
[2] = krb5pa
->checksum
[2];
13337 digest
[3] = krb5pa
->checksum
[3];
13339 return (PARSER_OK
);
13342 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13344 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13346 u32
*digest
= (u32
*) hash_buf
->digest
;
13348 salt_t
*salt
= hash_buf
->salt
;
13354 char *salt_pos
= input_buf
;
13356 char *hash_pos
= strchr (salt_pos
, '$');
13358 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13360 uint salt_len
= hash_pos
- salt_pos
;
13362 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13366 uint hash_len
= input_len
- 1 - salt_len
;
13368 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13376 for (uint i
= 0; i
< salt_len
; i
++)
13378 if (salt_pos
[i
] == ' ') continue;
13383 // SAP user names cannot be longer than 12 characters
13384 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13386 // SAP user name cannot start with ! or ?
13387 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13393 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13395 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13397 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13399 salt
->salt_len
= salt_len
;
13401 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13402 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13406 digest
[0] = byte_swap_32 (digest
[0]);
13407 digest
[1] = byte_swap_32 (digest
[1]);
13409 return (PARSER_OK
);
13412 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13414 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13416 u32
*digest
= (u32
*) hash_buf
->digest
;
13418 salt_t
*salt
= hash_buf
->salt
;
13424 char *salt_pos
= input_buf
;
13426 char *hash_pos
= strchr (salt_pos
, '$');
13428 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13430 uint salt_len
= hash_pos
- salt_pos
;
13432 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13436 uint hash_len
= input_len
- 1 - salt_len
;
13438 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13446 for (uint i
= 0; i
< salt_len
; i
++)
13448 if (salt_pos
[i
] == ' ') continue;
13453 // SAP user names cannot be longer than 12 characters
13454 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13455 // so far nobody complained so we stay with this because it helps in optimization
13456 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13458 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13460 // SAP user name cannot start with ! or ?
13461 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13467 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13469 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13471 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13473 salt
->salt_len
= salt_len
;
13475 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13476 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13477 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13478 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13479 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13481 return (PARSER_OK
);
13484 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13486 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13488 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13490 u64
*digest
= (u64
*) hash_buf
->digest
;
13492 salt_t
*salt
= hash_buf
->salt
;
13494 char *iter_pos
= input_buf
+ 3;
13496 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13498 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13500 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13502 salt
->salt_iter
= salt_iter
;
13504 char *salt_pos
= iter_pos
+ 1;
13508 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13510 salt
->salt_len
= salt_len
;
13512 char *hash_pos
= salt_pos
+ salt_len
;
13514 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13518 char *tmp
= (char *) salt
->salt_buf_pc
;
13520 tmp
[0] = hash_pos
[42];
13524 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13525 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13526 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13527 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13533 return (PARSER_OK
);
13536 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13538 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13540 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13542 u32
*digest
= (u32
*) hash_buf
->digest
;
13544 salt_t
*salt
= hash_buf
->salt
;
13546 char *salt_buf
= input_buf
+ 6;
13548 uint salt_len
= 16;
13550 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13552 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13554 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13556 salt
->salt_len
= salt_len
;
13558 char *hash_pos
= input_buf
+ 6 + 16;
13560 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13561 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13562 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13563 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13564 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13565 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13566 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13567 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13569 return (PARSER_OK
);
13572 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13574 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13576 u32
*digest
= (u32
*) hash_buf
->digest
;
13578 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13579 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13583 return (PARSER_OK
);
13586 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13588 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13590 u32
*digest
= (u32
*) hash_buf
->digest
;
13592 salt_t
*salt
= hash_buf
->salt
;
13594 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13596 char *saltbuf_pos
= input_buf
;
13598 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13600 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13602 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13604 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13605 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13607 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13611 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13613 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13615 char *salt_ptr
= (char *) saltbuf_pos
;
13616 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13621 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13623 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13626 rakp_ptr
[j
] = 0x80;
13628 rakp
->salt_len
= j
;
13630 for (i
= 0; i
< 64; i
++)
13632 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13635 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13636 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13637 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13638 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13639 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13640 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13641 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13642 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13644 salt
->salt_len
= 32; // muss min. 32 haben
13646 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13647 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13648 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13649 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13650 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13652 return (PARSER_OK
);
13655 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13657 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13659 u32
*digest
= (u32
*) hash_buf
->digest
;
13661 salt_t
*salt
= hash_buf
->salt
;
13663 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13665 char *salt_pos
= input_buf
+ 1;
13667 memcpy (salt
->salt_buf
, salt_pos
, 8);
13669 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13670 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13672 salt
->salt_len
= 8;
13674 char *hash_pos
= salt_pos
+ 8;
13676 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13677 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13678 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13679 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13680 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13682 digest
[0] -= SHA1M_A
;
13683 digest
[1] -= SHA1M_B
;
13684 digest
[2] -= SHA1M_C
;
13685 digest
[3] -= SHA1M_D
;
13686 digest
[4] -= SHA1M_E
;
13688 return (PARSER_OK
);
13691 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13693 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13695 u32
*digest
= (u32
*) hash_buf
->digest
;
13697 salt_t
*salt
= hash_buf
->salt
;
13699 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13700 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13701 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13702 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13704 digest
[0] = byte_swap_32 (digest
[0]);
13705 digest
[1] = byte_swap_32 (digest
[1]);
13706 digest
[2] = byte_swap_32 (digest
[2]);
13707 digest
[3] = byte_swap_32 (digest
[3]);
13709 digest
[0] -= MD5M_A
;
13710 digest
[1] -= MD5M_B
;
13711 digest
[2] -= MD5M_C
;
13712 digest
[3] -= MD5M_D
;
13714 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13716 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13718 u32
*salt_buf
= salt
->salt_buf
;
13720 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13721 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13722 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13723 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13725 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13726 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13727 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13728 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13730 salt
->salt_len
= 16 + 1;
13732 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13734 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13736 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13738 return (PARSER_OK
);
13741 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13743 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13745 u32
*digest
= (u32
*) hash_buf
->digest
;
13747 salt_t
*salt
= hash_buf
->salt
;
13749 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13755 char *hashbuf_pos
= input_buf
;
13757 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13759 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13761 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13763 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13767 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13769 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13771 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13773 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13777 char *databuf_pos
= strchr (iteration_pos
, ':');
13779 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13781 const uint iteration_len
= databuf_pos
- iteration_pos
;
13783 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13784 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13786 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13788 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13789 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13795 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13796 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13797 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13798 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13799 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13800 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13801 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13802 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13806 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13808 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13810 const char p0
= saltbuf_pos
[i
+ 0];
13811 const char p1
= saltbuf_pos
[i
+ 1];
13813 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13814 | hex_convert (p0
) << 4;
13817 salt
->salt_buf
[4] = 0x01000000;
13818 salt
->salt_buf
[5] = 0x80;
13820 salt
->salt_len
= saltbuf_len
/ 2;
13824 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13828 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13830 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13832 const char p0
= databuf_pos
[i
+ 0];
13833 const char p1
= databuf_pos
[i
+ 1];
13835 *databuf_ptr
++ = hex_convert (p1
) << 0
13836 | hex_convert (p0
) << 4;
13839 *databuf_ptr
++ = 0x80;
13841 for (uint i
= 0; i
< 512; i
++)
13843 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13846 cloudkey
->data_len
= databuf_len
/ 2;
13848 return (PARSER_OK
);
13851 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13853 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13855 u32
*digest
= (u32
*) hash_buf
->digest
;
13857 salt_t
*salt
= hash_buf
->salt
;
13863 char *hashbuf_pos
= input_buf
;
13865 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13867 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13869 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13871 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13875 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13877 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13879 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13881 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13883 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13887 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13889 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13891 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13893 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13895 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13899 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13901 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13902 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13904 // ok, the plan for this algorithm is the following:
13905 // we have 2 salts here, the domain-name and a random salt
13906 // while both are used in the initial transformation,
13907 // only the random salt is used in the following iterations
13908 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13909 // and one that includes only the real salt (stored into salt_buf[]).
13910 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13912 u8 tmp_buf
[100] = { 0 };
13914 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
13916 memcpy (digest
, tmp_buf
, 20);
13918 digest
[0] = byte_swap_32 (digest
[0]);
13919 digest
[1] = byte_swap_32 (digest
[1]);
13920 digest
[2] = byte_swap_32 (digest
[2]);
13921 digest
[3] = byte_swap_32 (digest
[3]);
13922 digest
[4] = byte_swap_32 (digest
[4]);
13926 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13928 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13930 char *len_ptr
= NULL
;
13932 for (uint i
= 0; i
< domainbuf_len
; i
++)
13934 if (salt_buf_pc_ptr
[i
] == '.')
13936 len_ptr
= &salt_buf_pc_ptr
[i
];
13946 salt
->salt_buf_pc
[7] = domainbuf_len
;
13950 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13952 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13954 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13956 salt
->salt_len
= salt_len
;
13960 salt
->salt_iter
= atoi (iteration_pos
);
13962 return (PARSER_OK
);
13965 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13967 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13969 u32
*digest
= (u32
*) hash_buf
->digest
;
13971 salt_t
*salt
= hash_buf
->salt
;
13973 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13974 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13975 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13976 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13977 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13979 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13981 uint salt_len
= input_len
- 40 - 1;
13983 char *salt_buf
= input_buf
+ 40 + 1;
13985 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13987 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13989 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13991 salt
->salt_len
= salt_len
;
13993 return (PARSER_OK
);
13996 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13998 const u8 ascii_to_ebcdic
[] =
14000 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14001 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14002 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14003 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14004 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14005 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14006 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14007 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14008 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14009 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14010 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14011 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14012 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14013 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14014 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14015 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14018 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14020 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14022 u32
*digest
= (u32
*) hash_buf
->digest
;
14024 salt_t
*salt
= hash_buf
->salt
;
14026 char *salt_pos
= input_buf
+ 6 + 1;
14028 char *digest_pos
= strchr (salt_pos
, '*');
14030 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14032 uint salt_len
= digest_pos
- salt_pos
;
14034 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14036 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14038 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14042 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14043 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14045 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14047 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14049 salt
->salt_len
= salt_len
;
14051 for (uint i
= 0; i
< salt_len
; i
++)
14053 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14055 for (uint i
= salt_len
; i
< 8; i
++)
14057 salt_buf_pc_ptr
[i
] = 0x40;
14062 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14064 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14065 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14067 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14068 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14070 digest
[0] = byte_swap_32 (digest
[0]);
14071 digest
[1] = byte_swap_32 (digest
[1]);
14073 IP (digest
[0], digest
[1], tt
);
14075 digest
[0] = rotr32 (digest
[0], 29);
14076 digest
[1] = rotr32 (digest
[1], 29);
14080 return (PARSER_OK
);
14083 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14085 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14087 u32
*digest
= (u32
*) hash_buf
->digest
;
14089 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14090 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14091 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14092 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14094 digest
[0] = byte_swap_32 (digest
[0]);
14095 digest
[1] = byte_swap_32 (digest
[1]);
14096 digest
[2] = byte_swap_32 (digest
[2]);
14097 digest
[3] = byte_swap_32 (digest
[3]);
14099 return (PARSER_OK
);
14102 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14104 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14106 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14108 u32
*digest
= (u32
*) hash_buf
->digest
;
14110 salt_t
*salt
= hash_buf
->salt
;
14112 u8 tmp_buf
[120] = { 0 };
14114 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14116 tmp_buf
[3] += -4; // dont ask!
14118 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14120 salt
->salt_len
= 5;
14122 memcpy (digest
, tmp_buf
+ 5, 9);
14124 // yes, only 9 byte are needed to crack, but 10 to display
14126 salt
->salt_buf_pc
[7] = input_buf
[20];
14128 return (PARSER_OK
);
14131 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14133 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14135 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14137 u32
*digest
= (u32
*) hash_buf
->digest
;
14139 salt_t
*salt
= hash_buf
->salt
;
14141 u8 tmp_buf
[120] = { 0 };
14143 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14145 tmp_buf
[3] += -4; // dont ask!
14149 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14151 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)
14155 char tmp_iter_buf
[11] = { 0 };
14157 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14159 tmp_iter_buf
[10] = 0;
14161 salt
->salt_iter
= atoi (tmp_iter_buf
);
14163 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14165 return (PARSER_SALT_ITERATION
);
14168 salt
->salt_iter
--; // first round in init
14170 // 2 additional bytes for display only
14172 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14173 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14177 memcpy (digest
, tmp_buf
+ 28, 8);
14179 digest
[0] = byte_swap_32 (digest
[0]);
14180 digest
[1] = byte_swap_32 (digest
[1]);
14184 return (PARSER_OK
);
14187 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14189 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14191 u32
*digest
= (u32
*) hash_buf
->digest
;
14193 salt_t
*salt
= hash_buf
->salt
;
14195 char *salt_buf_pos
= input_buf
;
14197 char *hash_buf_pos
= salt_buf_pos
+ 6;
14199 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14200 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14201 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14202 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14203 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14204 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14205 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14206 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14208 digest
[0] -= SHA256M_A
;
14209 digest
[1] -= SHA256M_B
;
14210 digest
[2] -= SHA256M_C
;
14211 digest
[3] -= SHA256M_D
;
14212 digest
[4] -= SHA256M_E
;
14213 digest
[5] -= SHA256M_F
;
14214 digest
[6] -= SHA256M_G
;
14215 digest
[7] -= SHA256M_H
;
14217 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14219 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14221 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14223 salt
->salt_len
= salt_len
;
14225 return (PARSER_OK
);
14228 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14230 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14232 u32
*digest
= (u32
*) hash_buf
->digest
;
14234 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14236 salt_t
*salt
= hash_buf
->salt
;
14238 char *salt_buf
= input_buf
+ 6;
14240 char *digest_buf
= strchr (salt_buf
, '$');
14242 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14244 uint salt_len
= digest_buf
- salt_buf
;
14246 digest_buf
++; // skip the '$' symbol
14248 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14250 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14252 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14254 salt
->salt_len
= salt_len
;
14256 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14257 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14258 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14259 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14261 digest
[0] = byte_swap_32 (digest
[0]);
14262 digest
[1] = byte_swap_32 (digest
[1]);
14263 digest
[2] = byte_swap_32 (digest
[2]);
14264 digest
[3] = byte_swap_32 (digest
[3]);
14266 digest
[0] -= MD5M_A
;
14267 digest
[1] -= MD5M_B
;
14268 digest
[2] -= MD5M_C
;
14269 digest
[3] -= MD5M_D
;
14271 return (PARSER_OK
);
14274 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14276 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14278 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14280 u32
*digest
= (u32
*) hash_buf
->digest
;
14282 salt_t
*salt
= hash_buf
->salt
;
14284 char *salt_buf
= input_buf
+ 3;
14286 char *digest_buf
= strchr (salt_buf
, '$');
14288 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14290 uint salt_len
= digest_buf
- salt_buf
;
14292 digest_buf
++; // skip the '$' symbol
14294 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14296 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14298 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14300 salt_buf_ptr
[salt_len
] = 0x2d;
14302 salt
->salt_len
= salt_len
+ 1;
14304 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14305 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14306 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14307 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14309 digest
[0] = byte_swap_32 (digest
[0]);
14310 digest
[1] = byte_swap_32 (digest
[1]);
14311 digest
[2] = byte_swap_32 (digest
[2]);
14312 digest
[3] = byte_swap_32 (digest
[3]);
14314 digest
[0] -= MD5M_A
;
14315 digest
[1] -= MD5M_B
;
14316 digest
[2] -= MD5M_C
;
14317 digest
[3] -= MD5M_D
;
14319 return (PARSER_OK
);
14322 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14324 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14326 u32
*digest
= (u32
*) hash_buf
->digest
;
14328 u8 tmp_buf
[100] = { 0 };
14330 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14332 memcpy (digest
, tmp_buf
, 20);
14334 digest
[0] = byte_swap_32 (digest
[0]);
14335 digest
[1] = byte_swap_32 (digest
[1]);
14336 digest
[2] = byte_swap_32 (digest
[2]);
14337 digest
[3] = byte_swap_32 (digest
[3]);
14338 digest
[4] = byte_swap_32 (digest
[4]);
14340 digest
[0] -= SHA1M_A
;
14341 digest
[1] -= SHA1M_B
;
14342 digest
[2] -= SHA1M_C
;
14343 digest
[3] -= SHA1M_D
;
14344 digest
[4] -= SHA1M_E
;
14346 return (PARSER_OK
);
14349 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14351 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14353 u32
*digest
= (u32
*) hash_buf
->digest
;
14355 salt_t
*salt
= hash_buf
->salt
;
14357 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14358 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14359 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14360 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14362 digest
[0] = byte_swap_32 (digest
[0]);
14363 digest
[1] = byte_swap_32 (digest
[1]);
14364 digest
[2] = byte_swap_32 (digest
[2]);
14365 digest
[3] = byte_swap_32 (digest
[3]);
14367 digest
[0] -= MD5M_A
;
14368 digest
[1] -= MD5M_B
;
14369 digest
[2] -= MD5M_C
;
14370 digest
[3] -= MD5M_D
;
14372 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14374 uint salt_len
= input_len
- 32 - 1;
14376 char *salt_buf
= input_buf
+ 32 + 1;
14378 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14380 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14382 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14385 * add static "salt" part
14388 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14392 salt
->salt_len
= salt_len
;
14394 return (PARSER_OK
);
14397 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14399 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14401 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14403 u32
*digest
= (u32
*) hash_buf
->digest
;
14405 salt_t
*salt
= hash_buf
->salt
;
14407 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14413 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14415 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14417 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14419 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14421 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14425 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14427 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14429 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14431 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14435 char *keybuf_pos
= strchr (keylen_pos
, '$');
14437 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14439 uint keylen_len
= keybuf_pos
- keylen_pos
;
14441 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14445 char *databuf_pos
= strchr (keybuf_pos
, '$');
14447 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14449 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14451 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14455 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14457 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14463 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14464 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14465 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14466 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14468 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14469 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14470 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14471 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14473 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14474 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14475 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14476 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14478 salt
->salt_len
= 16;
14479 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14481 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14483 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14486 return (PARSER_OK
);
14489 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14491 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14493 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14495 u32
*digest
= (u32
*) hash_buf
->digest
;
14497 salt_t
*salt
= hash_buf
->salt
;
14503 // first is the N salt parameter
14505 char *N_pos
= input_buf
+ 6;
14507 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14511 salt
->scrypt_N
= atoi (N_pos
);
14515 char *r_pos
= strchr (N_pos
, ':');
14517 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14521 salt
->scrypt_r
= atoi (r_pos
);
14525 char *p_pos
= strchr (r_pos
, ':');
14527 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14531 salt
->scrypt_p
= atoi (p_pos
);
14535 char *saltbuf_pos
= strchr (p_pos
, ':');
14537 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14541 char *hash_pos
= strchr (saltbuf_pos
, ':');
14543 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14549 u8 tmp_buf
[33] = { 0 };
14551 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14553 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14555 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14557 salt
->salt_len
= tmp_len
;
14558 salt
->salt_iter
= 1;
14560 // digest - base64 decode
14562 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14564 tmp_len
= input_len
- (hash_pos
- input_buf
);
14566 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14568 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14570 memcpy (digest
, tmp_buf
, 32);
14572 return (PARSER_OK
);
14575 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14577 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14579 u32
*digest
= (u32
*) hash_buf
->digest
;
14581 salt_t
*salt
= hash_buf
->salt
;
14587 char decrypted
[76] = { 0 }; // iv + hash
14589 juniper_decrypt_hash (input_buf
, decrypted
);
14591 char *md5crypt_hash
= decrypted
+ 12;
14593 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14595 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14597 char *salt_pos
= md5crypt_hash
+ 3;
14599 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14601 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14603 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14607 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14609 return (PARSER_OK
);
14612 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14614 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14616 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14618 u32
*digest
= (u32
*) hash_buf
->digest
;
14620 salt_t
*salt
= hash_buf
->salt
;
14622 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14628 // first is *raw* salt
14630 char *salt_pos
= input_buf
+ 3;
14632 char *hash_pos
= strchr (salt_pos
, '$');
14634 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14636 uint salt_len
= hash_pos
- salt_pos
;
14638 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14642 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14644 memcpy (salt_buf_ptr
, salt_pos
, 14);
14646 salt_buf_ptr
[17] = 0x01;
14647 salt_buf_ptr
[18] = 0x80;
14649 // add some stuff to normal salt to make sorted happy
14651 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14652 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14653 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14654 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14656 salt
->salt_len
= salt_len
;
14657 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14659 // base64 decode hash
14661 u8 tmp_buf
[100] = { 0 };
14663 uint hash_len
= input_len
- 3 - salt_len
- 1;
14665 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14667 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14669 memcpy (digest
, tmp_buf
, 32);
14671 digest
[0] = byte_swap_32 (digest
[0]);
14672 digest
[1] = byte_swap_32 (digest
[1]);
14673 digest
[2] = byte_swap_32 (digest
[2]);
14674 digest
[3] = byte_swap_32 (digest
[3]);
14675 digest
[4] = byte_swap_32 (digest
[4]);
14676 digest
[5] = byte_swap_32 (digest
[5]);
14677 digest
[6] = byte_swap_32 (digest
[6]);
14678 digest
[7] = byte_swap_32 (digest
[7]);
14680 return (PARSER_OK
);
14683 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14685 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14687 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14689 u32
*digest
= (u32
*) hash_buf
->digest
;
14691 salt_t
*salt
= hash_buf
->salt
;
14697 // first is *raw* salt
14699 char *salt_pos
= input_buf
+ 3;
14701 char *hash_pos
= strchr (salt_pos
, '$');
14703 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14705 uint salt_len
= hash_pos
- salt_pos
;
14707 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14709 salt
->salt_len
= salt_len
;
14712 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14714 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14715 salt_buf_ptr
[salt_len
] = 0;
14717 // base64 decode hash
14719 u8 tmp_buf
[100] = { 0 };
14721 uint hash_len
= input_len
- 3 - salt_len
- 1;
14723 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14725 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14727 memcpy (digest
, tmp_buf
, 32);
14730 salt
->scrypt_N
= 16384;
14731 salt
->scrypt_r
= 1;
14732 salt
->scrypt_p
= 1;
14733 salt
->salt_iter
= 1;
14735 return (PARSER_OK
);
14738 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14740 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14742 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14744 u32
*digest
= (u32
*) hash_buf
->digest
;
14746 salt_t
*salt
= hash_buf
->salt
;
14748 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14754 char *version_pos
= input_buf
+ 8 + 1;
14756 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14758 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14760 u32 version_len
= verifierHashSize_pos
- version_pos
;
14762 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14764 verifierHashSize_pos
++;
14766 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14768 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14770 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14772 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14776 char *saltSize_pos
= strchr (keySize_pos
, '*');
14778 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14780 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14782 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14786 char *osalt_pos
= strchr (saltSize_pos
, '*');
14788 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14790 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14792 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14796 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14798 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14800 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14802 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14804 encryptedVerifier_pos
++;
14806 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14808 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14810 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14812 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14814 encryptedVerifierHash_pos
++;
14816 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;
14818 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14820 const uint version
= atoi (version_pos
);
14822 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14824 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14826 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14828 const uint keySize
= atoi (keySize_pos
);
14830 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14832 office2007
->keySize
= keySize
;
14834 const uint saltSize
= atoi (saltSize_pos
);
14836 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14842 salt
->salt_len
= 16;
14843 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14845 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14846 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14847 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14848 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14854 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14855 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14856 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14857 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14859 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14860 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14861 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14862 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14863 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14869 digest
[0] = office2007
->encryptedVerifierHash
[0];
14870 digest
[1] = office2007
->encryptedVerifierHash
[1];
14871 digest
[2] = office2007
->encryptedVerifierHash
[2];
14872 digest
[3] = office2007
->encryptedVerifierHash
[3];
14874 return (PARSER_OK
);
14877 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14879 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14881 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14883 u32
*digest
= (u32
*) hash_buf
->digest
;
14885 salt_t
*salt
= hash_buf
->salt
;
14887 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14893 char *version_pos
= input_buf
+ 8 + 1;
14895 char *spinCount_pos
= strchr (version_pos
, '*');
14897 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14899 u32 version_len
= spinCount_pos
- version_pos
;
14901 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14905 char *keySize_pos
= strchr (spinCount_pos
, '*');
14907 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14909 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
14911 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14915 char *saltSize_pos
= strchr (keySize_pos
, '*');
14917 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14919 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14921 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14925 char *osalt_pos
= strchr (saltSize_pos
, '*');
14927 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14929 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14931 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14935 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14937 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14939 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14941 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14943 encryptedVerifier_pos
++;
14945 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14947 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14949 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14951 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14953 encryptedVerifierHash_pos
++;
14955 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;
14957 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14959 const uint version
= atoi (version_pos
);
14961 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14963 const uint spinCount
= atoi (spinCount_pos
);
14965 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14967 const uint keySize
= atoi (keySize_pos
);
14969 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14971 const uint saltSize
= atoi (saltSize_pos
);
14973 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14979 salt
->salt_len
= 16;
14980 salt
->salt_iter
= spinCount
;
14982 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14983 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14984 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14985 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14991 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14992 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14993 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14994 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14996 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14997 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14998 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14999 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15000 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15001 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15002 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15003 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15009 digest
[0] = office2010
->encryptedVerifierHash
[0];
15010 digest
[1] = office2010
->encryptedVerifierHash
[1];
15011 digest
[2] = office2010
->encryptedVerifierHash
[2];
15012 digest
[3] = office2010
->encryptedVerifierHash
[3];
15014 return (PARSER_OK
);
15017 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15019 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15021 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15023 u32
*digest
= (u32
*) hash_buf
->digest
;
15025 salt_t
*salt
= hash_buf
->salt
;
15027 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15033 char *version_pos
= input_buf
+ 8 + 1;
15035 char *spinCount_pos
= strchr (version_pos
, '*');
15037 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15039 u32 version_len
= spinCount_pos
- version_pos
;
15041 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15045 char *keySize_pos
= strchr (spinCount_pos
, '*');
15047 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15049 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15051 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15055 char *saltSize_pos
= strchr (keySize_pos
, '*');
15057 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15059 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15061 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15065 char *osalt_pos
= strchr (saltSize_pos
, '*');
15067 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15069 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15071 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15075 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15077 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15079 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15081 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15083 encryptedVerifier_pos
++;
15085 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15087 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15089 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15091 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15093 encryptedVerifierHash_pos
++;
15095 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;
15097 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15099 const uint version
= atoi (version_pos
);
15101 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15103 const uint spinCount
= atoi (spinCount_pos
);
15105 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15107 const uint keySize
= atoi (keySize_pos
);
15109 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15111 const uint saltSize
= atoi (saltSize_pos
);
15113 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15119 salt
->salt_len
= 16;
15120 salt
->salt_iter
= spinCount
;
15122 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15123 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15124 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15125 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15131 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15132 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15133 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15134 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15136 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15137 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15138 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15139 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15140 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15141 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15142 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15143 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15149 digest
[0] = office2013
->encryptedVerifierHash
[0];
15150 digest
[1] = office2013
->encryptedVerifierHash
[1];
15151 digest
[2] = office2013
->encryptedVerifierHash
[2];
15152 digest
[3] = office2013
->encryptedVerifierHash
[3];
15154 return (PARSER_OK
);
15157 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15159 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15161 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15163 u32
*digest
= (u32
*) hash_buf
->digest
;
15165 salt_t
*salt
= hash_buf
->salt
;
15167 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15173 char *version_pos
= input_buf
+ 11;
15175 char *osalt_pos
= strchr (version_pos
, '*');
15177 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15179 u32 version_len
= osalt_pos
- version_pos
;
15181 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15185 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15187 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15189 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15191 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15193 encryptedVerifier_pos
++;
15195 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15197 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15199 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15201 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15203 encryptedVerifierHash_pos
++;
15205 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15207 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15209 const uint version
= *version_pos
- 0x30;
15211 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15217 oldoffice01
->version
= version
;
15219 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15220 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15221 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15222 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15224 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15225 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15226 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15227 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15229 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15230 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15231 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15232 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15234 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15235 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15236 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15237 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15243 salt
->salt_len
= 16;
15245 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15246 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15247 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15248 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15250 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15251 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15252 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15253 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15255 // this is a workaround as office produces multiple documents with the same salt
15257 salt
->salt_len
+= 32;
15259 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15260 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15261 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15262 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15263 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15264 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15265 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15266 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15272 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15273 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15274 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15275 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15277 return (PARSER_OK
);
15280 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15282 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15285 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15287 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15289 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15291 u32
*digest
= (u32
*) hash_buf
->digest
;
15293 salt_t
*salt
= hash_buf
->salt
;
15295 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15301 char *version_pos
= input_buf
+ 11;
15303 char *osalt_pos
= strchr (version_pos
, '*');
15305 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15307 u32 version_len
= osalt_pos
- version_pos
;
15309 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15313 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15315 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15317 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15319 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15321 encryptedVerifier_pos
++;
15323 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15325 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15327 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15329 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15331 encryptedVerifierHash_pos
++;
15333 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15335 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15337 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15339 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15343 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15345 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15347 const uint version
= *version_pos
- 0x30;
15349 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15355 oldoffice01
->version
= version
;
15357 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15358 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15359 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15360 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15362 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15363 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15364 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15365 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15367 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15368 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15369 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15370 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15372 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15373 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15374 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15375 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15377 oldoffice01
->rc4key
[1] = 0;
15378 oldoffice01
->rc4key
[0] = 0;
15380 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15381 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15382 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15383 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15384 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15385 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15386 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15387 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15388 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15389 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15391 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15392 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15398 salt
->salt_len
= 16;
15400 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15401 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15402 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15403 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15405 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15406 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15407 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15408 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15410 // this is a workaround as office produces multiple documents with the same salt
15412 salt
->salt_len
+= 32;
15414 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15415 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15416 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15417 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15418 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15419 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15420 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15421 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15427 digest
[0] = oldoffice01
->rc4key
[0];
15428 digest
[1] = oldoffice01
->rc4key
[1];
15432 return (PARSER_OK
);
15435 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15437 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15439 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15441 u32
*digest
= (u32
*) hash_buf
->digest
;
15443 salt_t
*salt
= hash_buf
->salt
;
15445 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15451 char *version_pos
= input_buf
+ 11;
15453 char *osalt_pos
= strchr (version_pos
, '*');
15455 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15457 u32 version_len
= osalt_pos
- version_pos
;
15459 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15463 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15465 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15467 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15469 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15471 encryptedVerifier_pos
++;
15473 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15475 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15477 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15479 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15481 encryptedVerifierHash_pos
++;
15483 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15485 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15487 const uint version
= *version_pos
- 0x30;
15489 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15495 oldoffice34
->version
= version
;
15497 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15498 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15499 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15500 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15502 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15503 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15504 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15505 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15507 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15508 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15509 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15510 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15511 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15513 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15514 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15515 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15516 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15517 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15523 salt
->salt_len
= 16;
15525 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15526 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15527 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15528 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15530 // this is a workaround as office produces multiple documents with the same salt
15532 salt
->salt_len
+= 32;
15534 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15535 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15536 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15537 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15538 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15539 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15540 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15541 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15547 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15548 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15549 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15550 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15552 return (PARSER_OK
);
15555 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15557 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15559 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15562 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15564 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15566 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15568 u32
*digest
= (u32
*) hash_buf
->digest
;
15570 salt_t
*salt
= hash_buf
->salt
;
15572 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15578 char *version_pos
= input_buf
+ 11;
15580 char *osalt_pos
= strchr (version_pos
, '*');
15582 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15584 u32 version_len
= osalt_pos
- version_pos
;
15586 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15590 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15592 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15594 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15596 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15598 encryptedVerifier_pos
++;
15600 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15602 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15604 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15606 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15608 encryptedVerifierHash_pos
++;
15610 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15612 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15614 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15616 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15620 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15622 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15624 const uint version
= *version_pos
- 0x30;
15626 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15632 oldoffice34
->version
= version
;
15634 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15635 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15636 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15637 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15639 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15640 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15641 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15642 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15644 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15645 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15646 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15647 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15648 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15650 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15651 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15652 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15653 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15654 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15656 oldoffice34
->rc4key
[1] = 0;
15657 oldoffice34
->rc4key
[0] = 0;
15659 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15660 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15661 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15662 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15663 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15664 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15665 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15666 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15667 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15668 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15670 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15671 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15677 salt
->salt_len
= 16;
15679 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15680 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15681 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15682 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15684 // this is a workaround as office produces multiple documents with the same salt
15686 salt
->salt_len
+= 32;
15688 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15689 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15690 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15691 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15692 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15693 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15694 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15695 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15701 digest
[0] = oldoffice34
->rc4key
[0];
15702 digest
[1] = oldoffice34
->rc4key
[1];
15706 return (PARSER_OK
);
15709 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15711 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15713 u32
*digest
= (u32
*) hash_buf
->digest
;
15715 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15716 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15717 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15718 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15720 digest
[0] = byte_swap_32 (digest
[0]);
15721 digest
[1] = byte_swap_32 (digest
[1]);
15722 digest
[2] = byte_swap_32 (digest
[2]);
15723 digest
[3] = byte_swap_32 (digest
[3]);
15725 return (PARSER_OK
);
15728 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15730 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15732 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15734 u32
*digest
= (u32
*) hash_buf
->digest
;
15736 salt_t
*salt
= hash_buf
->salt
;
15738 char *signature_pos
= input_buf
;
15740 char *salt_pos
= strchr (signature_pos
, '$');
15742 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15744 u32 signature_len
= salt_pos
- signature_pos
;
15746 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15750 char *hash_pos
= strchr (salt_pos
, '$');
15752 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15754 u32 salt_len
= hash_pos
- salt_pos
;
15756 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15760 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15762 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15764 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15765 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15766 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15767 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15768 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15770 digest
[0] -= SHA1M_A
;
15771 digest
[1] -= SHA1M_B
;
15772 digest
[2] -= SHA1M_C
;
15773 digest
[3] -= SHA1M_D
;
15774 digest
[4] -= SHA1M_E
;
15776 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15778 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15780 salt
->salt_len
= salt_len
;
15782 return (PARSER_OK
);
15785 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15787 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15789 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15791 u32
*digest
= (u32
*) hash_buf
->digest
;
15793 salt_t
*salt
= hash_buf
->salt
;
15795 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15801 char *iter_pos
= input_buf
+ 14;
15803 const int iter
= atoi (iter_pos
);
15805 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15807 salt
->salt_iter
= iter
- 1;
15809 char *salt_pos
= strchr (iter_pos
, '$');
15811 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15815 char *hash_pos
= strchr (salt_pos
, '$');
15817 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15819 const uint salt_len
= hash_pos
- salt_pos
;
15823 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15825 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15827 salt
->salt_len
= salt_len
;
15829 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15830 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15832 // add some stuff to normal salt to make sorted happy
15834 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15835 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15836 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15837 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15838 salt
->salt_buf
[4] = salt
->salt_iter
;
15840 // base64 decode hash
15842 u8 tmp_buf
[100] = { 0 };
15844 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15846 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15848 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15850 memcpy (digest
, tmp_buf
, 32);
15852 digest
[0] = byte_swap_32 (digest
[0]);
15853 digest
[1] = byte_swap_32 (digest
[1]);
15854 digest
[2] = byte_swap_32 (digest
[2]);
15855 digest
[3] = byte_swap_32 (digest
[3]);
15856 digest
[4] = byte_swap_32 (digest
[4]);
15857 digest
[5] = byte_swap_32 (digest
[5]);
15858 digest
[6] = byte_swap_32 (digest
[6]);
15859 digest
[7] = byte_swap_32 (digest
[7]);
15861 return (PARSER_OK
);
15864 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15866 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15868 u32
*digest
= (u32
*) hash_buf
->digest
;
15870 salt_t
*salt
= hash_buf
->salt
;
15872 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15873 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15877 digest
[0] = byte_swap_32 (digest
[0]);
15878 digest
[1] = byte_swap_32 (digest
[1]);
15880 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15881 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15882 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15884 char iter_c
= input_buf
[17];
15885 char iter_d
= input_buf
[19];
15887 // atm only defaults, let's see if there's more request
15888 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15889 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15891 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15893 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15894 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15895 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15896 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15898 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15899 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15900 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15901 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15903 salt
->salt_len
= 16;
15905 return (PARSER_OK
);
15908 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15910 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15912 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15914 u32
*digest
= (u32
*) hash_buf
->digest
;
15916 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15918 salt_t
*salt
= hash_buf
->salt
;
15920 char *salt_pos
= input_buf
+ 10;
15922 char *hash_pos
= strchr (salt_pos
, '$');
15924 uint salt_len
= hash_pos
- salt_pos
;
15926 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15930 uint hash_len
= input_len
- 10 - salt_len
- 1;
15932 // base64 decode salt
15934 u8 tmp_buf
[100] = { 0 };
15936 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
15938 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15940 tmp_buf
[salt_len
] = 0x80;
15942 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15944 salt
->salt_len
= salt_len
;
15946 // base64 decode salt
15948 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15950 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15952 uint user_len
= hash_len
- 32;
15954 const u8
*tmp_hash
= tmp_buf
+ user_len
;
15956 user_len
--; // skip the trailing space
15958 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
15959 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
15960 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
15961 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
15963 digest
[0] = byte_swap_32 (digest
[0]);
15964 digest
[1] = byte_swap_32 (digest
[1]);
15965 digest
[2] = byte_swap_32 (digest
[2]);
15966 digest
[3] = byte_swap_32 (digest
[3]);
15968 // store username for host only (output hash if cracked)
15970 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15971 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15973 return (PARSER_OK
);
15976 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15978 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15980 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15982 u32
*digest
= (u32
*) hash_buf
->digest
;
15984 salt_t
*salt
= hash_buf
->salt
;
15986 char *iter_pos
= input_buf
+ 10;
15988 u32 iter
= atoi (iter_pos
);
15992 return (PARSER_SALT_ITERATION
);
15995 iter
--; // first iteration is special
15997 salt
->salt_iter
= iter
;
15999 char *base64_pos
= strchr (iter_pos
, '}');
16001 if (base64_pos
== NULL
)
16003 return (PARSER_SIGNATURE_UNMATCHED
);
16008 // base64 decode salt
16010 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16012 u8 tmp_buf
[100] = { 0 };
16014 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16016 if (decoded_len
< 24)
16018 return (PARSER_SALT_LENGTH
);
16023 uint salt_len
= decoded_len
- 20;
16025 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16026 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16028 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16030 salt
->salt_len
= salt_len
;
16034 u32
*digest_ptr
= (u32
*) tmp_buf
;
16036 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16037 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16038 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16039 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16040 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16042 return (PARSER_OK
);
16045 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16047 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16049 u32
*digest
= (u32
*) hash_buf
->digest
;
16051 salt_t
*salt
= hash_buf
->salt
;
16053 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16054 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16055 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16056 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16057 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16059 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16061 uint salt_len
= input_len
- 40 - 1;
16063 char *salt_buf
= input_buf
+ 40 + 1;
16065 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16067 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16069 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16071 salt
->salt_len
= salt_len
;
16073 return (PARSER_OK
);
16076 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16078 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16080 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16082 u32
*digest
= (u32
*) hash_buf
->digest
;
16084 salt_t
*salt
= hash_buf
->salt
;
16086 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16092 char *V_pos
= input_buf
+ 5;
16094 char *R_pos
= strchr (V_pos
, '*');
16096 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16098 u32 V_len
= R_pos
- V_pos
;
16102 char *bits_pos
= strchr (R_pos
, '*');
16104 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16106 u32 R_len
= bits_pos
- R_pos
;
16110 char *P_pos
= strchr (bits_pos
, '*');
16112 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16114 u32 bits_len
= P_pos
- bits_pos
;
16118 char *enc_md_pos
= strchr (P_pos
, '*');
16120 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16122 u32 P_len
= enc_md_pos
- P_pos
;
16126 char *id_len_pos
= strchr (enc_md_pos
, '*');
16128 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16130 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16134 char *id_buf_pos
= strchr (id_len_pos
, '*');
16136 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16138 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16142 char *u_len_pos
= strchr (id_buf_pos
, '*');
16144 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16146 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16148 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16152 char *u_buf_pos
= strchr (u_len_pos
, '*');
16154 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16156 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16160 char *o_len_pos
= strchr (u_buf_pos
, '*');
16162 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16164 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16166 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16170 char *o_buf_pos
= strchr (o_len_pos
, '*');
16172 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16174 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16178 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;
16180 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16184 const int V
= atoi (V_pos
);
16185 const int R
= atoi (R_pos
);
16186 const int P
= atoi (P_pos
);
16188 if (V
!= 1) return (PARSER_SALT_VALUE
);
16189 if (R
!= 2) return (PARSER_SALT_VALUE
);
16191 const int enc_md
= atoi (enc_md_pos
);
16193 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16195 const int id_len
= atoi (id_len_pos
);
16196 const int u_len
= atoi (u_len_pos
);
16197 const int o_len
= atoi (o_len_pos
);
16199 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16200 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16201 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16203 const int bits
= atoi (bits_pos
);
16205 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16207 // copy data to esalt
16213 pdf
->enc_md
= enc_md
;
16215 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16216 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16217 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16218 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16219 pdf
->id_len
= id_len
;
16221 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16222 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16223 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16224 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16225 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16226 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16227 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16228 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16229 pdf
->u_len
= u_len
;
16231 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16232 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16233 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16234 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16235 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16236 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16237 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16238 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16239 pdf
->o_len
= o_len
;
16241 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16242 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16243 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16244 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16246 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16247 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16248 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16249 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16250 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16251 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16252 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16253 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16255 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16256 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16257 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16258 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16259 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16260 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16261 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16262 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16264 // we use ID for salt, maybe needs to change, we will see...
16266 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16267 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16268 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16269 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16270 salt
->salt_len
= pdf
->id_len
;
16272 digest
[0] = pdf
->u_buf
[0];
16273 digest
[1] = pdf
->u_buf
[1];
16274 digest
[2] = pdf
->u_buf
[2];
16275 digest
[3] = pdf
->u_buf
[3];
16277 return (PARSER_OK
);
16280 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16282 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16285 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16287 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16289 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16291 u32
*digest
= (u32
*) hash_buf
->digest
;
16293 salt_t
*salt
= hash_buf
->salt
;
16295 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16301 char *V_pos
= input_buf
+ 5;
16303 char *R_pos
= strchr (V_pos
, '*');
16305 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16307 u32 V_len
= R_pos
- V_pos
;
16311 char *bits_pos
= strchr (R_pos
, '*');
16313 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16315 u32 R_len
= bits_pos
- R_pos
;
16319 char *P_pos
= strchr (bits_pos
, '*');
16321 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16323 u32 bits_len
= P_pos
- bits_pos
;
16327 char *enc_md_pos
= strchr (P_pos
, '*');
16329 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16331 u32 P_len
= enc_md_pos
- P_pos
;
16335 char *id_len_pos
= strchr (enc_md_pos
, '*');
16337 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16339 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16343 char *id_buf_pos
= strchr (id_len_pos
, '*');
16345 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16347 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16351 char *u_len_pos
= strchr (id_buf_pos
, '*');
16353 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16355 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16357 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16361 char *u_buf_pos
= strchr (u_len_pos
, '*');
16363 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16365 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16369 char *o_len_pos
= strchr (u_buf_pos
, '*');
16371 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16373 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16375 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16379 char *o_buf_pos
= strchr (o_len_pos
, '*');
16381 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16383 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16387 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16389 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16391 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16393 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16397 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;
16399 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16403 const int V
= atoi (V_pos
);
16404 const int R
= atoi (R_pos
);
16405 const int P
= atoi (P_pos
);
16407 if (V
!= 1) return (PARSER_SALT_VALUE
);
16408 if (R
!= 2) return (PARSER_SALT_VALUE
);
16410 const int enc_md
= atoi (enc_md_pos
);
16412 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16414 const int id_len
= atoi (id_len_pos
);
16415 const int u_len
= atoi (u_len_pos
);
16416 const int o_len
= atoi (o_len_pos
);
16418 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16419 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16420 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16422 const int bits
= atoi (bits_pos
);
16424 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16426 // copy data to esalt
16432 pdf
->enc_md
= enc_md
;
16434 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16435 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16436 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16437 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16438 pdf
->id_len
= id_len
;
16440 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16441 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16442 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16443 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16444 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16445 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16446 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16447 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16448 pdf
->u_len
= u_len
;
16450 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16451 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16452 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16453 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16454 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16455 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16456 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16457 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16458 pdf
->o_len
= o_len
;
16460 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16461 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16462 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16463 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16465 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16466 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16467 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16468 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16469 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16470 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16471 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16472 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16474 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16475 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16476 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16477 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16478 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16479 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16480 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16481 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16483 pdf
->rc4key
[1] = 0;
16484 pdf
->rc4key
[0] = 0;
16486 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16487 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16488 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16489 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16490 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16491 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16492 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16493 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16494 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16495 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16497 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16498 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16500 // we use ID for salt, maybe needs to change, we will see...
16502 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16503 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16504 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16505 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16506 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16507 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16508 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16509 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16510 salt
->salt_len
= pdf
->id_len
+ 16;
16512 digest
[0] = pdf
->rc4key
[0];
16513 digest
[1] = pdf
->rc4key
[1];
16517 return (PARSER_OK
);
16520 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16522 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16524 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16526 u32
*digest
= (u32
*) hash_buf
->digest
;
16528 salt_t
*salt
= hash_buf
->salt
;
16530 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16536 char *V_pos
= input_buf
+ 5;
16538 char *R_pos
= strchr (V_pos
, '*');
16540 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16542 u32 V_len
= R_pos
- V_pos
;
16546 char *bits_pos
= strchr (R_pos
, '*');
16548 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16550 u32 R_len
= bits_pos
- R_pos
;
16554 char *P_pos
= strchr (bits_pos
, '*');
16556 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16558 u32 bits_len
= P_pos
- bits_pos
;
16562 char *enc_md_pos
= strchr (P_pos
, '*');
16564 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16566 u32 P_len
= enc_md_pos
- P_pos
;
16570 char *id_len_pos
= strchr (enc_md_pos
, '*');
16572 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16574 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16578 char *id_buf_pos
= strchr (id_len_pos
, '*');
16580 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16582 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16586 char *u_len_pos
= strchr (id_buf_pos
, '*');
16588 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16590 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16592 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16596 char *u_buf_pos
= strchr (u_len_pos
, '*');
16598 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16600 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16604 char *o_len_pos
= strchr (u_buf_pos
, '*');
16606 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16608 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16610 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16614 char *o_buf_pos
= strchr (o_len_pos
, '*');
16616 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16618 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16622 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;
16624 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16628 const int V
= atoi (V_pos
);
16629 const int R
= atoi (R_pos
);
16630 const int P
= atoi (P_pos
);
16634 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16635 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16637 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16639 const int id_len
= atoi (id_len_pos
);
16640 const int u_len
= atoi (u_len_pos
);
16641 const int o_len
= atoi (o_len_pos
);
16643 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16645 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16646 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16648 const int bits
= atoi (bits_pos
);
16650 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16656 enc_md
= atoi (enc_md_pos
);
16659 // copy data to esalt
16665 pdf
->enc_md
= enc_md
;
16667 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16668 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16669 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16670 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16674 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16675 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16676 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16677 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16680 pdf
->id_len
= id_len
;
16682 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16683 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16684 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16685 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16686 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16687 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16688 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16689 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16690 pdf
->u_len
= u_len
;
16692 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16693 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16694 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16695 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16696 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16697 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16698 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16699 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16700 pdf
->o_len
= o_len
;
16702 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16703 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16704 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16705 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16709 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16710 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16711 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16712 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16715 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16716 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16717 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16718 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16719 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16720 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16721 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16722 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16724 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16725 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16726 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16727 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16728 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16729 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16730 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16731 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16733 // precompute rc4 data for later use
16749 uint salt_pc_block
[32] = { 0 };
16751 char *salt_pc_ptr
= (char *) salt_pc_block
;
16753 memcpy (salt_pc_ptr
, padding
, 32);
16754 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16756 uint salt_pc_digest
[4] = { 0 };
16758 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16760 pdf
->rc4data
[0] = salt_pc_digest
[0];
16761 pdf
->rc4data
[1] = salt_pc_digest
[1];
16763 // we use ID for salt, maybe needs to change, we will see...
16765 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16766 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16767 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16768 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16769 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16770 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16771 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16772 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16773 salt
->salt_len
= pdf
->id_len
+ 16;
16775 salt
->salt_iter
= ROUNDS_PDF14
;
16777 digest
[0] = pdf
->u_buf
[0];
16778 digest
[1] = pdf
->u_buf
[1];
16782 return (PARSER_OK
);
16785 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16787 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16789 if (ret
!= PARSER_OK
)
16794 u32
*digest
= (u32
*) hash_buf
->digest
;
16796 salt_t
*salt
= hash_buf
->salt
;
16798 digest
[0] -= SHA256M_A
;
16799 digest
[1] -= SHA256M_B
;
16800 digest
[2] -= SHA256M_C
;
16801 digest
[3] -= SHA256M_D
;
16802 digest
[4] -= SHA256M_E
;
16803 digest
[5] -= SHA256M_F
;
16804 digest
[6] -= SHA256M_G
;
16805 digest
[7] -= SHA256M_H
;
16807 salt
->salt_buf
[2] = 0x80;
16809 return (PARSER_OK
);
16812 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16814 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16816 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16818 u32
*digest
= (u32
*) hash_buf
->digest
;
16820 salt_t
*salt
= hash_buf
->salt
;
16822 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16828 char *V_pos
= input_buf
+ 5;
16830 char *R_pos
= strchr (V_pos
, '*');
16832 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16834 u32 V_len
= R_pos
- V_pos
;
16838 char *bits_pos
= strchr (R_pos
, '*');
16840 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16842 u32 R_len
= bits_pos
- R_pos
;
16846 char *P_pos
= strchr (bits_pos
, '*');
16848 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16850 u32 bits_len
= P_pos
- bits_pos
;
16854 char *enc_md_pos
= strchr (P_pos
, '*');
16856 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16858 u32 P_len
= enc_md_pos
- P_pos
;
16862 char *id_len_pos
= strchr (enc_md_pos
, '*');
16864 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16866 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16870 char *id_buf_pos
= strchr (id_len_pos
, '*');
16872 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16874 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16878 char *u_len_pos
= strchr (id_buf_pos
, '*');
16880 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16882 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16886 char *u_buf_pos
= strchr (u_len_pos
, '*');
16888 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16890 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16894 char *o_len_pos
= strchr (u_buf_pos
, '*');
16896 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16898 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16902 char *o_buf_pos
= strchr (o_len_pos
, '*');
16904 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16906 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16910 char *last
= strchr (o_buf_pos
, '*');
16912 if (last
== NULL
) last
= input_buf
+ input_len
;
16914 u32 o_buf_len
= last
- o_buf_pos
;
16918 const int V
= atoi (V_pos
);
16919 const int R
= atoi (R_pos
);
16923 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16924 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16926 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16928 const int bits
= atoi (bits_pos
);
16930 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16932 int enc_md
= atoi (enc_md_pos
);
16934 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16936 const uint id_len
= atoi (id_len_pos
);
16937 const uint u_len
= atoi (u_len_pos
);
16938 const uint o_len
= atoi (o_len_pos
);
16940 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16941 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16942 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16943 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16944 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16945 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16946 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16947 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16949 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16950 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16951 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16953 // copy data to esalt
16955 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16957 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16959 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
16962 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16963 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16965 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16966 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16968 salt
->salt_len
= 8;
16969 salt
->salt_iter
= ROUNDS_PDF17L8
;
16971 digest
[0] = pdf
->u_buf
[0];
16972 digest
[1] = pdf
->u_buf
[1];
16973 digest
[2] = pdf
->u_buf
[2];
16974 digest
[3] = pdf
->u_buf
[3];
16975 digest
[4] = pdf
->u_buf
[4];
16976 digest
[5] = pdf
->u_buf
[5];
16977 digest
[6] = pdf
->u_buf
[6];
16978 digest
[7] = pdf
->u_buf
[7];
16980 return (PARSER_OK
);
16983 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16985 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
16987 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
16989 u32
*digest
= (u32
*) hash_buf
->digest
;
16991 salt_t
*salt
= hash_buf
->salt
;
16993 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17001 char *iter_pos
= input_buf
+ 7;
17003 u32 iter
= atoi (iter_pos
);
17005 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17006 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17008 // first is *raw* salt
17010 char *salt_pos
= strchr (iter_pos
, ':');
17012 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17016 char *hash_pos
= strchr (salt_pos
, ':');
17018 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17020 u32 salt_len
= hash_pos
- salt_pos
;
17022 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17026 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17028 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17032 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17034 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17036 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17038 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17039 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17041 salt
->salt_len
= salt_len
;
17042 salt
->salt_iter
= iter
- 1;
17046 u8 tmp_buf
[100] = { 0 };
17048 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17050 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17052 memcpy (digest
, tmp_buf
, 16);
17054 digest
[0] = byte_swap_32 (digest
[0]);
17055 digest
[1] = byte_swap_32 (digest
[1]);
17056 digest
[2] = byte_swap_32 (digest
[2]);
17057 digest
[3] = byte_swap_32 (digest
[3]);
17059 // add some stuff to normal salt to make sorted happy
17061 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17062 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17063 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17064 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17065 salt
->salt_buf
[4] = salt
->salt_iter
;
17067 return (PARSER_OK
);
17070 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17072 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17074 u32
*digest
= (u32
*) hash_buf
->digest
;
17076 salt_t
*salt
= hash_buf
->salt
;
17078 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17079 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17080 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17081 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17083 digest
[0] = byte_swap_32 (digest
[0]);
17084 digest
[1] = byte_swap_32 (digest
[1]);
17085 digest
[2] = byte_swap_32 (digest
[2]);
17086 digest
[3] = byte_swap_32 (digest
[3]);
17088 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17090 uint salt_len
= input_len
- 32 - 1;
17092 char *salt_buf
= input_buf
+ 32 + 1;
17094 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17096 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17098 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17100 salt
->salt_len
= salt_len
;
17102 return (PARSER_OK
);
17105 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17107 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17109 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17111 u32
*digest
= (u32
*) hash_buf
->digest
;
17113 salt_t
*salt
= hash_buf
->salt
;
17115 char *user_pos
= input_buf
+ 10;
17117 char *salt_pos
= strchr (user_pos
, '*');
17119 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17123 char *hash_pos
= strchr (salt_pos
, '*');
17127 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17129 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17131 uint user_len
= salt_pos
- user_pos
- 1;
17133 uint salt_len
= hash_pos
- salt_pos
- 1;
17135 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17141 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17142 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17143 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17144 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17146 digest
[0] = byte_swap_32 (digest
[0]);
17147 digest
[1] = byte_swap_32 (digest
[1]);
17148 digest
[2] = byte_swap_32 (digest
[2]);
17149 digest
[3] = byte_swap_32 (digest
[3]);
17151 digest
[0] -= MD5M_A
;
17152 digest
[1] -= MD5M_B
;
17153 digest
[2] -= MD5M_C
;
17154 digest
[3] -= MD5M_D
;
17160 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17162 // first 4 bytes are the "challenge"
17164 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17165 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17166 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17167 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17169 // append the user name
17171 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17173 salt
->salt_len
= 4 + user_len
;
17175 return (PARSER_OK
);
17178 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17180 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17182 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17184 u32
*digest
= (u32
*) hash_buf
->digest
;
17186 salt_t
*salt
= hash_buf
->salt
;
17188 char *salt_pos
= input_buf
+ 9;
17190 char *hash_pos
= strchr (salt_pos
, '*');
17192 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17196 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17198 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17200 uint salt_len
= hash_pos
- salt_pos
- 1;
17202 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17208 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17209 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17210 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17211 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17212 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17218 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17220 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17222 salt
->salt_len
= salt_len
;
17224 return (PARSER_OK
);
17227 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17229 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17231 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17233 u32
*digest
= (u32
*) hash_buf
->digest
;
17235 salt_t
*salt
= hash_buf
->salt
;
17237 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17243 char *cry_master_len_pos
= input_buf
+ 9;
17245 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17247 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17249 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17251 cry_master_buf_pos
++;
17253 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17255 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17257 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17259 cry_salt_len_pos
++;
17261 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17263 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17265 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17267 cry_salt_buf_pos
++;
17269 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17271 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17273 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17277 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17279 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17281 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17285 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17287 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17289 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17293 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17295 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17297 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17299 public_key_len_pos
++;
17301 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17303 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17305 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17307 public_key_buf_pos
++;
17309 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;
17311 const uint cry_master_len
= atoi (cry_master_len_pos
);
17312 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17313 const uint ckey_len
= atoi (ckey_len_pos
);
17314 const uint public_key_len
= atoi (public_key_len_pos
);
17316 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17317 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17318 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17319 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17321 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17323 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17325 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17328 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17330 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17332 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17335 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17337 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17339 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17342 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17343 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17344 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17347 * store digest (should be unique enought, hopefully)
17350 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17351 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17352 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17353 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17359 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17361 const uint cry_rounds
= atoi (cry_rounds_pos
);
17363 salt
->salt_iter
= cry_rounds
- 1;
17365 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17367 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17369 salt
->salt_len
= salt_len
;
17371 return (PARSER_OK
);
17374 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17376 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17378 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17380 u32
*digest
= (u32
*) hash_buf
->digest
;
17382 salt_t
*salt
= hash_buf
->salt
;
17384 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17386 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17388 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17390 memcpy (temp_input_buf
, input_buf
, input_len
);
17394 char *URI_server_pos
= temp_input_buf
+ 6;
17396 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17398 if (URI_client_pos
== NULL
)
17400 myfree (temp_input_buf
);
17402 return (PARSER_SEPARATOR_UNMATCHED
);
17405 URI_client_pos
[0] = 0;
17408 uint URI_server_len
= strlen (URI_server_pos
);
17410 if (URI_server_len
> 512)
17412 myfree (temp_input_buf
);
17414 return (PARSER_SALT_LENGTH
);
17419 char *user_pos
= strchr (URI_client_pos
, '*');
17421 if (user_pos
== NULL
)
17423 myfree (temp_input_buf
);
17425 return (PARSER_SEPARATOR_UNMATCHED
);
17431 uint URI_client_len
= strlen (URI_client_pos
);
17433 if (URI_client_len
> 512)
17435 myfree (temp_input_buf
);
17437 return (PARSER_SALT_LENGTH
);
17442 char *realm_pos
= strchr (user_pos
, '*');
17444 if (realm_pos
== NULL
)
17446 myfree (temp_input_buf
);
17448 return (PARSER_SEPARATOR_UNMATCHED
);
17454 uint user_len
= strlen (user_pos
);
17456 if (user_len
> 116)
17458 myfree (temp_input_buf
);
17460 return (PARSER_SALT_LENGTH
);
17465 char *method_pos
= strchr (realm_pos
, '*');
17467 if (method_pos
== NULL
)
17469 myfree (temp_input_buf
);
17471 return (PARSER_SEPARATOR_UNMATCHED
);
17477 uint realm_len
= strlen (realm_pos
);
17479 if (realm_len
> 116)
17481 myfree (temp_input_buf
);
17483 return (PARSER_SALT_LENGTH
);
17488 char *URI_prefix_pos
= strchr (method_pos
, '*');
17490 if (URI_prefix_pos
== NULL
)
17492 myfree (temp_input_buf
);
17494 return (PARSER_SEPARATOR_UNMATCHED
);
17497 URI_prefix_pos
[0] = 0;
17500 uint method_len
= strlen (method_pos
);
17502 if (method_len
> 246)
17504 myfree (temp_input_buf
);
17506 return (PARSER_SALT_LENGTH
);
17511 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17513 if (URI_resource_pos
== NULL
)
17515 myfree (temp_input_buf
);
17517 return (PARSER_SEPARATOR_UNMATCHED
);
17520 URI_resource_pos
[0] = 0;
17521 URI_resource_pos
++;
17523 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17525 if (URI_prefix_len
> 245)
17527 myfree (temp_input_buf
);
17529 return (PARSER_SALT_LENGTH
);
17534 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17536 if (URI_suffix_pos
== NULL
)
17538 myfree (temp_input_buf
);
17540 return (PARSER_SEPARATOR_UNMATCHED
);
17543 URI_suffix_pos
[0] = 0;
17546 uint URI_resource_len
= strlen (URI_resource_pos
);
17548 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17550 myfree (temp_input_buf
);
17552 return (PARSER_SALT_LENGTH
);
17557 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17559 if (nonce_pos
== NULL
)
17561 myfree (temp_input_buf
);
17563 return (PARSER_SEPARATOR_UNMATCHED
);
17569 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17571 if (URI_suffix_len
> 245)
17573 myfree (temp_input_buf
);
17575 return (PARSER_SALT_LENGTH
);
17580 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17582 if (nonce_client_pos
== NULL
)
17584 myfree (temp_input_buf
);
17586 return (PARSER_SEPARATOR_UNMATCHED
);
17589 nonce_client_pos
[0] = 0;
17590 nonce_client_pos
++;
17592 uint nonce_len
= strlen (nonce_pos
);
17594 if (nonce_len
< 1 || nonce_len
> 50)
17596 myfree (temp_input_buf
);
17598 return (PARSER_SALT_LENGTH
);
17603 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17605 if (nonce_count_pos
== NULL
)
17607 myfree (temp_input_buf
);
17609 return (PARSER_SEPARATOR_UNMATCHED
);
17612 nonce_count_pos
[0] = 0;
17615 uint nonce_client_len
= strlen (nonce_client_pos
);
17617 if (nonce_client_len
> 50)
17619 myfree (temp_input_buf
);
17621 return (PARSER_SALT_LENGTH
);
17626 char *qop_pos
= strchr (nonce_count_pos
, '*');
17628 if (qop_pos
== NULL
)
17630 myfree (temp_input_buf
);
17632 return (PARSER_SEPARATOR_UNMATCHED
);
17638 uint nonce_count_len
= strlen (nonce_count_pos
);
17640 if (nonce_count_len
> 50)
17642 myfree (temp_input_buf
);
17644 return (PARSER_SALT_LENGTH
);
17649 char *directive_pos
= strchr (qop_pos
, '*');
17651 if (directive_pos
== NULL
)
17653 myfree (temp_input_buf
);
17655 return (PARSER_SEPARATOR_UNMATCHED
);
17658 directive_pos
[0] = 0;
17661 uint qop_len
= strlen (qop_pos
);
17665 myfree (temp_input_buf
);
17667 return (PARSER_SALT_LENGTH
);
17672 char *digest_pos
= strchr (directive_pos
, '*');
17674 if (digest_pos
== NULL
)
17676 myfree (temp_input_buf
);
17678 return (PARSER_SEPARATOR_UNMATCHED
);
17684 uint directive_len
= strlen (directive_pos
);
17686 if (directive_len
!= 3)
17688 myfree (temp_input_buf
);
17690 return (PARSER_SALT_LENGTH
);
17693 if (memcmp (directive_pos
, "MD5", 3))
17695 log_info ("ERROR: only the MD5 directive is currently supported\n");
17697 myfree (temp_input_buf
);
17699 return (PARSER_SIP_AUTH_DIRECTIVE
);
17703 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17708 uint md5_max_len
= 4 * 64;
17710 uint md5_remaining_len
= md5_max_len
;
17712 uint tmp_md5_buf
[64] = { 0 };
17714 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17716 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17718 md5_len
+= method_len
+ 1;
17719 tmp_md5_ptr
+= method_len
+ 1;
17721 if (URI_prefix_len
> 0)
17723 md5_remaining_len
= md5_max_len
- md5_len
;
17725 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17727 md5_len
+= URI_prefix_len
+ 1;
17728 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17731 md5_remaining_len
= md5_max_len
- md5_len
;
17733 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17735 md5_len
+= URI_resource_len
;
17736 tmp_md5_ptr
+= URI_resource_len
;
17738 if (URI_suffix_len
> 0)
17740 md5_remaining_len
= md5_max_len
- md5_len
;
17742 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17744 md5_len
+= 1 + URI_suffix_len
;
17747 uint tmp_digest
[4] = { 0 };
17749 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17751 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17752 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17753 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17754 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17760 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17762 uint esalt_len
= 0;
17764 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17766 // there are 2 possibilities for the esalt:
17768 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17770 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17772 if (esalt_len
> max_esalt_len
)
17774 myfree (temp_input_buf
);
17776 return (PARSER_SALT_LENGTH
);
17779 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17791 esalt_len
= 1 + nonce_len
+ 1 + 32;
17793 if (esalt_len
> max_esalt_len
)
17795 myfree (temp_input_buf
);
17797 return (PARSER_SALT_LENGTH
);
17800 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17808 // add 0x80 to esalt
17810 esalt_buf_ptr
[esalt_len
] = 0x80;
17812 sip
->esalt_len
= esalt_len
;
17818 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17820 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17822 uint max_salt_len
= 119;
17824 if (salt_len
> max_salt_len
)
17826 myfree (temp_input_buf
);
17828 return (PARSER_SALT_LENGTH
);
17831 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17833 sip
->salt_len
= salt_len
;
17836 * fake salt (for sorting)
17839 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17843 uint fake_salt_len
= salt_len
;
17845 if (fake_salt_len
> max_salt_len
)
17847 fake_salt_len
= max_salt_len
;
17850 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17852 salt
->salt_len
= fake_salt_len
;
17858 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17859 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17860 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17861 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17863 digest
[0] = byte_swap_32 (digest
[0]);
17864 digest
[1] = byte_swap_32 (digest
[1]);
17865 digest
[2] = byte_swap_32 (digest
[2]);
17866 digest
[3] = byte_swap_32 (digest
[3]);
17868 myfree (temp_input_buf
);
17870 return (PARSER_OK
);
17873 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17875 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17877 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17879 u32
*digest
= (u32
*) hash_buf
->digest
;
17881 salt_t
*salt
= hash_buf
->salt
;
17885 char *digest_pos
= input_buf
;
17887 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17894 char *salt_buf
= input_buf
+ 8 + 1;
17898 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17900 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17902 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17904 salt
->salt_len
= salt_len
;
17906 return (PARSER_OK
);
17909 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17911 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17913 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17915 u32
*digest
= (u32
*) hash_buf
->digest
;
17917 salt_t
*salt
= hash_buf
->salt
;
17919 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17925 char *p_buf_pos
= input_buf
+ 4;
17927 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17929 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17931 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17933 NumCyclesPower_pos
++;
17935 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17937 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17939 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17943 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17945 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17947 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
17951 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17953 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17955 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17959 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17961 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17963 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
17967 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17969 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17971 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17975 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17977 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17979 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
17983 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17985 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17987 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
17991 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17993 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17995 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17999 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;
18001 const uint iter
= atoi (NumCyclesPower_pos
);
18002 const uint crc
= atoi (crc_buf_pos
);
18003 const uint p_buf
= atoi (p_buf_pos
);
18004 const uint salt_len
= atoi (salt_len_pos
);
18005 const uint iv_len
= atoi (iv_len_pos
);
18006 const uint unpack_size
= atoi (unpack_size_pos
);
18007 const uint data_len
= atoi (data_len_pos
);
18013 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18014 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18016 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18018 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18020 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18026 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18027 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18028 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18029 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18031 seven_zip
->iv_len
= iv_len
;
18033 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18035 seven_zip
->salt_len
= 0;
18037 seven_zip
->crc
= crc
;
18039 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18041 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18043 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18046 seven_zip
->data_len
= data_len
;
18048 seven_zip
->unpack_size
= unpack_size
;
18052 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18053 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18054 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18055 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18057 salt
->salt_len
= 16;
18059 salt
->salt_sign
[0] = iter
;
18061 salt
->salt_iter
= 1 << iter
;
18072 return (PARSER_OK
);
18075 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18077 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18079 u32
*digest
= (u32
*) hash_buf
->digest
;
18081 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18082 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18083 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18084 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18085 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18086 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18087 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18088 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18090 digest
[0] = byte_swap_32 (digest
[0]);
18091 digest
[1] = byte_swap_32 (digest
[1]);
18092 digest
[2] = byte_swap_32 (digest
[2]);
18093 digest
[3] = byte_swap_32 (digest
[3]);
18094 digest
[4] = byte_swap_32 (digest
[4]);
18095 digest
[5] = byte_swap_32 (digest
[5]);
18096 digest
[6] = byte_swap_32 (digest
[6]);
18097 digest
[7] = byte_swap_32 (digest
[7]);
18099 return (PARSER_OK
);
18102 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18104 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18106 u32
*digest
= (u32
*) hash_buf
->digest
;
18108 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18109 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18110 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18111 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18112 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18113 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18114 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18115 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18116 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18117 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18118 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18119 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18120 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18121 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18122 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18123 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18125 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18126 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18127 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18128 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18129 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18130 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18131 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18132 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18133 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18134 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18135 digest
[10] = byte_swap_32 (digest
[10]);
18136 digest
[11] = byte_swap_32 (digest
[11]);
18137 digest
[12] = byte_swap_32 (digest
[12]);
18138 digest
[13] = byte_swap_32 (digest
[13]);
18139 digest
[14] = byte_swap_32 (digest
[14]);
18140 digest
[15] = byte_swap_32 (digest
[15]);
18142 return (PARSER_OK
);
18145 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18147 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18149 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18151 u32
*digest
= (u32
*) hash_buf
->digest
;
18153 salt_t
*salt
= hash_buf
->salt
;
18155 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18163 char *iter_pos
= input_buf
+ 4;
18165 u32 iter
= atoi (iter_pos
);
18167 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18168 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18170 // first is *raw* salt
18172 char *salt_pos
= strchr (iter_pos
, ':');
18174 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18178 char *hash_pos
= strchr (salt_pos
, ':');
18180 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18182 u32 salt_len
= hash_pos
- salt_pos
;
18184 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18188 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18190 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18194 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18196 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18198 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18200 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18201 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18203 salt
->salt_len
= salt_len
;
18204 salt
->salt_iter
= iter
- 1;
18208 u8 tmp_buf
[100] = { 0 };
18210 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18212 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18214 memcpy (digest
, tmp_buf
, 16);
18216 // add some stuff to normal salt to make sorted happy
18218 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18219 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18220 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18221 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18222 salt
->salt_buf
[4] = salt
->salt_iter
;
18224 return (PARSER_OK
);
18227 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18229 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18231 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18233 u32
*digest
= (u32
*) hash_buf
->digest
;
18235 salt_t
*salt
= hash_buf
->salt
;
18237 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18245 char *iter_pos
= input_buf
+ 5;
18247 u32 iter
= atoi (iter_pos
);
18249 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18250 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18252 // first is *raw* salt
18254 char *salt_pos
= strchr (iter_pos
, ':');
18256 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18260 char *hash_pos
= strchr (salt_pos
, ':');
18262 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18264 u32 salt_len
= hash_pos
- salt_pos
;
18266 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18270 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18272 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18276 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18278 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18280 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18282 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18283 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18285 salt
->salt_len
= salt_len
;
18286 salt
->salt_iter
= iter
- 1;
18290 u8 tmp_buf
[100] = { 0 };
18292 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18294 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18296 memcpy (digest
, tmp_buf
, 16);
18298 digest
[0] = byte_swap_32 (digest
[0]);
18299 digest
[1] = byte_swap_32 (digest
[1]);
18300 digest
[2] = byte_swap_32 (digest
[2]);
18301 digest
[3] = byte_swap_32 (digest
[3]);
18303 // add some stuff to normal salt to make sorted happy
18305 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18306 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18307 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18308 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18309 salt
->salt_buf
[4] = salt
->salt_iter
;
18311 return (PARSER_OK
);
18314 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18316 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18318 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18320 u64
*digest
= (u64
*) hash_buf
->digest
;
18322 salt_t
*salt
= hash_buf
->salt
;
18324 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18332 char *iter_pos
= input_buf
+ 7;
18334 u32 iter
= atoi (iter_pos
);
18336 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18337 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18339 // first is *raw* salt
18341 char *salt_pos
= strchr (iter_pos
, ':');
18343 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18347 char *hash_pos
= strchr (salt_pos
, ':');
18349 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18351 u32 salt_len
= hash_pos
- salt_pos
;
18353 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18357 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18359 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18363 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18365 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18367 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18369 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18370 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18372 salt
->salt_len
= salt_len
;
18373 salt
->salt_iter
= iter
- 1;
18377 u8 tmp_buf
[100] = { 0 };
18379 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18381 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18383 memcpy (digest
, tmp_buf
, 64);
18385 digest
[0] = byte_swap_64 (digest
[0]);
18386 digest
[1] = byte_swap_64 (digest
[1]);
18387 digest
[2] = byte_swap_64 (digest
[2]);
18388 digest
[3] = byte_swap_64 (digest
[3]);
18389 digest
[4] = byte_swap_64 (digest
[4]);
18390 digest
[5] = byte_swap_64 (digest
[5]);
18391 digest
[6] = byte_swap_64 (digest
[6]);
18392 digest
[7] = byte_swap_64 (digest
[7]);
18394 // add some stuff to normal salt to make sorted happy
18396 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18397 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18398 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18399 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18400 salt
->salt_buf
[4] = salt
->salt_iter
;
18402 return (PARSER_OK
);
18405 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18407 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18409 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18411 uint
*digest
= (uint
*) hash_buf
->digest
;
18413 salt_t
*salt
= hash_buf
->salt
;
18419 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18421 char *hash_pos
= strchr (salt_pos
, '$');
18423 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18425 u32 salt_len
= hash_pos
- salt_pos
;
18427 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18431 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18433 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18437 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18438 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18456 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18457 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18459 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18460 salt
->salt_len
= 8;
18462 return (PARSER_OK
);
18465 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18467 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18469 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18471 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18473 if (c19
& 3) return (PARSER_HASH_VALUE
);
18475 salt_t
*salt
= hash_buf
->salt
;
18477 u32
*digest
= (u32
*) hash_buf
->digest
;
18481 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18482 | itoa64_to_int (input_buf
[2]) << 6
18483 | itoa64_to_int (input_buf
[3]) << 12
18484 | itoa64_to_int (input_buf
[4]) << 18;
18488 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18489 | itoa64_to_int (input_buf
[6]) << 6
18490 | itoa64_to_int (input_buf
[7]) << 12
18491 | itoa64_to_int (input_buf
[8]) << 18;
18493 salt
->salt_len
= 4;
18495 u8 tmp_buf
[100] = { 0 };
18497 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18499 memcpy (digest
, tmp_buf
, 8);
18503 IP (digest
[0], digest
[1], tt
);
18505 digest
[0] = rotr32 (digest
[0], 31);
18506 digest
[1] = rotr32 (digest
[1], 31);
18510 return (PARSER_OK
);
18513 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18515 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18517 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18519 u32
*digest
= (u32
*) hash_buf
->digest
;
18521 salt_t
*salt
= hash_buf
->salt
;
18527 char *type_pos
= input_buf
+ 6 + 1;
18529 char *salt_pos
= strchr (type_pos
, '*');
18531 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18533 u32 type_len
= salt_pos
- type_pos
;
18535 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18539 char *crypted_pos
= strchr (salt_pos
, '*');
18541 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18543 u32 salt_len
= crypted_pos
- salt_pos
;
18545 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18549 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18551 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18557 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18558 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18560 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18561 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18563 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18564 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18565 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18566 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18568 salt
->salt_len
= 24;
18569 salt
->salt_iter
= ROUNDS_RAR3
;
18571 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18572 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18574 digest
[0] = 0xc43d7b00;
18575 digest
[1] = 0x40070000;
18579 return (PARSER_OK
);
18582 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18584 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18586 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18588 u32
*digest
= (u32
*) hash_buf
->digest
;
18590 salt_t
*salt
= hash_buf
->salt
;
18592 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18598 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18600 char *param1_pos
= strchr (param0_pos
, '$');
18602 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18604 u32 param0_len
= param1_pos
- param0_pos
;
18608 char *param2_pos
= strchr (param1_pos
, '$');
18610 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18612 u32 param1_len
= param2_pos
- param1_pos
;
18616 char *param3_pos
= strchr (param2_pos
, '$');
18618 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18620 u32 param2_len
= param3_pos
- param2_pos
;
18624 char *param4_pos
= strchr (param3_pos
, '$');
18626 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18628 u32 param3_len
= param4_pos
- param3_pos
;
18632 char *param5_pos
= strchr (param4_pos
, '$');
18634 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18636 u32 param4_len
= param5_pos
- param4_pos
;
18640 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18642 char *salt_buf
= param1_pos
;
18643 char *iv
= param3_pos
;
18644 char *pswcheck
= param5_pos
;
18646 const uint salt_len
= atoi (param0_pos
);
18647 const uint iterations
= atoi (param2_pos
);
18648 const uint pswcheck_len
= atoi (param4_pos
);
18654 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18655 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18656 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18658 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18659 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18660 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18666 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18667 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18668 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18669 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18671 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18672 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18673 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18674 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18676 salt
->salt_len
= 16;
18678 salt
->salt_sign
[0] = iterations
;
18680 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18686 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18687 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18691 return (PARSER_OK
);
18694 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18696 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18698 u32
*digest
= (u32
*) hash_buf
->digest
;
18700 salt_t
*salt
= hash_buf
->salt
;
18702 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18703 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18704 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18705 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18706 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18707 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18708 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18709 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18711 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18713 uint salt_len
= input_len
- 64 - 1;
18715 char *salt_buf
= input_buf
+ 64 + 1;
18717 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18719 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18721 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18723 salt
->salt_len
= salt_len
;
18726 * we can precompute the first sha256 transform
18729 uint w
[16] = { 0 };
18731 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18732 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18733 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18734 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18735 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18736 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18737 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18738 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18739 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18740 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18741 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18742 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18743 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18744 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18745 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18746 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18748 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
18750 sha256_64 (w
, pc256
);
18752 salt
->salt_buf_pc
[0] = pc256
[0];
18753 salt
->salt_buf_pc
[1] = pc256
[1];
18754 salt
->salt_buf_pc
[2] = pc256
[2];
18755 salt
->salt_buf_pc
[3] = pc256
[3];
18756 salt
->salt_buf_pc
[4] = pc256
[4];
18757 salt
->salt_buf_pc
[5] = pc256
[5];
18758 salt
->salt_buf_pc
[6] = pc256
[6];
18759 salt
->salt_buf_pc
[7] = pc256
[7];
18761 digest
[0] -= pc256
[0];
18762 digest
[1] -= pc256
[1];
18763 digest
[2] -= pc256
[2];
18764 digest
[3] -= pc256
[3];
18765 digest
[4] -= pc256
[4];
18766 digest
[5] -= pc256
[5];
18767 digest
[6] -= pc256
[6];
18768 digest
[7] -= pc256
[7];
18770 return (PARSER_OK
);
18773 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18775 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18777 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18779 u32
*digest
= (u32
*) hash_buf
->digest
;
18781 salt_t
*salt
= hash_buf
->salt
;
18787 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18789 char *data_buf_pos
= strchr (data_len_pos
, '$');
18791 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18793 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18795 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18796 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18800 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18802 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18804 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18806 u32 data_len
= atoi (data_len_pos
);
18808 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18814 char *salt_pos
= data_buf_pos
;
18816 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18817 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18818 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
18819 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
18821 // this is actually the CT, which is also the hash later (if matched)
18823 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
18824 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
18825 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
18826 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
18828 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18830 salt
->salt_iter
= 10 - 1;
18836 digest
[0] = salt
->salt_buf
[4];
18837 digest
[1] = salt
->salt_buf
[5];
18838 digest
[2] = salt
->salt_buf
[6];
18839 digest
[3] = salt
->salt_buf
[7];
18841 return (PARSER_OK
);
18844 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18846 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18848 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18850 u32
*digest
= (u32
*) hash_buf
->digest
;
18852 salt_t
*salt
= hash_buf
->salt
;
18858 char *salt_pos
= input_buf
+ 11 + 1;
18860 char *iter_pos
= strchr (salt_pos
, ',');
18862 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18864 u32 salt_len
= iter_pos
- salt_pos
;
18866 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18870 char *hash_pos
= strchr (iter_pos
, ',');
18872 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18874 u32 iter_len
= hash_pos
- iter_pos
;
18876 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18880 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18882 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18888 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18889 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18890 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
18891 salt
->salt_buf
[3] = 0x00018000;
18893 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18894 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18895 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18896 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18898 salt
->salt_len
= salt_len
/ 2;
18900 salt
->salt_iter
= atoi (iter_pos
) - 1;
18906 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18907 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18908 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18909 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18910 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18911 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18912 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18913 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18915 return (PARSER_OK
);
18918 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18920 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
18922 u32
*digest
= (u32
*) hash_buf
->digest
;
18924 salt_t
*salt
= hash_buf
->salt
;
18930 char *hash_pos
= input_buf
+ 64;
18931 char *salt1_pos
= input_buf
+ 128;
18932 char *salt2_pos
= input_buf
;
18938 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
18939 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
18940 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
18941 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
18943 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
18944 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
18945 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
18946 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
18948 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
18949 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
18950 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
18951 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
18953 salt
->salt_len
= 48;
18955 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
18961 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18962 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18963 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18964 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18965 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18966 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18967 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18968 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18970 return (PARSER_OK
);
18974 * parallel running threads
18979 BOOL WINAPI
sigHandler_default (DWORD sig
)
18983 case CTRL_CLOSE_EVENT
:
18986 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18987 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18988 * function otherwise it is too late (e.g. after returning from this function)
18993 SetConsoleCtrlHandler (NULL
, TRUE
);
19000 case CTRL_LOGOFF_EVENT
:
19001 case CTRL_SHUTDOWN_EVENT
:
19005 SetConsoleCtrlHandler (NULL
, TRUE
);
19013 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19017 case CTRL_CLOSE_EVENT
:
19021 SetConsoleCtrlHandler (NULL
, TRUE
);
19028 case CTRL_LOGOFF_EVENT
:
19029 case CTRL_SHUTDOWN_EVENT
:
19033 SetConsoleCtrlHandler (NULL
, TRUE
);
19041 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19043 if (callback
== NULL
)
19045 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19049 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19055 void sigHandler_default (int sig
)
19059 signal (sig
, NULL
);
19062 void sigHandler_benchmark (int sig
)
19066 signal (sig
, NULL
);
19069 void hc_signal (void (callback
) (int))
19071 if (callback
== NULL
) callback
= SIG_DFL
;
19073 signal (SIGINT
, callback
);
19074 signal (SIGTERM
, callback
);
19075 signal (SIGABRT
, callback
);
19080 void status_display ();
19082 void *thread_keypress (void *p
)
19084 int benchmark
= *((int *) p
);
19086 uint quiet
= data
.quiet
;
19090 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19092 int ch
= tty_getchar();
19094 if (ch
== -1) break;
19096 if (ch
== 0) continue;
19102 hc_thread_mutex_lock (mux_display
);
19117 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19118 if (quiet
== 0) fflush (stdout
);
19130 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19131 if (quiet
== 0) fflush (stdout
);
19143 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19144 if (quiet
== 0) fflush (stdout
);
19156 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19157 if (quiet
== 0) fflush (stdout
);
19165 if (benchmark
== 1) break;
19167 stop_at_checkpoint ();
19171 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19172 if (quiet
== 0) fflush (stdout
);
19180 if (benchmark
== 1)
19192 hc_thread_mutex_unlock (mux_display
);
19204 bool class_num (const u8 c
)
19206 return ((c
>= '0') && (c
<= '9'));
19209 bool class_lower (const u8 c
)
19211 return ((c
>= 'a') && (c
<= 'z'));
19214 bool class_upper (const u8 c
)
19216 return ((c
>= 'A') && (c
<= 'Z'));
19219 bool class_alpha (const u8 c
)
19221 return (class_lower (c
) || class_upper (c
));
19224 int conv_ctoi (const u8 c
)
19230 else if (class_upper (c
))
19232 return c
- 'A' + 10;
19238 int conv_itoc (const u8 c
)
19246 return c
+ 'A' - 10;
19256 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19257 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19258 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19259 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19260 #define MAX_KERNEL_RULES 255
19261 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19262 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19263 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19265 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19266 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19267 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19268 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19270 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19275 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19277 switch (rule_buf
[rule_pos
])
19283 case RULE_OP_MANGLE_NOOP
:
19284 SET_NAME (rule
, rule_buf
[rule_pos
]);
19287 case RULE_OP_MANGLE_LREST
:
19288 SET_NAME (rule
, rule_buf
[rule_pos
]);
19291 case RULE_OP_MANGLE_UREST
:
19292 SET_NAME (rule
, rule_buf
[rule_pos
]);
19295 case RULE_OP_MANGLE_LREST_UFIRST
:
19296 SET_NAME (rule
, rule_buf
[rule_pos
]);
19299 case RULE_OP_MANGLE_UREST_LFIRST
:
19300 SET_NAME (rule
, rule_buf
[rule_pos
]);
19303 case RULE_OP_MANGLE_TREST
:
19304 SET_NAME (rule
, rule_buf
[rule_pos
]);
19307 case RULE_OP_MANGLE_TOGGLE_AT
:
19308 SET_NAME (rule
, rule_buf
[rule_pos
]);
19309 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19312 case RULE_OP_MANGLE_REVERSE
:
19313 SET_NAME (rule
, rule_buf
[rule_pos
]);
19316 case RULE_OP_MANGLE_DUPEWORD
:
19317 SET_NAME (rule
, rule_buf
[rule_pos
]);
19320 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19321 SET_NAME (rule
, rule_buf
[rule_pos
]);
19322 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19325 case RULE_OP_MANGLE_REFLECT
:
19326 SET_NAME (rule
, rule_buf
[rule_pos
]);
19329 case RULE_OP_MANGLE_ROTATE_LEFT
:
19330 SET_NAME (rule
, rule_buf
[rule_pos
]);
19333 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19334 SET_NAME (rule
, rule_buf
[rule_pos
]);
19337 case RULE_OP_MANGLE_APPEND
:
19338 SET_NAME (rule
, rule_buf
[rule_pos
]);
19339 SET_P0 (rule
, rule_buf
[rule_pos
]);
19342 case RULE_OP_MANGLE_PREPEND
:
19343 SET_NAME (rule
, rule_buf
[rule_pos
]);
19344 SET_P0 (rule
, rule_buf
[rule_pos
]);
19347 case RULE_OP_MANGLE_DELETE_FIRST
:
19348 SET_NAME (rule
, rule_buf
[rule_pos
]);
19351 case RULE_OP_MANGLE_DELETE_LAST
:
19352 SET_NAME (rule
, rule_buf
[rule_pos
]);
19355 case RULE_OP_MANGLE_DELETE_AT
:
19356 SET_NAME (rule
, rule_buf
[rule_pos
]);
19357 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19360 case RULE_OP_MANGLE_EXTRACT
:
19361 SET_NAME (rule
, rule_buf
[rule_pos
]);
19362 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19363 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19366 case RULE_OP_MANGLE_OMIT
:
19367 SET_NAME (rule
, rule_buf
[rule_pos
]);
19368 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19369 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19372 case RULE_OP_MANGLE_INSERT
:
19373 SET_NAME (rule
, rule_buf
[rule_pos
]);
19374 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19375 SET_P1 (rule
, rule_buf
[rule_pos
]);
19378 case RULE_OP_MANGLE_OVERSTRIKE
:
19379 SET_NAME (rule
, rule_buf
[rule_pos
]);
19380 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19381 SET_P1 (rule
, rule_buf
[rule_pos
]);
19384 case RULE_OP_MANGLE_TRUNCATE_AT
:
19385 SET_NAME (rule
, rule_buf
[rule_pos
]);
19386 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19389 case RULE_OP_MANGLE_REPLACE
:
19390 SET_NAME (rule
, rule_buf
[rule_pos
]);
19391 SET_P0 (rule
, rule_buf
[rule_pos
]);
19392 SET_P1 (rule
, rule_buf
[rule_pos
]);
19395 case RULE_OP_MANGLE_PURGECHAR
:
19399 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19403 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19404 SET_NAME (rule
, rule_buf
[rule_pos
]);
19405 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19408 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19409 SET_NAME (rule
, rule_buf
[rule_pos
]);
19410 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19413 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19414 SET_NAME (rule
, rule_buf
[rule_pos
]);
19417 case RULE_OP_MANGLE_SWITCH_FIRST
:
19418 SET_NAME (rule
, rule_buf
[rule_pos
]);
19421 case RULE_OP_MANGLE_SWITCH_LAST
:
19422 SET_NAME (rule
, rule_buf
[rule_pos
]);
19425 case RULE_OP_MANGLE_SWITCH_AT
:
19426 SET_NAME (rule
, rule_buf
[rule_pos
]);
19427 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19428 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19431 case RULE_OP_MANGLE_CHR_SHIFTL
:
19432 SET_NAME (rule
, rule_buf
[rule_pos
]);
19433 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19436 case RULE_OP_MANGLE_CHR_SHIFTR
:
19437 SET_NAME (rule
, rule_buf
[rule_pos
]);
19438 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19441 case RULE_OP_MANGLE_CHR_INCR
:
19442 SET_NAME (rule
, rule_buf
[rule_pos
]);
19443 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19446 case RULE_OP_MANGLE_CHR_DECR
:
19447 SET_NAME (rule
, rule_buf
[rule_pos
]);
19448 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19451 case RULE_OP_MANGLE_REPLACE_NP1
:
19452 SET_NAME (rule
, rule_buf
[rule_pos
]);
19453 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19456 case RULE_OP_MANGLE_REPLACE_NM1
:
19457 SET_NAME (rule
, rule_buf
[rule_pos
]);
19458 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19461 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19462 SET_NAME (rule
, rule_buf
[rule_pos
]);
19463 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19466 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19467 SET_NAME (rule
, rule_buf
[rule_pos
]);
19468 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19471 case RULE_OP_MANGLE_TITLE
:
19472 SET_NAME (rule
, rule_buf
[rule_pos
]);
19481 if (rule_pos
< rule_len
) return (-1);
19486 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19490 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19494 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19498 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19502 case RULE_OP_MANGLE_NOOP
:
19503 rule_buf
[rule_pos
] = rule_cmd
;
19506 case RULE_OP_MANGLE_LREST
:
19507 rule_buf
[rule_pos
] = rule_cmd
;
19510 case RULE_OP_MANGLE_UREST
:
19511 rule_buf
[rule_pos
] = rule_cmd
;
19514 case RULE_OP_MANGLE_LREST_UFIRST
:
19515 rule_buf
[rule_pos
] = rule_cmd
;
19518 case RULE_OP_MANGLE_UREST_LFIRST
:
19519 rule_buf
[rule_pos
] = rule_cmd
;
19522 case RULE_OP_MANGLE_TREST
:
19523 rule_buf
[rule_pos
] = rule_cmd
;
19526 case RULE_OP_MANGLE_TOGGLE_AT
:
19527 rule_buf
[rule_pos
] = rule_cmd
;
19528 GET_P0_CONV (rule
);
19531 case RULE_OP_MANGLE_REVERSE
:
19532 rule_buf
[rule_pos
] = rule_cmd
;
19535 case RULE_OP_MANGLE_DUPEWORD
:
19536 rule_buf
[rule_pos
] = rule_cmd
;
19539 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19540 rule_buf
[rule_pos
] = rule_cmd
;
19541 GET_P0_CONV (rule
);
19544 case RULE_OP_MANGLE_REFLECT
:
19545 rule_buf
[rule_pos
] = rule_cmd
;
19548 case RULE_OP_MANGLE_ROTATE_LEFT
:
19549 rule_buf
[rule_pos
] = rule_cmd
;
19552 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19553 rule_buf
[rule_pos
] = rule_cmd
;
19556 case RULE_OP_MANGLE_APPEND
:
19557 rule_buf
[rule_pos
] = rule_cmd
;
19561 case RULE_OP_MANGLE_PREPEND
:
19562 rule_buf
[rule_pos
] = rule_cmd
;
19566 case RULE_OP_MANGLE_DELETE_FIRST
:
19567 rule_buf
[rule_pos
] = rule_cmd
;
19570 case RULE_OP_MANGLE_DELETE_LAST
:
19571 rule_buf
[rule_pos
] = rule_cmd
;
19574 case RULE_OP_MANGLE_DELETE_AT
:
19575 rule_buf
[rule_pos
] = rule_cmd
;
19576 GET_P0_CONV (rule
);
19579 case RULE_OP_MANGLE_EXTRACT
:
19580 rule_buf
[rule_pos
] = rule_cmd
;
19581 GET_P0_CONV (rule
);
19582 GET_P1_CONV (rule
);
19585 case RULE_OP_MANGLE_OMIT
:
19586 rule_buf
[rule_pos
] = rule_cmd
;
19587 GET_P0_CONV (rule
);
19588 GET_P1_CONV (rule
);
19591 case RULE_OP_MANGLE_INSERT
:
19592 rule_buf
[rule_pos
] = rule_cmd
;
19593 GET_P0_CONV (rule
);
19597 case RULE_OP_MANGLE_OVERSTRIKE
:
19598 rule_buf
[rule_pos
] = rule_cmd
;
19599 GET_P0_CONV (rule
);
19603 case RULE_OP_MANGLE_TRUNCATE_AT
:
19604 rule_buf
[rule_pos
] = rule_cmd
;
19605 GET_P0_CONV (rule
);
19608 case RULE_OP_MANGLE_REPLACE
:
19609 rule_buf
[rule_pos
] = rule_cmd
;
19614 case RULE_OP_MANGLE_PURGECHAR
:
19618 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19622 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19623 rule_buf
[rule_pos
] = rule_cmd
;
19624 GET_P0_CONV (rule
);
19627 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19628 rule_buf
[rule_pos
] = rule_cmd
;
19629 GET_P0_CONV (rule
);
19632 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19633 rule_buf
[rule_pos
] = rule_cmd
;
19636 case RULE_OP_MANGLE_SWITCH_FIRST
:
19637 rule_buf
[rule_pos
] = rule_cmd
;
19640 case RULE_OP_MANGLE_SWITCH_LAST
:
19641 rule_buf
[rule_pos
] = rule_cmd
;
19644 case RULE_OP_MANGLE_SWITCH_AT
:
19645 rule_buf
[rule_pos
] = rule_cmd
;
19646 GET_P0_CONV (rule
);
19647 GET_P1_CONV (rule
);
19650 case RULE_OP_MANGLE_CHR_SHIFTL
:
19651 rule_buf
[rule_pos
] = rule_cmd
;
19652 GET_P0_CONV (rule
);
19655 case RULE_OP_MANGLE_CHR_SHIFTR
:
19656 rule_buf
[rule_pos
] = rule_cmd
;
19657 GET_P0_CONV (rule
);
19660 case RULE_OP_MANGLE_CHR_INCR
:
19661 rule_buf
[rule_pos
] = rule_cmd
;
19662 GET_P0_CONV (rule
);
19665 case RULE_OP_MANGLE_CHR_DECR
:
19666 rule_buf
[rule_pos
] = rule_cmd
;
19667 GET_P0_CONV (rule
);
19670 case RULE_OP_MANGLE_REPLACE_NP1
:
19671 rule_buf
[rule_pos
] = rule_cmd
;
19672 GET_P0_CONV (rule
);
19675 case RULE_OP_MANGLE_REPLACE_NM1
:
19676 rule_buf
[rule_pos
] = rule_cmd
;
19677 GET_P0_CONV (rule
);
19680 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19681 rule_buf
[rule_pos
] = rule_cmd
;
19682 GET_P0_CONV (rule
);
19685 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19686 rule_buf
[rule_pos
] = rule_cmd
;
19687 GET_P0_CONV (rule
);
19690 case RULE_OP_MANGLE_TITLE
:
19691 rule_buf
[rule_pos
] = rule_cmd
;
19695 return rule_pos
- 1;
19713 * CPU rules : this is from hashcat sources, cpu based rules
19716 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19717 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19719 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19720 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19721 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19723 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19724 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19725 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19727 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19731 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19736 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19740 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19745 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19749 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19754 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19759 for (l
= 0; l
< arr_len
; l
++)
19761 r
= arr_len
- 1 - l
;
19765 MANGLE_SWITCH (arr
, l
, r
);
19771 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19773 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19775 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19777 return (arr_len
* 2);
19780 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19782 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19784 int orig_len
= arr_len
;
19788 for (i
= 0; i
< times
; i
++)
19790 memcpy (&arr
[arr_len
], arr
, orig_len
);
19792 arr_len
+= orig_len
;
19798 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19800 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19802 mangle_double (arr
, arr_len
);
19804 mangle_reverse (arr
+ arr_len
, arr_len
);
19806 return (arr_len
* 2);
19809 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19814 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19816 MANGLE_SWITCH (arr
, l
, r
);
19822 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19827 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19829 MANGLE_SWITCH (arr
, l
, r
);
19835 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19837 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19841 return (arr_len
+ 1);
19844 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19846 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19850 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19852 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19857 return (arr_len
+ 1);
19860 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19862 if (upos
>= arr_len
) return (arr_len
);
19866 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19868 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19871 return (arr_len
- 1);
19874 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19876 if (upos
>= arr_len
) return (arr_len
);
19878 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19882 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19884 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19890 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19892 if (upos
>= arr_len
) return (arr_len
);
19894 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19898 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19900 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19903 return (arr_len
- ulen
);
19906 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19908 if (upos
>= arr_len
) return (arr_len
);
19910 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19914 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19916 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19921 return (arr_len
+ 1);
19924 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
)
19926 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19928 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19930 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19932 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19934 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19936 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19938 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19940 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19942 return (arr_len
+ arr2_cpy
);
19945 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19947 if (upos
>= arr_len
) return (arr_len
);
19954 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19956 if (upos
>= arr_len
) return (arr_len
);
19958 memset (arr
+ upos
, 0, arr_len
- upos
);
19963 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19967 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19969 if (arr
[arr_pos
] != oldc
) continue;
19971 arr
[arr_pos
] = newc
;
19977 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19983 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19985 if (arr
[arr_pos
] == c
) continue;
19987 arr
[ret_len
] = arr
[arr_pos
];
19995 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19997 if (ulen
> arr_len
) return (arr_len
);
19999 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20001 char cs
[100] = { 0 };
20003 memcpy (cs
, arr
, ulen
);
20007 for (i
= 0; i
< ulen
; i
++)
20011 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20017 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20019 if (ulen
> arr_len
) return (arr_len
);
20021 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20023 int upos
= arr_len
- ulen
;
20027 for (i
= 0; i
< ulen
; i
++)
20029 char c
= arr
[upos
+ i
];
20031 arr_len
= mangle_append (arr
, arr_len
, c
);
20037 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20039 if ( arr_len
== 0) return (arr_len
);
20040 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20042 char c
= arr
[upos
];
20046 for (i
= 0; i
< ulen
; i
++)
20048 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20054 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20056 if ( arr_len
== 0) return (arr_len
);
20057 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20061 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20063 int new_pos
= arr_pos
* 2;
20065 arr
[new_pos
] = arr
[arr_pos
];
20067 arr
[new_pos
+ 1] = arr
[arr_pos
];
20070 return (arr_len
* 2);
20073 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20075 if (upos
>= arr_len
) return (arr_len
);
20076 if (upos2
>= arr_len
) return (arr_len
);
20078 MANGLE_SWITCH (arr
, upos
, upos2
);
20083 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20085 MANGLE_SWITCH (arr
, upos
, upos2
);
20090 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20092 if (upos
>= arr_len
) return (arr_len
);
20099 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20101 if (upos
>= arr_len
) return (arr_len
);
20108 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20110 if (upos
>= arr_len
) return (arr_len
);
20117 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20119 if (upos
>= arr_len
) return (arr_len
);
20126 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20128 int upper_next
= 1;
20132 for (pos
= 0; pos
< arr_len
; pos
++)
20134 if (arr
[pos
] == ' ')
20145 MANGLE_UPPER_AT (arr
, pos
);
20149 MANGLE_LOWER_AT (arr
, pos
);
20156 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20158 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20164 for (j
= 0; j
< rp_gen_num
; j
++)
20171 switch ((char) get_random_num (0, 9))
20174 r
= get_random_num (0, sizeof (grp_op_nop
));
20175 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20179 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20180 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20181 p1
= get_random_num (0, sizeof (grp_pos
));
20182 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20186 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20187 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20188 p1
= get_random_num (1, 6);
20189 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20193 r
= get_random_num (0, sizeof (grp_op_chr
));
20194 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20195 p1
= get_random_num (0x20, 0x7e);
20196 rule_buf
[rule_pos
++] = (char) p1
;
20200 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20201 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20202 p1
= get_random_num (0x20, 0x7e);
20203 rule_buf
[rule_pos
++] = (char) p1
;
20204 p2
= get_random_num (0x20, 0x7e);
20206 p2
= get_random_num (0x20, 0x7e);
20207 rule_buf
[rule_pos
++] = (char) p2
;
20211 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20212 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20213 p1
= get_random_num (0, sizeof (grp_pos
));
20214 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20215 p2
= get_random_num (0x20, 0x7e);
20216 rule_buf
[rule_pos
++] = (char) p2
;
20220 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20221 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20222 p1
= get_random_num (0, sizeof (grp_pos
));
20223 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20224 p2
= get_random_num (0, sizeof (grp_pos
));
20226 p2
= get_random_num (0, sizeof (grp_pos
));
20227 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20231 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20232 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20233 p1
= get_random_num (0, sizeof (grp_pos
));
20234 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20235 p2
= get_random_num (1, sizeof (grp_pos
));
20237 p2
= get_random_num (1, sizeof (grp_pos
));
20238 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20242 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20243 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20244 p1
= get_random_num (0, sizeof (grp_pos
));
20245 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20246 p2
= get_random_num (1, sizeof (grp_pos
));
20247 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20248 p3
= get_random_num (0, sizeof (grp_pos
));
20249 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20257 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20259 char mem
[BLOCK_SIZE
] = { 0 };
20261 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20263 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20265 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20267 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20269 int out_len
= in_len
;
20270 int mem_len
= in_len
;
20272 memcpy (out
, in
, out_len
);
20276 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20281 switch (rule
[rule_pos
])
20286 case RULE_OP_MANGLE_NOOP
:
20289 case RULE_OP_MANGLE_LREST
:
20290 out_len
= mangle_lrest (out
, out_len
);
20293 case RULE_OP_MANGLE_UREST
:
20294 out_len
= mangle_urest (out
, out_len
);
20297 case RULE_OP_MANGLE_LREST_UFIRST
:
20298 out_len
= mangle_lrest (out
, out_len
);
20299 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20302 case RULE_OP_MANGLE_UREST_LFIRST
:
20303 out_len
= mangle_urest (out
, out_len
);
20304 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20307 case RULE_OP_MANGLE_TREST
:
20308 out_len
= mangle_trest (out
, out_len
);
20311 case RULE_OP_MANGLE_TOGGLE_AT
:
20312 NEXT_RULEPOS (rule_pos
);
20313 NEXT_RPTOI (rule
, rule_pos
, upos
);
20314 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20317 case RULE_OP_MANGLE_REVERSE
:
20318 out_len
= mangle_reverse (out
, out_len
);
20321 case RULE_OP_MANGLE_DUPEWORD
:
20322 out_len
= mangle_double (out
, out_len
);
20325 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20326 NEXT_RULEPOS (rule_pos
);
20327 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20328 out_len
= mangle_double_times (out
, out_len
, ulen
);
20331 case RULE_OP_MANGLE_REFLECT
:
20332 out_len
= mangle_reflect (out
, out_len
);
20335 case RULE_OP_MANGLE_ROTATE_LEFT
:
20336 mangle_rotate_left (out
, out_len
);
20339 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20340 mangle_rotate_right (out
, out_len
);
20343 case RULE_OP_MANGLE_APPEND
:
20344 NEXT_RULEPOS (rule_pos
);
20345 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20348 case RULE_OP_MANGLE_PREPEND
:
20349 NEXT_RULEPOS (rule_pos
);
20350 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20353 case RULE_OP_MANGLE_DELETE_FIRST
:
20354 out_len
= mangle_delete_at (out
, out_len
, 0);
20357 case RULE_OP_MANGLE_DELETE_LAST
:
20358 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20361 case RULE_OP_MANGLE_DELETE_AT
:
20362 NEXT_RULEPOS (rule_pos
);
20363 NEXT_RPTOI (rule
, rule_pos
, upos
);
20364 out_len
= mangle_delete_at (out
, out_len
, upos
);
20367 case RULE_OP_MANGLE_EXTRACT
:
20368 NEXT_RULEPOS (rule_pos
);
20369 NEXT_RPTOI (rule
, rule_pos
, upos
);
20370 NEXT_RULEPOS (rule_pos
);
20371 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20372 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20375 case RULE_OP_MANGLE_OMIT
:
20376 NEXT_RULEPOS (rule_pos
);
20377 NEXT_RPTOI (rule
, rule_pos
, upos
);
20378 NEXT_RULEPOS (rule_pos
);
20379 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20380 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20383 case RULE_OP_MANGLE_INSERT
:
20384 NEXT_RULEPOS (rule_pos
);
20385 NEXT_RPTOI (rule
, rule_pos
, upos
);
20386 NEXT_RULEPOS (rule_pos
);
20387 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20390 case RULE_OP_MANGLE_OVERSTRIKE
:
20391 NEXT_RULEPOS (rule_pos
);
20392 NEXT_RPTOI (rule
, rule_pos
, upos
);
20393 NEXT_RULEPOS (rule_pos
);
20394 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20397 case RULE_OP_MANGLE_TRUNCATE_AT
:
20398 NEXT_RULEPOS (rule_pos
);
20399 NEXT_RPTOI (rule
, rule_pos
, upos
);
20400 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20403 case RULE_OP_MANGLE_REPLACE
:
20404 NEXT_RULEPOS (rule_pos
);
20405 NEXT_RULEPOS (rule_pos
);
20406 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20409 case RULE_OP_MANGLE_PURGECHAR
:
20410 NEXT_RULEPOS (rule_pos
);
20411 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20414 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20418 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20419 NEXT_RULEPOS (rule_pos
);
20420 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20421 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20424 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20425 NEXT_RULEPOS (rule_pos
);
20426 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20427 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20430 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20431 out_len
= mangle_dupechar (out
, out_len
);
20434 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20435 NEXT_RULEPOS (rule_pos
);
20436 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20437 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20440 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20441 NEXT_RULEPOS (rule_pos
);
20442 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20443 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20446 case RULE_OP_MANGLE_SWITCH_FIRST
:
20447 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20450 case RULE_OP_MANGLE_SWITCH_LAST
:
20451 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20454 case RULE_OP_MANGLE_SWITCH_AT
:
20455 NEXT_RULEPOS (rule_pos
);
20456 NEXT_RPTOI (rule
, rule_pos
, upos
);
20457 NEXT_RULEPOS (rule_pos
);
20458 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20459 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20462 case RULE_OP_MANGLE_CHR_SHIFTL
:
20463 NEXT_RULEPOS (rule_pos
);
20464 NEXT_RPTOI (rule
, rule_pos
, upos
);
20465 mangle_chr_shiftl (out
, out_len
, upos
);
20468 case RULE_OP_MANGLE_CHR_SHIFTR
:
20469 NEXT_RULEPOS (rule_pos
);
20470 NEXT_RPTOI (rule
, rule_pos
, upos
);
20471 mangle_chr_shiftr (out
, out_len
, upos
);
20474 case RULE_OP_MANGLE_CHR_INCR
:
20475 NEXT_RULEPOS (rule_pos
);
20476 NEXT_RPTOI (rule
, rule_pos
, upos
);
20477 mangle_chr_incr (out
, out_len
, upos
);
20480 case RULE_OP_MANGLE_CHR_DECR
:
20481 NEXT_RULEPOS (rule_pos
);
20482 NEXT_RPTOI (rule
, rule_pos
, upos
);
20483 mangle_chr_decr (out
, out_len
, upos
);
20486 case RULE_OP_MANGLE_REPLACE_NP1
:
20487 NEXT_RULEPOS (rule_pos
);
20488 NEXT_RPTOI (rule
, rule_pos
, upos
);
20489 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20492 case RULE_OP_MANGLE_REPLACE_NM1
:
20493 NEXT_RULEPOS (rule_pos
);
20494 NEXT_RPTOI (rule
, rule_pos
, upos
);
20495 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20498 case RULE_OP_MANGLE_TITLE
:
20499 out_len
= mangle_title (out
, out_len
);
20502 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20503 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20504 NEXT_RULEPOS (rule_pos
);
20505 NEXT_RPTOI (rule
, rule_pos
, upos
);
20506 NEXT_RULEPOS (rule_pos
);
20507 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20508 NEXT_RULEPOS (rule_pos
);
20509 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20510 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20513 case RULE_OP_MANGLE_APPEND_MEMORY
:
20514 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20515 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20516 memcpy (out
+ out_len
, mem
, mem_len
);
20517 out_len
+= mem_len
;
20520 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20521 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20522 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20523 memcpy (mem
+ mem_len
, out
, out_len
);
20524 out_len
+= mem_len
;
20525 memcpy (out
, mem
, out_len
);
20528 case RULE_OP_MEMORIZE_WORD
:
20529 memcpy (mem
, out
, out_len
);
20533 case RULE_OP_REJECT_LESS
:
20534 NEXT_RULEPOS (rule_pos
);
20535 NEXT_RPTOI (rule
, rule_pos
, upos
);
20536 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20539 case RULE_OP_REJECT_GREATER
:
20540 NEXT_RULEPOS (rule_pos
);
20541 NEXT_RPTOI (rule
, rule_pos
, upos
);
20542 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20545 case RULE_OP_REJECT_CONTAIN
:
20546 NEXT_RULEPOS (rule_pos
);
20547 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20550 case RULE_OP_REJECT_NOT_CONTAIN
:
20551 NEXT_RULEPOS (rule_pos
);
20552 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20555 case RULE_OP_REJECT_EQUAL_FIRST
:
20556 NEXT_RULEPOS (rule_pos
);
20557 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20560 case RULE_OP_REJECT_EQUAL_LAST
:
20561 NEXT_RULEPOS (rule_pos
);
20562 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20565 case RULE_OP_REJECT_EQUAL_AT
:
20566 NEXT_RULEPOS (rule_pos
);
20567 NEXT_RPTOI (rule
, rule_pos
, upos
);
20568 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20569 NEXT_RULEPOS (rule_pos
);
20570 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20573 case RULE_OP_REJECT_CONTAINS
:
20574 NEXT_RULEPOS (rule_pos
);
20575 NEXT_RPTOI (rule
, rule_pos
, upos
);
20576 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20577 NEXT_RULEPOS (rule_pos
);
20578 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20579 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20582 case RULE_OP_REJECT_MEMORY
:
20583 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20587 return (RULE_RC_SYNTAX_ERROR
);
20592 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);