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
) + 1;
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
) + 1;
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 if (binary_size
> 0)
8677 FILE *fp
= fopen (dst
, "wb");
8679 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8690 restore_data_t
*init_restore (int argc
, char **argv
)
8692 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8694 if (data
.restore_disable
== 0)
8696 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8700 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8704 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8713 char pidbin
[BUFSIZ
] = { 0 };
8715 int pidbin_len
= -1;
8718 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8720 FILE *fd
= fopen (pidbin
, "rb");
8724 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8726 pidbin
[pidbin_len
] = 0;
8730 char *argv0_r
= strrchr (argv
[0], '/');
8732 char *pidbin_r
= strrchr (pidbin
, '/');
8734 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8736 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8738 if (strcmp (argv0_r
, pidbin_r
) == 0)
8740 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8747 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8749 char pidbin2
[BUFSIZ
] = { 0 };
8751 int pidbin2_len
= -1;
8753 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8754 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8756 pidbin
[pidbin_len
] = 0;
8757 pidbin2
[pidbin2_len
] = 0;
8761 if (strcmp (pidbin
, pidbin2
) == 0)
8763 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8771 if (rd
->version_bin
< RESTORE_MIN
)
8773 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8780 memset (rd
, 0, sizeof (restore_data_t
));
8782 rd
->version_bin
= VERSION_BIN
;
8785 rd
->pid
= getpid ();
8787 rd
->pid
= GetCurrentProcessId ();
8790 if (getcwd (rd
->cwd
, 255) == NULL
)
8803 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8805 FILE *fp
= fopen (eff_restore_file
, "rb");
8809 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8814 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8816 log_error ("ERROR: cannot read %s", eff_restore_file
);
8821 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8823 for (uint i
= 0; i
< rd
->argc
; i
++)
8825 char buf
[BUFSIZ
] = { 0 };
8827 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8829 log_error ("ERROR: cannot read %s", eff_restore_file
);
8834 size_t len
= strlen (buf
);
8836 if (len
) buf
[len
- 1] = 0;
8838 rd
->argv
[i
] = mystrdup (buf
);
8843 char new_cwd
[1024] = { 0 };
8845 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8849 log_error ("Restore file is corrupted");
8852 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8854 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8856 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8861 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8864 if (chdir (rd
->cwd
))
8866 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8872 u64
get_lowest_words_done ()
8876 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8878 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8880 if (device_param
->skipped
) continue;
8882 const u64 words_done
= device_param
->words_done
;
8884 if (words_done
< words_cur
) words_cur
= words_done
;
8887 // It's possible that a device's workload isn't finished right after a restore-case.
8888 // In that case, this function would return 0 and overwrite the real restore point
8889 // There's also data.words_cur which is set to rd->words_cur but it changes while
8890 // the attack is running therefore we should stick to rd->words_cur.
8891 // Note that -s influences rd->words_cur we should keep a close look on that.
8893 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8898 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8900 u64 words_cur
= get_lowest_words_done ();
8902 rd
->words_cur
= words_cur
;
8904 FILE *fp
= fopen (new_restore_file
, "wb");
8908 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8913 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8915 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8920 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8922 for (uint i
= 0; i
< rd
->argc
; i
++)
8924 fprintf (fp
, "%s", rd
->argv
[i
]);
8930 fsync (fileno (fp
));
8935 void cycle_restore ()
8937 const char *eff_restore_file
= data
.eff_restore_file
;
8938 const char *new_restore_file
= data
.new_restore_file
;
8940 restore_data_t
*rd
= data
.rd
;
8942 write_restore (new_restore_file
, rd
);
8946 memset (&st
, 0, sizeof(st
));
8948 if (stat (eff_restore_file
, &st
) == 0)
8950 if (unlink (eff_restore_file
))
8952 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8956 if (rename (new_restore_file
, eff_restore_file
))
8958 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8962 void check_checkpoint ()
8964 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8966 u64 words_cur
= get_lowest_words_done ();
8968 if (words_cur
!= data
.checkpoint_cur_words
)
8978 uint
set_kernel_accel (uint hash_mode
)
8982 case 0: return GET_ACCEL (0);
8983 case 10: return GET_ACCEL (10);
8984 case 11: return GET_ACCEL (11);
8985 case 12: return GET_ACCEL (12);
8986 case 20: return GET_ACCEL (20);
8987 case 21: return GET_ACCEL (21);
8988 case 22: return GET_ACCEL (22);
8989 case 23: return GET_ACCEL (23);
8990 case 30: return GET_ACCEL (30);
8991 case 40: return GET_ACCEL (40);
8992 case 50: return GET_ACCEL (50);
8993 case 60: return GET_ACCEL (60);
8994 case 100: return GET_ACCEL (100);
8995 case 101: return GET_ACCEL (101);
8996 case 110: return GET_ACCEL (110);
8997 case 111: return GET_ACCEL (111);
8998 case 112: return GET_ACCEL (112);
8999 case 120: return GET_ACCEL (120);
9000 case 121: return GET_ACCEL (121);
9001 case 122: return GET_ACCEL (122);
9002 case 124: return GET_ACCEL (124);
9003 case 130: return GET_ACCEL (130);
9004 case 131: return GET_ACCEL (131);
9005 case 132: return GET_ACCEL (132);
9006 case 133: return GET_ACCEL (133);
9007 case 140: return GET_ACCEL (140);
9008 case 141: return GET_ACCEL (141);
9009 case 150: return GET_ACCEL (150);
9010 case 160: return GET_ACCEL (160);
9011 case 190: return GET_ACCEL (190);
9012 case 200: return GET_ACCEL (200);
9013 case 300: return GET_ACCEL (300);
9014 case 400: return GET_ACCEL (400);
9015 case 500: return GET_ACCEL (500);
9016 case 501: return GET_ACCEL (501);
9017 case 900: return GET_ACCEL (900);
9018 case 910: return GET_ACCEL (910);
9019 case 1000: return GET_ACCEL (1000);
9020 case 1100: return GET_ACCEL (1100);
9021 case 1400: return GET_ACCEL (1400);
9022 case 1410: return GET_ACCEL (1410);
9023 case 1420: return GET_ACCEL (1420);
9024 case 1421: return GET_ACCEL (1421);
9025 case 1430: return GET_ACCEL (1430);
9026 case 1440: return GET_ACCEL (1440);
9027 case 1441: return GET_ACCEL (1441);
9028 case 1450: return GET_ACCEL (1450);
9029 case 1460: return GET_ACCEL (1460);
9030 case 1500: return GET_ACCEL (1500);
9031 case 1600: return GET_ACCEL (1600);
9032 case 1700: return GET_ACCEL (1700);
9033 case 1710: return GET_ACCEL (1710);
9034 case 1711: return GET_ACCEL (1711);
9035 case 1720: return GET_ACCEL (1720);
9036 case 1722: return GET_ACCEL (1722);
9037 case 1730: return GET_ACCEL (1730);
9038 case 1731: return GET_ACCEL (1731);
9039 case 1740: return GET_ACCEL (1740);
9040 case 1750: return GET_ACCEL (1750);
9041 case 1760: return GET_ACCEL (1760);
9042 case 1800: return GET_ACCEL (1800);
9043 case 2100: return GET_ACCEL (2100);
9044 case 2400: return GET_ACCEL (2400);
9045 case 2410: return GET_ACCEL (2410);
9046 case 2500: return GET_ACCEL (2500);
9047 case 2600: return GET_ACCEL (2600);
9048 case 2611: return GET_ACCEL (2611);
9049 case 2612: return GET_ACCEL (2612);
9050 case 2711: return GET_ACCEL (2711);
9051 case 2811: return GET_ACCEL (2811);
9052 case 3000: return GET_ACCEL (3000);
9053 case 3100: return GET_ACCEL (3100);
9054 case 3200: return GET_ACCEL (3200);
9055 case 3710: return GET_ACCEL (3710);
9056 case 3711: return GET_ACCEL (3711);
9057 case 3800: return GET_ACCEL (3800);
9058 case 4300: return GET_ACCEL (4300);
9059 case 4400: return GET_ACCEL (4400);
9060 case 4500: return GET_ACCEL (4500);
9061 case 4700: return GET_ACCEL (4700);
9062 case 4800: return GET_ACCEL (4800);
9063 case 4900: return GET_ACCEL (4900);
9064 case 5000: return GET_ACCEL (5000);
9065 case 5100: return GET_ACCEL (5100);
9066 case 5200: return GET_ACCEL (5200);
9067 case 5300: return GET_ACCEL (5300);
9068 case 5400: return GET_ACCEL (5400);
9069 case 5500: return GET_ACCEL (5500);
9070 case 5600: return GET_ACCEL (5600);
9071 case 5700: return GET_ACCEL (5700);
9072 case 5800: return GET_ACCEL (5800);
9073 case 6000: return GET_ACCEL (6000);
9074 case 6100: return GET_ACCEL (6100);
9075 case 6211: return GET_ACCEL (6211);
9076 case 6212: return GET_ACCEL (6212);
9077 case 6213: return GET_ACCEL (6213);
9078 case 6221: return GET_ACCEL (6221);
9079 case 6222: return GET_ACCEL (6222);
9080 case 6223: return GET_ACCEL (6223);
9081 case 6231: return GET_ACCEL (6231);
9082 case 6232: return GET_ACCEL (6232);
9083 case 6233: return GET_ACCEL (6233);
9084 case 6241: return GET_ACCEL (6241);
9085 case 6242: return GET_ACCEL (6242);
9086 case 6243: return GET_ACCEL (6243);
9087 case 6300: return GET_ACCEL (6300);
9088 case 6400: return GET_ACCEL (6400);
9089 case 6500: return GET_ACCEL (6500);
9090 case 6600: return GET_ACCEL (6600);
9091 case 6700: return GET_ACCEL (6700);
9092 case 6800: return GET_ACCEL (6800);
9093 case 6900: return GET_ACCEL (6900);
9094 case 7100: return GET_ACCEL (7100);
9095 case 7200: return GET_ACCEL (7200);
9096 case 7300: return GET_ACCEL (7300);
9097 case 7400: return GET_ACCEL (7400);
9098 case 7500: return GET_ACCEL (7500);
9099 case 7600: return GET_ACCEL (7600);
9100 case 7700: return GET_ACCEL (7700);
9101 case 7800: return GET_ACCEL (7800);
9102 case 7900: return GET_ACCEL (7900);
9103 case 8000: return GET_ACCEL (8000);
9104 case 8100: return GET_ACCEL (8100);
9105 case 8200: return GET_ACCEL (8200);
9106 case 8300: return GET_ACCEL (8300);
9107 case 8400: return GET_ACCEL (8400);
9108 case 8500: return GET_ACCEL (8500);
9109 case 8600: return GET_ACCEL (8600);
9110 case 8700: return GET_ACCEL (8700);
9111 case 8800: return GET_ACCEL (8800);
9112 case 8900: return GET_ACCEL (8900);
9113 case 9000: return GET_ACCEL (9000);
9114 case 9100: return GET_ACCEL (9100);
9115 case 9200: return GET_ACCEL (9200);
9116 case 9300: return GET_ACCEL (9300);
9117 case 9400: return GET_ACCEL (9400);
9118 case 9500: return GET_ACCEL (9500);
9119 case 9600: return GET_ACCEL (9600);
9120 case 9700: return GET_ACCEL (9700);
9121 case 9710: return GET_ACCEL (9710);
9122 case 9720: return GET_ACCEL (9720);
9123 case 9800: return GET_ACCEL (9800);
9124 case 9810: return GET_ACCEL (9810);
9125 case 9820: return GET_ACCEL (9820);
9126 case 9900: return GET_ACCEL (9900);
9127 case 10000: return GET_ACCEL (10000);
9128 case 10100: return GET_ACCEL (10100);
9129 case 10200: return GET_ACCEL (10200);
9130 case 10300: return GET_ACCEL (10300);
9131 case 10400: return GET_ACCEL (10400);
9132 case 10410: return GET_ACCEL (10410);
9133 case 10420: return GET_ACCEL (10420);
9134 case 10500: return GET_ACCEL (10500);
9135 case 10600: return GET_ACCEL (10600);
9136 case 10700: return GET_ACCEL (10700);
9137 case 10800: return GET_ACCEL (10800);
9138 case 10900: return GET_ACCEL (10900);
9139 case 11000: return GET_ACCEL (11000);
9140 case 11100: return GET_ACCEL (11100);
9141 case 11200: return GET_ACCEL (11200);
9142 case 11300: return GET_ACCEL (11300);
9143 case 11400: return GET_ACCEL (11400);
9144 case 11500: return GET_ACCEL (11500);
9145 case 11600: return GET_ACCEL (11600);
9146 case 11700: return GET_ACCEL (11700);
9147 case 11800: return GET_ACCEL (11800);
9148 case 11900: return GET_ACCEL (11900);
9149 case 12000: return GET_ACCEL (12000);
9150 case 12100: return GET_ACCEL (12100);
9151 case 12200: return GET_ACCEL (12200);
9152 case 12300: return GET_ACCEL (12300);
9153 case 12400: return GET_ACCEL (12400);
9154 case 12500: return GET_ACCEL (12500);
9155 case 12600: return GET_ACCEL (12600);
9156 case 12700: return GET_ACCEL (12700);
9157 case 12800: return GET_ACCEL (12800);
9158 case 12900: return GET_ACCEL (12900);
9159 case 13000: return GET_ACCEL (13000);
9165 uint
set_kernel_loops (uint hash_mode
)
9169 case 0: return GET_LOOPS (0);
9170 case 10: return GET_LOOPS (10);
9171 case 11: return GET_LOOPS (11);
9172 case 12: return GET_LOOPS (12);
9173 case 20: return GET_LOOPS (20);
9174 case 21: return GET_LOOPS (21);
9175 case 22: return GET_LOOPS (22);
9176 case 23: return GET_LOOPS (23);
9177 case 30: return GET_LOOPS (30);
9178 case 40: return GET_LOOPS (40);
9179 case 50: return GET_LOOPS (50);
9180 case 60: return GET_LOOPS (60);
9181 case 100: return GET_LOOPS (100);
9182 case 101: return GET_LOOPS (101);
9183 case 110: return GET_LOOPS (110);
9184 case 111: return GET_LOOPS (111);
9185 case 112: return GET_LOOPS (112);
9186 case 120: return GET_LOOPS (120);
9187 case 121: return GET_LOOPS (121);
9188 case 122: return GET_LOOPS (122);
9189 case 124: return GET_LOOPS (124);
9190 case 130: return GET_LOOPS (130);
9191 case 131: return GET_LOOPS (131);
9192 case 132: return GET_LOOPS (132);
9193 case 133: return GET_LOOPS (133);
9194 case 140: return GET_LOOPS (140);
9195 case 141: return GET_LOOPS (141);
9196 case 150: return GET_LOOPS (150);
9197 case 160: return GET_LOOPS (160);
9198 case 190: return GET_LOOPS (190);
9199 case 200: return GET_LOOPS (200);
9200 case 300: return GET_LOOPS (300);
9201 case 400: return GET_LOOPS (400);
9202 case 500: return GET_LOOPS (500);
9203 case 501: return GET_LOOPS (501);
9204 case 900: return GET_LOOPS (900);
9205 case 910: return GET_LOOPS (910);
9206 case 1000: return GET_LOOPS (1000);
9207 case 1100: return GET_LOOPS (1100);
9208 case 1400: return GET_LOOPS (1400);
9209 case 1410: return GET_LOOPS (1410);
9210 case 1420: return GET_LOOPS (1420);
9211 case 1421: return GET_LOOPS (1421);
9212 case 1430: return GET_LOOPS (1430);
9213 case 1440: return GET_LOOPS (1440);
9214 case 1441: return GET_LOOPS (1441);
9215 case 1450: return GET_LOOPS (1450);
9216 case 1460: return GET_LOOPS (1460);
9217 case 1500: return GET_LOOPS (1500);
9218 case 1600: return GET_LOOPS (1600);
9219 case 1700: return GET_LOOPS (1700);
9220 case 1710: return GET_LOOPS (1710);
9221 case 1711: return GET_LOOPS (1711);
9222 case 1720: return GET_LOOPS (1720);
9223 case 1722: return GET_LOOPS (1722);
9224 case 1730: return GET_LOOPS (1730);
9225 case 1731: return GET_LOOPS (1731);
9226 case 1740: return GET_LOOPS (1740);
9227 case 1750: return GET_LOOPS (1750);
9228 case 1760: return GET_LOOPS (1760);
9229 case 1800: return GET_LOOPS (1800);
9230 case 2100: return GET_LOOPS (2100);
9231 case 2400: return GET_LOOPS (2400);
9232 case 2410: return GET_LOOPS (2410);
9233 case 2500: return GET_LOOPS (2500);
9234 case 2600: return GET_LOOPS (2600);
9235 case 2611: return GET_LOOPS (2611);
9236 case 2612: return GET_LOOPS (2612);
9237 case 2711: return GET_LOOPS (2711);
9238 case 2811: return GET_LOOPS (2811);
9239 case 3000: return GET_LOOPS (3000);
9240 case 3100: return GET_LOOPS (3100);
9241 case 3200: return GET_LOOPS (3200);
9242 case 3710: return GET_LOOPS (3710);
9243 case 3711: return GET_LOOPS (3711);
9244 case 3800: return GET_LOOPS (3800);
9245 case 4300: return GET_LOOPS (4300);
9246 case 4400: return GET_LOOPS (4400);
9247 case 4500: return GET_LOOPS (4500);
9248 case 4700: return GET_LOOPS (4700);
9249 case 4800: return GET_LOOPS (4800);
9250 case 4900: return GET_LOOPS (4900);
9251 case 5000: return GET_LOOPS (5000);
9252 case 5100: return GET_LOOPS (5100);
9253 case 5200: return GET_LOOPS (5200);
9254 case 5300: return GET_LOOPS (5300);
9255 case 5400: return GET_LOOPS (5400);
9256 case 5500: return GET_LOOPS (5500);
9257 case 5600: return GET_LOOPS (5600);
9258 case 5700: return GET_LOOPS (5700);
9259 case 5800: return GET_LOOPS (5800);
9260 case 6000: return GET_LOOPS (6000);
9261 case 6100: return GET_LOOPS (6100);
9262 case 6211: return GET_LOOPS (6211);
9263 case 6212: return GET_LOOPS (6212);
9264 case 6213: return GET_LOOPS (6213);
9265 case 6221: return GET_LOOPS (6221);
9266 case 6222: return GET_LOOPS (6222);
9267 case 6223: return GET_LOOPS (6223);
9268 case 6231: return GET_LOOPS (6231);
9269 case 6232: return GET_LOOPS (6232);
9270 case 6233: return GET_LOOPS (6233);
9271 case 6241: return GET_LOOPS (6241);
9272 case 6242: return GET_LOOPS (6242);
9273 case 6243: return GET_LOOPS (6243);
9274 case 6300: return GET_LOOPS (6300);
9275 case 6400: return GET_LOOPS (6400);
9276 case 6500: return GET_LOOPS (6500);
9277 case 6600: return GET_LOOPS (6600);
9278 case 6700: return GET_LOOPS (6700);
9279 case 6800: return GET_LOOPS (6800);
9280 case 6900: return GET_LOOPS (6900);
9281 case 7100: return GET_LOOPS (7100);
9282 case 7200: return GET_LOOPS (7200);
9283 case 7300: return GET_LOOPS (7300);
9284 case 7400: return GET_LOOPS (7400);
9285 case 7500: return GET_LOOPS (7500);
9286 case 7600: return GET_LOOPS (7600);
9287 case 7700: return GET_LOOPS (7700);
9288 case 7800: return GET_LOOPS (7800);
9289 case 7900: return GET_LOOPS (7900);
9290 case 8000: return GET_LOOPS (8000);
9291 case 8100: return GET_LOOPS (8100);
9292 case 8200: return GET_LOOPS (8200);
9293 case 8300: return GET_LOOPS (8300);
9294 case 8400: return GET_LOOPS (8400);
9295 case 8500: return GET_LOOPS (8500);
9296 case 8600: return GET_LOOPS (8600);
9297 case 8700: return GET_LOOPS (8700);
9298 case 8800: return GET_LOOPS (8800);
9299 case 8900: return GET_LOOPS (8900);
9300 case 9000: return GET_LOOPS (9000);
9301 case 9100: return GET_LOOPS (9100);
9302 case 9200: return GET_LOOPS (9200);
9303 case 9300: return GET_LOOPS (9300);
9304 case 9400: return GET_LOOPS (9400);
9305 case 9500: return GET_LOOPS (9500);
9306 case 9600: return GET_LOOPS (9600);
9307 case 9700: return GET_LOOPS (9700);
9308 case 9710: return GET_LOOPS (9710);
9309 case 9720: return GET_LOOPS (9720);
9310 case 9800: return GET_LOOPS (9800);
9311 case 9810: return GET_LOOPS (9810);
9312 case 9820: return GET_LOOPS (9820);
9313 case 9900: return GET_LOOPS (9900);
9314 case 10000: return GET_LOOPS (10000);
9315 case 10100: return GET_LOOPS (10100);
9316 case 10200: return GET_LOOPS (10200);
9317 case 10300: return GET_LOOPS (10300);
9318 case 10400: return GET_LOOPS (10400);
9319 case 10410: return GET_LOOPS (10410);
9320 case 10420: return GET_LOOPS (10420);
9321 case 10500: return GET_LOOPS (10500);
9322 case 10600: return GET_LOOPS (10600);
9323 case 10700: return GET_LOOPS (10700);
9324 case 10800: return GET_LOOPS (10800);
9325 case 10900: return GET_LOOPS (10900);
9326 case 11000: return GET_LOOPS (11000);
9327 case 11100: return GET_LOOPS (11100);
9328 case 11200: return GET_LOOPS (11200);
9329 case 11300: return GET_LOOPS (11300);
9330 case 11400: return GET_LOOPS (11400);
9331 case 11500: return GET_LOOPS (11500);
9332 case 11600: return GET_LOOPS (11600);
9333 case 11700: return GET_LOOPS (11700);
9334 case 11800: return GET_LOOPS (11800);
9335 case 11900: return GET_LOOPS (11900);
9336 case 12000: return GET_LOOPS (12000);
9337 case 12100: return GET_LOOPS (12100);
9338 case 12200: return GET_LOOPS (12200);
9339 case 12300: return GET_LOOPS (12300);
9340 case 12400: return GET_LOOPS (12400);
9341 case 12500: return GET_LOOPS (12500);
9342 case 12600: return GET_LOOPS (12600);
9343 case 12700: return GET_LOOPS (12700);
9344 case 12800: return GET_LOOPS (12800);
9345 case 12900: return GET_LOOPS (12900);
9346 case 13000: return GET_LOOPS (13000);
9356 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9358 u8 tmp
[256] = { 0 };
9360 if (salt_len
> sizeof (tmp
))
9365 memcpy (tmp
, in
, salt_len
);
9367 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9369 if ((salt_len
% 2) == 0)
9371 u32 new_salt_len
= salt_len
/ 2;
9373 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9378 tmp
[i
] = hex_convert (p1
) << 0;
9379 tmp
[i
] |= hex_convert (p0
) << 4;
9382 salt_len
= new_salt_len
;
9389 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9391 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9394 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9396 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9400 u32
*tmp_uint
= (u32
*) tmp
;
9402 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9403 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9404 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9405 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9406 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9407 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9408 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9409 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9410 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9411 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9413 salt_len
= salt_len
* 2;
9421 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9423 lowercase (tmp
, salt_len
);
9426 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9428 uppercase (tmp
, salt_len
);
9433 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9438 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9443 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9445 u32
*tmp_uint
= (uint
*) tmp
;
9451 for (u32 i
= 0; i
< max
; i
++)
9453 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9456 // Important: we may need to increase the length of memcpy since
9457 // we don't want to "loose" some swapped bytes (could happen if
9458 // they do not perfectly fit in the 4-byte blocks)
9459 // Memcpy does always copy the bytes in the BE order, but since
9460 // we swapped them, some important bytes could be in positions
9461 // we normally skip with the original len
9463 if (len
% 4) len
+= 4 - (len
% 4);
9466 memcpy (out
, tmp
, len
);
9471 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9473 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9475 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9477 u32
*digest
= (u32
*) hash_buf
->digest
;
9479 salt_t
*salt
= hash_buf
->salt
;
9481 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9483 char *iter_pos
= input_buf
+ 4;
9485 salt
->salt_iter
= 1 << atoi (iter_pos
);
9487 char *salt_pos
= strchr (iter_pos
, '$');
9489 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9495 salt
->salt_len
= salt_len
;
9497 u8 tmp_buf
[100] = { 0 };
9499 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9501 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9503 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9505 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9506 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9507 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9508 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9510 char *hash_pos
= salt_pos
+ 22;
9512 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9514 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9516 memcpy (digest
, tmp_buf
, 24);
9518 digest
[0] = byte_swap_32 (digest
[0]);
9519 digest
[1] = byte_swap_32 (digest
[1]);
9520 digest
[2] = byte_swap_32 (digest
[2]);
9521 digest
[3] = byte_swap_32 (digest
[3]);
9522 digest
[4] = byte_swap_32 (digest
[4]);
9523 digest
[5] = byte_swap_32 (digest
[5]);
9525 digest
[5] &= ~0xff; // its just 23 not 24 !
9530 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9532 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9534 u32
*digest
= (u32
*) hash_buf
->digest
;
9536 u8 tmp_buf
[100] = { 0 };
9538 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9540 memcpy (digest
, tmp_buf
, 32);
9542 digest
[0] = byte_swap_32 (digest
[0]);
9543 digest
[1] = byte_swap_32 (digest
[1]);
9544 digest
[2] = byte_swap_32 (digest
[2]);
9545 digest
[3] = byte_swap_32 (digest
[3]);
9546 digest
[4] = byte_swap_32 (digest
[4]);
9547 digest
[5] = byte_swap_32 (digest
[5]);
9548 digest
[6] = byte_swap_32 (digest
[6]);
9549 digest
[7] = byte_swap_32 (digest
[7]);
9551 digest
[0] -= SHA256M_A
;
9552 digest
[1] -= SHA256M_B
;
9553 digest
[2] -= SHA256M_C
;
9554 digest
[3] -= SHA256M_D
;
9555 digest
[4] -= SHA256M_E
;
9556 digest
[5] -= SHA256M_F
;
9557 digest
[6] -= SHA256M_G
;
9558 digest
[7] -= SHA256M_H
;
9563 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9565 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9567 u32
*digest
= (u32
*) hash_buf
->digest
;
9569 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9570 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9572 digest
[0] = byte_swap_32 (digest
[0]);
9573 digest
[1] = byte_swap_32 (digest
[1]);
9577 IP (digest
[0], digest
[1], tt
);
9579 digest
[0] = digest
[0];
9580 digest
[1] = digest
[1];
9587 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9589 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9591 u32
*digest
= (u32
*) hash_buf
->digest
;
9593 salt_t
*salt
= hash_buf
->salt
;
9595 char *hash_pos
= input_buf
+ 8;
9597 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9598 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9599 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9600 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9601 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9603 digest
[0] -= SHA1M_A
;
9604 digest
[1] -= SHA1M_B
;
9605 digest
[2] -= SHA1M_C
;
9606 digest
[3] -= SHA1M_D
;
9607 digest
[4] -= SHA1M_E
;
9611 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9613 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9615 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9617 salt
->salt_len
= salt_len
;
9622 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9624 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9626 u64
*digest
= (u64
*) hash_buf
->digest
;
9628 salt_t
*salt
= hash_buf
->salt
;
9630 char *hash_pos
= input_buf
+ 8;
9632 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9633 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9634 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9635 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9636 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9637 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9638 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9639 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9641 digest
[0] -= SHA512M_A
;
9642 digest
[1] -= SHA512M_B
;
9643 digest
[2] -= SHA512M_C
;
9644 digest
[3] -= SHA512M_D
;
9645 digest
[4] -= SHA512M_E
;
9646 digest
[5] -= SHA512M_F
;
9647 digest
[6] -= SHA512M_G
;
9648 digest
[7] -= SHA512M_H
;
9652 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9654 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9656 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9658 salt
->salt_len
= salt_len
;
9663 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9665 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9667 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9671 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9674 u32
*digest
= (u32
*) hash_buf
->digest
;
9676 salt_t
*salt
= hash_buf
->salt
;
9678 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9679 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9680 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9681 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9683 digest
[0] = byte_swap_32 (digest
[0]);
9684 digest
[1] = byte_swap_32 (digest
[1]);
9685 digest
[2] = byte_swap_32 (digest
[2]);
9686 digest
[3] = byte_swap_32 (digest
[3]);
9688 digest
[0] -= MD5M_A
;
9689 digest
[1] -= MD5M_B
;
9690 digest
[2] -= MD5M_C
;
9691 digest
[3] -= MD5M_D
;
9693 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9695 uint salt_len
= input_len
- 32 - 1;
9697 char *salt_buf
= input_buf
+ 32 + 1;
9699 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9701 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9703 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9705 salt
->salt_len
= salt_len
;
9710 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9712 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9714 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9718 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9723 char clean_input_buf
[32] = { 0 };
9725 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9726 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9728 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9732 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9738 clean_input_buf
[k
] = input_buf
[i
];
9746 u32
*digest
= (u32
*) hash_buf
->digest
;
9748 salt_t
*salt
= hash_buf
->salt
;
9750 u32 a
, b
, c
, d
, e
, f
;
9752 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9753 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9754 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9755 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9756 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9757 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9759 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9760 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9762 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9763 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9764 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9765 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9766 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9767 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9769 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9770 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9772 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9773 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9774 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9775 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9776 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9777 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9779 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9780 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9782 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9783 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9784 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9785 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9786 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9787 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9789 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9790 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9792 digest
[0] = byte_swap_32 (digest
[0]);
9793 digest
[1] = byte_swap_32 (digest
[1]);
9794 digest
[2] = byte_swap_32 (digest
[2]);
9795 digest
[3] = byte_swap_32 (digest
[3]);
9797 digest
[0] -= MD5M_A
;
9798 digest
[1] -= MD5M_B
;
9799 digest
[2] -= MD5M_C
;
9800 digest
[3] -= MD5M_D
;
9802 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9804 uint salt_len
= input_len
- 30 - 1;
9806 char *salt_buf
= input_buf
+ 30 + 1;
9808 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9810 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9812 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9813 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9815 salt
->salt_len
= salt_len
;
9817 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9819 salt
->salt_len
+= 22;
9824 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9826 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9828 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9832 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9835 u32
*digest
= (u32
*) hash_buf
->digest
;
9837 salt_t
*salt
= hash_buf
->salt
;
9839 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9840 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9841 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9842 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9843 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9845 digest
[0] -= SHA1M_A
;
9846 digest
[1] -= SHA1M_B
;
9847 digest
[2] -= SHA1M_C
;
9848 digest
[3] -= SHA1M_D
;
9849 digest
[4] -= SHA1M_E
;
9851 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9853 uint salt_len
= input_len
- 40 - 1;
9855 char *salt_buf
= input_buf
+ 40 + 1;
9857 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9859 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9861 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9863 salt
->salt_len
= salt_len
;
9868 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9870 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9872 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9876 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9879 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9881 char *iter_pos
= input_buf
+ 6;
9883 salt_t
*salt
= hash_buf
->salt
;
9885 uint iter
= atoi (iter_pos
);
9892 salt
->salt_iter
= iter
- 1;
9894 char *salt_pos
= strchr (iter_pos
, '#');
9896 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9900 char *digest_pos
= strchr (salt_pos
, '#');
9902 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9906 uint salt_len
= digest_pos
- salt_pos
- 1;
9908 u32
*digest
= (u32
*) hash_buf
->digest
;
9910 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9911 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9912 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9913 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9915 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9917 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9919 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9921 salt
->salt_len
= salt_len
;
9926 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9928 u32
*digest
= (u32
*) hash_buf
->digest
;
9930 salt_t
*salt
= hash_buf
->salt
;
9932 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9936 memcpy (&in
, input_buf
, input_len
);
9938 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9940 memcpy (digest
, in
.keymic
, 16);
9943 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9944 The phrase "Pairwise key expansion"
9945 Access Point Address (referred to as Authenticator Address AA)
9946 Supplicant Address (referred to as Supplicant Address SA)
9947 Access Point Nonce (referred to as Authenticator Anonce)
9948 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9951 uint salt_len
= strlen (in
.essid
);
9953 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9955 salt
->salt_len
= salt_len
;
9957 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9959 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9961 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9963 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9965 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9966 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9970 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9971 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9974 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9976 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9977 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9981 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9982 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9985 for (int i
= 0; i
< 25; i
++)
9987 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9990 wpa
->keyver
= in
.keyver
;
9992 if (wpa
->keyver
> 255)
9994 log_info ("ATTENTION!");
9995 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9996 log_info (" This could be due to a recent aircrack-ng bug.");
9997 log_info (" The key version was automatically reset to a reasonable value.");
10000 wpa
->keyver
&= 0xff;
10003 wpa
->eapol_size
= in
.eapol_size
;
10005 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10007 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10009 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10011 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10013 if (wpa
->keyver
== 1)
10019 digest
[0] = byte_swap_32 (digest
[0]);
10020 digest
[1] = byte_swap_32 (digest
[1]);
10021 digest
[2] = byte_swap_32 (digest
[2]);
10022 digest
[3] = byte_swap_32 (digest
[3]);
10024 for (int i
= 0; i
< 64; i
++)
10026 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10030 salt
->salt_buf
[10] = digest
[1];
10031 salt
->salt_buf
[11] = digest
[2];
10033 return (PARSER_OK
);
10036 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10038 u32
*digest
= (u32
*) hash_buf
->digest
;
10040 salt_t
*salt
= hash_buf
->salt
;
10042 if (input_len
== 0)
10044 log_error ("Password Safe v2 container not specified");
10049 FILE *fp
= fopen (input_buf
, "rb");
10053 log_error ("%s: %s", input_buf
, strerror (errno
));
10060 memset (&buf
, 0, sizeof (psafe2_hdr
));
10062 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10066 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10068 salt
->salt_buf
[0] = buf
.random
[0];
10069 salt
->salt_buf
[1] = buf
.random
[1];
10071 salt
->salt_len
= 8;
10072 salt
->salt_iter
= 1000;
10074 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10075 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10076 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10077 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10078 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10080 return (PARSER_OK
);
10083 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10085 u32
*digest
= (u32
*) hash_buf
->digest
;
10087 salt_t
*salt
= hash_buf
->salt
;
10089 if (input_len
== 0)
10091 log_error (".psafe3 not specified");
10096 FILE *fp
= fopen (input_buf
, "rb");
10100 log_error ("%s: %s", input_buf
, strerror (errno
));
10107 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10111 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10113 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10115 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10117 salt
->salt_iter
= in
.iterations
+ 1;
10119 salt
->salt_buf
[0] = in
.salt_buf
[0];
10120 salt
->salt_buf
[1] = in
.salt_buf
[1];
10121 salt
->salt_buf
[2] = in
.salt_buf
[2];
10122 salt
->salt_buf
[3] = in
.salt_buf
[3];
10123 salt
->salt_buf
[4] = in
.salt_buf
[4];
10124 salt
->salt_buf
[5] = in
.salt_buf
[5];
10125 salt
->salt_buf
[6] = in
.salt_buf
[6];
10126 salt
->salt_buf
[7] = in
.salt_buf
[7];
10128 salt
->salt_len
= 32;
10130 digest
[0] = in
.hash_buf
[0];
10131 digest
[1] = in
.hash_buf
[1];
10132 digest
[2] = in
.hash_buf
[2];
10133 digest
[3] = in
.hash_buf
[3];
10134 digest
[4] = in
.hash_buf
[4];
10135 digest
[5] = in
.hash_buf
[5];
10136 digest
[6] = in
.hash_buf
[6];
10137 digest
[7] = in
.hash_buf
[7];
10139 digest
[0] = byte_swap_32 (digest
[0]);
10140 digest
[1] = byte_swap_32 (digest
[1]);
10141 digest
[2] = byte_swap_32 (digest
[2]);
10142 digest
[3] = byte_swap_32 (digest
[3]);
10143 digest
[4] = byte_swap_32 (digest
[4]);
10144 digest
[5] = byte_swap_32 (digest
[5]);
10145 digest
[6] = byte_swap_32 (digest
[6]);
10146 digest
[7] = byte_swap_32 (digest
[7]);
10148 return (PARSER_OK
);
10151 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10153 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10155 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10157 u32
*digest
= (u32
*) hash_buf
->digest
;
10159 salt_t
*salt
= hash_buf
->salt
;
10161 char *iter_pos
= input_buf
+ 3;
10163 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10165 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10167 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10169 salt
->salt_iter
= salt_iter
;
10171 char *salt_pos
= iter_pos
+ 1;
10175 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10177 salt
->salt_len
= salt_len
;
10179 char *hash_pos
= salt_pos
+ salt_len
;
10181 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10183 return (PARSER_OK
);
10186 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10188 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10190 u32
*digest
= (u32
*) hash_buf
->digest
;
10192 salt_t
*salt
= hash_buf
->salt
;
10194 char *salt_pos
= input_buf
+ 3;
10196 uint iterations_len
= 0;
10198 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10202 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10204 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10205 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10209 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10213 iterations_len
+= 8;
10217 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10220 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10222 char *hash_pos
= strchr (salt_pos
, '$');
10224 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10226 uint salt_len
= hash_pos
- salt_pos
;
10228 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10230 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10232 salt
->salt_len
= salt_len
;
10236 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10238 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10240 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10242 return (PARSER_OK
);
10245 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10247 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10249 u32
*digest
= (u32
*) hash_buf
->digest
;
10251 salt_t
*salt
= hash_buf
->salt
;
10253 char *salt_pos
= input_buf
+ 6;
10255 uint iterations_len
= 0;
10257 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10261 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10263 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10264 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10268 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10272 iterations_len
+= 8;
10276 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10279 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10281 char *hash_pos
= strchr (salt_pos
, '$');
10283 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10285 uint salt_len
= hash_pos
- salt_pos
;
10287 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10289 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10291 salt
->salt_len
= salt_len
;
10295 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10297 return (PARSER_OK
);
10300 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10302 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10304 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10306 u32
*digest
= (u32
*) hash_buf
->digest
;
10308 salt_t
*salt
= hash_buf
->salt
;
10310 char *salt_pos
= input_buf
+ 14;
10312 char *hash_pos
= strchr (salt_pos
, '*');
10314 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10318 uint salt_len
= hash_pos
- salt_pos
- 1;
10320 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10322 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10324 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10326 salt
->salt_len
= salt_len
;
10328 u8 tmp_buf
[100] = { 0 };
10330 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10332 memcpy (digest
, tmp_buf
, 20);
10334 digest
[0] = byte_swap_32 (digest
[0]);
10335 digest
[1] = byte_swap_32 (digest
[1]);
10336 digest
[2] = byte_swap_32 (digest
[2]);
10337 digest
[3] = byte_swap_32 (digest
[3]);
10338 digest
[4] = byte_swap_32 (digest
[4]);
10340 digest
[0] -= SHA1M_A
;
10341 digest
[1] -= SHA1M_B
;
10342 digest
[2] -= SHA1M_C
;
10343 digest
[3] -= SHA1M_D
;
10344 digest
[4] -= SHA1M_E
;
10346 return (PARSER_OK
);
10349 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10351 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10353 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10355 if (c12
& 3) return (PARSER_HASH_VALUE
);
10357 u32
*digest
= (u32
*) hash_buf
->digest
;
10359 salt_t
*salt
= hash_buf
->salt
;
10361 // for ascii_digest
10362 salt
->salt_sign
[0] = input_buf
[0];
10363 salt
->salt_sign
[1] = input_buf
[1];
10365 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10366 | itoa64_to_int (input_buf
[1]) << 6;
10368 salt
->salt_len
= 2;
10370 u8 tmp_buf
[100] = { 0 };
10372 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10374 memcpy (digest
, tmp_buf
, 8);
10378 IP (digest
[0], digest
[1], tt
);
10383 return (PARSER_OK
);
10386 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10388 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10390 u32
*digest
= (u32
*) hash_buf
->digest
;
10392 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10393 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10394 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10395 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10397 digest
[0] = byte_swap_32 (digest
[0]);
10398 digest
[1] = byte_swap_32 (digest
[1]);
10399 digest
[2] = byte_swap_32 (digest
[2]);
10400 digest
[3] = byte_swap_32 (digest
[3]);
10402 digest
[0] -= MD4M_A
;
10403 digest
[1] -= MD4M_B
;
10404 digest
[2] -= MD4M_C
;
10405 digest
[3] -= MD4M_D
;
10407 return (PARSER_OK
);
10410 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10412 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10414 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10418 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10421 u32
*digest
= (u32
*) hash_buf
->digest
;
10423 salt_t
*salt
= hash_buf
->salt
;
10425 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10426 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10427 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10428 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10430 digest
[0] = byte_swap_32 (digest
[0]);
10431 digest
[1] = byte_swap_32 (digest
[1]);
10432 digest
[2] = byte_swap_32 (digest
[2]);
10433 digest
[3] = byte_swap_32 (digest
[3]);
10435 digest
[0] -= MD4M_A
;
10436 digest
[1] -= MD4M_B
;
10437 digest
[2] -= MD4M_C
;
10438 digest
[3] -= MD4M_D
;
10440 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10442 uint salt_len
= input_len
- 32 - 1;
10444 char *salt_buf
= input_buf
+ 32 + 1;
10446 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10448 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10450 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10452 salt
->salt_len
= salt_len
;
10454 return (PARSER_OK
);
10457 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10459 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10461 u32
*digest
= (u32
*) hash_buf
->digest
;
10463 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10464 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10465 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10466 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10468 digest
[0] = byte_swap_32 (digest
[0]);
10469 digest
[1] = byte_swap_32 (digest
[1]);
10470 digest
[2] = byte_swap_32 (digest
[2]);
10471 digest
[3] = byte_swap_32 (digest
[3]);
10473 digest
[0] -= MD5M_A
;
10474 digest
[1] -= MD5M_B
;
10475 digest
[2] -= MD5M_C
;
10476 digest
[3] -= MD5M_D
;
10478 return (PARSER_OK
);
10481 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10483 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10485 u32
*digest
= (u32
*) hash_buf
->digest
;
10487 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10488 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10492 digest
[0] = byte_swap_32 (digest
[0]);
10493 digest
[1] = byte_swap_32 (digest
[1]);
10495 return (PARSER_OK
);
10498 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10500 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10502 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10506 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10509 u32
*digest
= (u32
*) hash_buf
->digest
;
10511 salt_t
*salt
= hash_buf
->salt
;
10513 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10514 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10515 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10516 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10518 digest
[0] = byte_swap_32 (digest
[0]);
10519 digest
[1] = byte_swap_32 (digest
[1]);
10520 digest
[2] = byte_swap_32 (digest
[2]);
10521 digest
[3] = byte_swap_32 (digest
[3]);
10523 digest
[0] -= MD5M_A
;
10524 digest
[1] -= MD5M_B
;
10525 digest
[2] -= MD5M_C
;
10526 digest
[3] -= MD5M_D
;
10528 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10530 uint salt_len
= input_len
- 32 - 1;
10532 char *salt_buf
= input_buf
+ 32 + 1;
10534 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10536 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10538 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10540 salt
->salt_len
= salt_len
;
10542 return (PARSER_OK
);
10545 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10547 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10549 u32
*digest
= (u32
*) hash_buf
->digest
;
10551 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10552 | itoa64_to_int (input_buf
[ 1]) << 6
10553 | itoa64_to_int (input_buf
[ 2]) << 12
10554 | itoa64_to_int (input_buf
[ 3]) << 18;
10555 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10556 | itoa64_to_int (input_buf
[ 5]) << 6
10557 | itoa64_to_int (input_buf
[ 6]) << 12
10558 | itoa64_to_int (input_buf
[ 7]) << 18;
10559 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10560 | itoa64_to_int (input_buf
[ 9]) << 6
10561 | itoa64_to_int (input_buf
[10]) << 12
10562 | itoa64_to_int (input_buf
[11]) << 18;
10563 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10564 | itoa64_to_int (input_buf
[13]) << 6
10565 | itoa64_to_int (input_buf
[14]) << 12
10566 | itoa64_to_int (input_buf
[15]) << 18;
10568 digest
[0] -= MD5M_A
;
10569 digest
[1] -= MD5M_B
;
10570 digest
[2] -= MD5M_C
;
10571 digest
[3] -= MD5M_D
;
10573 digest
[0] &= 0x00ffffff;
10574 digest
[1] &= 0x00ffffff;
10575 digest
[2] &= 0x00ffffff;
10576 digest
[3] &= 0x00ffffff;
10578 return (PARSER_OK
);
10581 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10583 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10585 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10589 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10592 u32
*digest
= (u32
*) hash_buf
->digest
;
10594 salt_t
*salt
= hash_buf
->salt
;
10596 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10597 | itoa64_to_int (input_buf
[ 1]) << 6
10598 | itoa64_to_int (input_buf
[ 2]) << 12
10599 | itoa64_to_int (input_buf
[ 3]) << 18;
10600 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10601 | itoa64_to_int (input_buf
[ 5]) << 6
10602 | itoa64_to_int (input_buf
[ 6]) << 12
10603 | itoa64_to_int (input_buf
[ 7]) << 18;
10604 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10605 | itoa64_to_int (input_buf
[ 9]) << 6
10606 | itoa64_to_int (input_buf
[10]) << 12
10607 | itoa64_to_int (input_buf
[11]) << 18;
10608 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10609 | itoa64_to_int (input_buf
[13]) << 6
10610 | itoa64_to_int (input_buf
[14]) << 12
10611 | itoa64_to_int (input_buf
[15]) << 18;
10613 digest
[0] -= MD5M_A
;
10614 digest
[1] -= MD5M_B
;
10615 digest
[2] -= MD5M_C
;
10616 digest
[3] -= MD5M_D
;
10618 digest
[0] &= 0x00ffffff;
10619 digest
[1] &= 0x00ffffff;
10620 digest
[2] &= 0x00ffffff;
10621 digest
[3] &= 0x00ffffff;
10623 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10625 uint salt_len
= input_len
- 16 - 1;
10627 char *salt_buf
= input_buf
+ 16 + 1;
10629 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10631 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10633 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10635 salt
->salt_len
= salt_len
;
10637 return (PARSER_OK
);
10640 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10642 key
[0] = (nthash
[0] >> 0);
10643 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10644 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10645 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10646 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10647 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10648 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10649 key
[7] = (nthash
[6] << 1);
10661 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10663 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10665 u32
*digest
= (u32
*) hash_buf
->digest
;
10667 salt_t
*salt
= hash_buf
->salt
;
10669 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10675 char *user_pos
= input_buf
;
10677 char *unused_pos
= strchr (user_pos
, ':');
10679 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10681 uint user_len
= unused_pos
- user_pos
;
10683 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10687 char *domain_pos
= strchr (unused_pos
, ':');
10689 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10691 uint unused_len
= domain_pos
- unused_pos
;
10693 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10697 char *srvchall_pos
= strchr (domain_pos
, ':');
10699 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10701 uint domain_len
= srvchall_pos
- domain_pos
;
10703 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10707 char *hash_pos
= strchr (srvchall_pos
, ':');
10709 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10711 uint srvchall_len
= hash_pos
- srvchall_pos
;
10713 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10717 char *clichall_pos
= strchr (hash_pos
, ':');
10719 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10721 uint hash_len
= clichall_pos
- hash_pos
;
10723 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10727 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10729 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10732 * store some data for later use
10735 netntlm
->user_len
= user_len
* 2;
10736 netntlm
->domain_len
= domain_len
* 2;
10737 netntlm
->srvchall_len
= srvchall_len
/ 2;
10738 netntlm
->clichall_len
= clichall_len
/ 2;
10740 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10741 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10744 * handle username and domainname
10747 for (uint i
= 0; i
< user_len
; i
++)
10749 *userdomain_ptr
++ = user_pos
[i
];
10750 *userdomain_ptr
++ = 0;
10753 for (uint i
= 0; i
< domain_len
; i
++)
10755 *userdomain_ptr
++ = domain_pos
[i
];
10756 *userdomain_ptr
++ = 0;
10760 * handle server challenge encoding
10763 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10765 const char p0
= srvchall_pos
[i
+ 0];
10766 const char p1
= srvchall_pos
[i
+ 1];
10768 *chall_ptr
++ = hex_convert (p1
) << 0
10769 | hex_convert (p0
) << 4;
10773 * handle client challenge encoding
10776 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10778 const char p0
= clichall_pos
[i
+ 0];
10779 const char p1
= clichall_pos
[i
+ 1];
10781 *chall_ptr
++ = hex_convert (p1
) << 0
10782 | hex_convert (p0
) << 4;
10789 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10791 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10793 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10795 salt
->salt_len
= salt_len
;
10797 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10798 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10799 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10800 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10802 digest
[0] = byte_swap_32 (digest
[0]);
10803 digest
[1] = byte_swap_32 (digest
[1]);
10804 digest
[2] = byte_swap_32 (digest
[2]);
10805 digest
[3] = byte_swap_32 (digest
[3]);
10807 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10809 uint digest_tmp
[2] = { 0 };
10811 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10812 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10814 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10815 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10817 /* special case 2: ESS */
10819 if (srvchall_len
== 48)
10821 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10823 uint w
[16] = { 0 };
10825 w
[ 0] = netntlm
->chall_buf
[6];
10826 w
[ 1] = netntlm
->chall_buf
[7];
10827 w
[ 2] = netntlm
->chall_buf
[0];
10828 w
[ 3] = netntlm
->chall_buf
[1];
10832 uint dgst
[4] = { 0 };
10841 salt
->salt_buf
[0] = dgst
[0];
10842 salt
->salt_buf
[1] = dgst
[1];
10846 /* precompute netntlmv1 exploit start */
10848 for (uint i
= 0; i
< 0x10000; i
++)
10850 uint key_md4
[2] = { i
, 0 };
10851 uint key_des
[2] = { 0, 0 };
10853 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10855 uint Kc
[16] = { 0 };
10856 uint Kd
[16] = { 0 };
10858 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10860 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10862 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10864 if (data3
[0] != digest_tmp
[0]) continue;
10865 if (data3
[1] != digest_tmp
[1]) continue;
10867 salt
->salt_buf
[2] = i
;
10869 salt
->salt_len
= 24;
10874 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10875 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10877 /* precompute netntlmv1 exploit stop */
10881 IP (digest
[0], digest
[1], tt
);
10882 IP (digest
[2], digest
[3], tt
);
10884 digest
[0] = rotr32 (digest
[0], 29);
10885 digest
[1] = rotr32 (digest
[1], 29);
10886 digest
[2] = rotr32 (digest
[2], 29);
10887 digest
[3] = rotr32 (digest
[3], 29);
10889 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10891 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10892 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10894 return (PARSER_OK
);
10897 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10899 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10901 u32
*digest
= (u32
*) hash_buf
->digest
;
10903 salt_t
*salt
= hash_buf
->salt
;
10905 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10911 char *user_pos
= input_buf
;
10913 char *unused_pos
= strchr (user_pos
, ':');
10915 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10917 uint user_len
= unused_pos
- user_pos
;
10919 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10923 char *domain_pos
= strchr (unused_pos
, ':');
10925 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10927 uint unused_len
= domain_pos
- unused_pos
;
10929 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10933 char *srvchall_pos
= strchr (domain_pos
, ':');
10935 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10937 uint domain_len
= srvchall_pos
- domain_pos
;
10939 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10943 char *hash_pos
= strchr (srvchall_pos
, ':');
10945 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10947 uint srvchall_len
= hash_pos
- srvchall_pos
;
10949 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10953 char *clichall_pos
= strchr (hash_pos
, ':');
10955 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10957 uint hash_len
= clichall_pos
- hash_pos
;
10959 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10963 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10965 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10967 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10970 * store some data for later use
10973 netntlm
->user_len
= user_len
* 2;
10974 netntlm
->domain_len
= domain_len
* 2;
10975 netntlm
->srvchall_len
= srvchall_len
/ 2;
10976 netntlm
->clichall_len
= clichall_len
/ 2;
10978 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10979 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10982 * handle username and domainname
10985 for (uint i
= 0; i
< user_len
; i
++)
10987 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10988 *userdomain_ptr
++ = 0;
10991 for (uint i
= 0; i
< domain_len
; i
++)
10993 *userdomain_ptr
++ = domain_pos
[i
];
10994 *userdomain_ptr
++ = 0;
10997 *userdomain_ptr
++ = 0x80;
11000 * handle server challenge encoding
11003 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11005 const char p0
= srvchall_pos
[i
+ 0];
11006 const char p1
= srvchall_pos
[i
+ 1];
11008 *chall_ptr
++ = hex_convert (p1
) << 0
11009 | hex_convert (p0
) << 4;
11013 * handle client challenge encoding
11016 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11018 const char p0
= clichall_pos
[i
+ 0];
11019 const char p1
= clichall_pos
[i
+ 1];
11021 *chall_ptr
++ = hex_convert (p1
) << 0
11022 | hex_convert (p0
) << 4;
11025 *chall_ptr
++ = 0x80;
11028 * handle hash itself
11031 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11032 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11033 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11034 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11036 digest
[0] = byte_swap_32 (digest
[0]);
11037 digest
[1] = byte_swap_32 (digest
[1]);
11038 digest
[2] = byte_swap_32 (digest
[2]);
11039 digest
[3] = byte_swap_32 (digest
[3]);
11042 * reuse challange data as salt_buf, its the buffer that is most likely unique
11045 salt
->salt_buf
[0] = 0;
11046 salt
->salt_buf
[1] = 0;
11047 salt
->salt_buf
[2] = 0;
11048 salt
->salt_buf
[3] = 0;
11049 salt
->salt_buf
[4] = 0;
11050 salt
->salt_buf
[5] = 0;
11051 salt
->salt_buf
[6] = 0;
11052 salt
->salt_buf
[7] = 0;
11056 uptr
= (uint
*) netntlm
->userdomain_buf
;
11058 for (uint i
= 0; i
< 16; i
+= 16)
11060 md5_64 (uptr
, salt
->salt_buf
);
11063 uptr
= (uint
*) netntlm
->chall_buf
;
11065 for (uint i
= 0; i
< 256; i
+= 16)
11067 md5_64 (uptr
, salt
->salt_buf
);
11070 salt
->salt_len
= 16;
11072 return (PARSER_OK
);
11075 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11077 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11079 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11083 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11086 u32
*digest
= (u32
*) hash_buf
->digest
;
11088 salt_t
*salt
= hash_buf
->salt
;
11090 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11091 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11092 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11093 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11095 digest
[0] = byte_swap_32 (digest
[0]);
11096 digest
[1] = byte_swap_32 (digest
[1]);
11097 digest
[2] = byte_swap_32 (digest
[2]);
11098 digest
[3] = byte_swap_32 (digest
[3]);
11100 digest
[0] -= MD5M_A
;
11101 digest
[1] -= MD5M_B
;
11102 digest
[2] -= MD5M_C
;
11103 digest
[3] -= MD5M_D
;
11105 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11107 uint salt_len
= input_len
- 32 - 1;
11109 char *salt_buf
= input_buf
+ 32 + 1;
11111 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11113 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11115 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11117 salt
->salt_len
= salt_len
;
11119 return (PARSER_OK
);
11122 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11124 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11126 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11130 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11133 u32
*digest
= (u32
*) hash_buf
->digest
;
11135 salt_t
*salt
= hash_buf
->salt
;
11137 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11138 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11139 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11140 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11142 digest
[0] = byte_swap_32 (digest
[0]);
11143 digest
[1] = byte_swap_32 (digest
[1]);
11144 digest
[2] = byte_swap_32 (digest
[2]);
11145 digest
[3] = byte_swap_32 (digest
[3]);
11147 digest
[0] -= MD5M_A
;
11148 digest
[1] -= MD5M_B
;
11149 digest
[2] -= MD5M_C
;
11150 digest
[3] -= MD5M_D
;
11152 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11154 uint salt_len
= input_len
- 32 - 1;
11156 char *salt_buf
= input_buf
+ 32 + 1;
11158 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11160 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11162 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11164 salt
->salt_len
= salt_len
;
11166 return (PARSER_OK
);
11169 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11171 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11173 u32
*digest
= (u32
*) hash_buf
->digest
;
11175 salt_t
*salt
= hash_buf
->salt
;
11177 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11178 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11179 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11180 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11182 digest
[0] = byte_swap_32 (digest
[0]);
11183 digest
[1] = byte_swap_32 (digest
[1]);
11184 digest
[2] = byte_swap_32 (digest
[2]);
11185 digest
[3] = byte_swap_32 (digest
[3]);
11187 digest
[0] -= MD5M_A
;
11188 digest
[1] -= MD5M_B
;
11189 digest
[2] -= MD5M_C
;
11190 digest
[3] -= MD5M_D
;
11193 * This is a virtual salt. While the algorithm is basically not salted
11194 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11195 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11198 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11200 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11202 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11204 salt
->salt_len
= salt_len
;
11206 return (PARSER_OK
);
11209 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11211 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11213 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11217 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11220 u32
*digest
= (u32
*) hash_buf
->digest
;
11222 salt_t
*salt
= hash_buf
->salt
;
11224 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11225 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11226 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11227 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11229 digest
[0] = byte_swap_32 (digest
[0]);
11230 digest
[1] = byte_swap_32 (digest
[1]);
11231 digest
[2] = byte_swap_32 (digest
[2]);
11232 digest
[3] = byte_swap_32 (digest
[3]);
11234 digest
[0] -= MD5M_A
;
11235 digest
[1] -= MD5M_B
;
11236 digest
[2] -= MD5M_C
;
11237 digest
[3] -= MD5M_D
;
11239 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11241 uint salt_len
= input_len
- 32 - 1;
11243 char *salt_buf
= input_buf
+ 32 + 1;
11245 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11247 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11249 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11251 salt
->salt_len
= salt_len
;
11253 return (PARSER_OK
);
11256 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11258 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11260 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11264 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11267 u32
*digest
= (u32
*) hash_buf
->digest
;
11269 salt_t
*salt
= hash_buf
->salt
;
11271 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11272 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11273 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11274 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11276 digest
[0] = byte_swap_32 (digest
[0]);
11277 digest
[1] = byte_swap_32 (digest
[1]);
11278 digest
[2] = byte_swap_32 (digest
[2]);
11279 digest
[3] = byte_swap_32 (digest
[3]);
11281 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11283 uint salt_len
= input_len
- 32 - 1;
11285 char *salt_buf
= input_buf
+ 32 + 1;
11287 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11289 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11291 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11293 salt
->salt_len
= salt_len
;
11295 return (PARSER_OK
);
11298 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11300 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11302 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11306 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11309 u32
*digest
= (u32
*) hash_buf
->digest
;
11311 salt_t
*salt
= hash_buf
->salt
;
11313 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11314 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11315 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11316 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11318 digest
[0] = byte_swap_32 (digest
[0]);
11319 digest
[1] = byte_swap_32 (digest
[1]);
11320 digest
[2] = byte_swap_32 (digest
[2]);
11321 digest
[3] = byte_swap_32 (digest
[3]);
11323 digest
[0] -= MD4M_A
;
11324 digest
[1] -= MD4M_B
;
11325 digest
[2] -= MD4M_C
;
11326 digest
[3] -= MD4M_D
;
11328 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11330 uint salt_len
= input_len
- 32 - 1;
11332 char *salt_buf
= input_buf
+ 32 + 1;
11334 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11336 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11338 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11340 salt
->salt_len
= salt_len
;
11342 return (PARSER_OK
);
11345 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11347 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11349 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11353 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11356 u32
*digest
= (u32
*) hash_buf
->digest
;
11358 salt_t
*salt
= hash_buf
->salt
;
11360 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11361 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11362 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11363 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11365 digest
[0] = byte_swap_32 (digest
[0]);
11366 digest
[1] = byte_swap_32 (digest
[1]);
11367 digest
[2] = byte_swap_32 (digest
[2]);
11368 digest
[3] = byte_swap_32 (digest
[3]);
11370 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11372 uint salt_len
= input_len
- 32 - 1;
11374 char *salt_buf
= input_buf
+ 32 + 1;
11376 uint salt_pc_block
[16] = { 0 };
11378 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11380 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11382 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11384 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11386 salt_pc_block
[14] = salt_len
* 8;
11388 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11390 md5_64 (salt_pc_block
, salt_pc_digest
);
11392 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11393 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11394 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11395 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11397 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11399 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11401 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11403 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11404 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11405 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11406 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11408 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11410 return (PARSER_OK
);
11413 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11415 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11417 u32
*digest
= (u32
*) hash_buf
->digest
;
11419 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11420 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11421 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11422 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11423 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11425 digest
[0] -= SHA1M_A
;
11426 digest
[1] -= SHA1M_B
;
11427 digest
[2] -= SHA1M_C
;
11428 digest
[3] -= SHA1M_D
;
11429 digest
[4] -= SHA1M_E
;
11431 return (PARSER_OK
);
11434 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11436 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11438 u32
*digest
= (u32
*) hash_buf
->digest
;
11440 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11441 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11442 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11443 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11444 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11446 return (PARSER_OK
);
11449 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11451 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11453 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11457 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11460 u32
*digest
= (u32
*) hash_buf
->digest
;
11462 salt_t
*salt
= hash_buf
->salt
;
11464 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11465 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11466 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11467 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11468 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11470 digest
[0] -= SHA1M_A
;
11471 digest
[1] -= SHA1M_B
;
11472 digest
[2] -= SHA1M_C
;
11473 digest
[3] -= SHA1M_D
;
11474 digest
[4] -= SHA1M_E
;
11476 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11478 uint salt_len
= input_len
- 40 - 1;
11480 char *salt_buf
= input_buf
+ 40 + 1;
11482 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11484 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11486 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11488 salt
->salt_len
= salt_len
;
11490 return (PARSER_OK
);
11493 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11495 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11497 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11499 u32
*digest
= (u32
*) hash_buf
->digest
;
11501 u8 tmp_buf
[100] = { 0 };
11503 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11505 memcpy (digest
, tmp_buf
, 20);
11507 digest
[0] = byte_swap_32 (digest
[0]);
11508 digest
[1] = byte_swap_32 (digest
[1]);
11509 digest
[2] = byte_swap_32 (digest
[2]);
11510 digest
[3] = byte_swap_32 (digest
[3]);
11511 digest
[4] = byte_swap_32 (digest
[4]);
11513 digest
[0] -= SHA1M_A
;
11514 digest
[1] -= SHA1M_B
;
11515 digest
[2] -= SHA1M_C
;
11516 digest
[3] -= SHA1M_D
;
11517 digest
[4] -= SHA1M_E
;
11519 return (PARSER_OK
);
11522 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11524 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11526 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11528 u32
*digest
= (u32
*) hash_buf
->digest
;
11530 salt_t
*salt
= hash_buf
->salt
;
11532 u8 tmp_buf
[100] = { 0 };
11534 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11536 memcpy (digest
, tmp_buf
, 20);
11538 salt
->salt_len
= tmp_len
- 20;
11540 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11542 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11544 char *ptr
= (char *) salt
->salt_buf
;
11546 ptr
[salt
->salt_len
] = 0x80;
11549 digest
[0] = byte_swap_32 (digest
[0]);
11550 digest
[1] = byte_swap_32 (digest
[1]);
11551 digest
[2] = byte_swap_32 (digest
[2]);
11552 digest
[3] = byte_swap_32 (digest
[3]);
11553 digest
[4] = byte_swap_32 (digest
[4]);
11555 digest
[0] -= SHA1M_A
;
11556 digest
[1] -= SHA1M_B
;
11557 digest
[2] -= SHA1M_C
;
11558 digest
[3] -= SHA1M_D
;
11559 digest
[4] -= SHA1M_E
;
11561 return (PARSER_OK
);
11564 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11566 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11568 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11570 u32
*digest
= (u32
*) hash_buf
->digest
;
11572 salt_t
*salt
= hash_buf
->salt
;
11574 char *salt_buf
= input_buf
+ 6;
11578 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11580 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11582 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11584 salt
->salt_len
= salt_len
;
11586 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11588 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11589 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11590 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11591 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11592 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11594 digest
[0] -= SHA1M_A
;
11595 digest
[1] -= SHA1M_B
;
11596 digest
[2] -= SHA1M_C
;
11597 digest
[3] -= SHA1M_D
;
11598 digest
[4] -= SHA1M_E
;
11600 return (PARSER_OK
);
11603 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11605 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11607 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11609 u32
*digest
= (u32
*) hash_buf
->digest
;
11611 salt_t
*salt
= hash_buf
->salt
;
11613 char *salt_buf
= input_buf
+ 6;
11617 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11619 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11621 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11623 salt
->salt_len
= salt_len
;
11625 char *hash_pos
= input_buf
+ 6 + 8;
11627 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11628 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11629 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11630 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11631 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11633 digest
[0] -= SHA1M_A
;
11634 digest
[1] -= SHA1M_B
;
11635 digest
[2] -= SHA1M_C
;
11636 digest
[3] -= SHA1M_D
;
11637 digest
[4] -= SHA1M_E
;
11639 return (PARSER_OK
);
11642 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11644 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11646 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11648 u64
*digest
= (u64
*) hash_buf
->digest
;
11650 salt_t
*salt
= hash_buf
->salt
;
11652 char *salt_buf
= input_buf
+ 6;
11656 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11658 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11660 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11662 salt
->salt_len
= salt_len
;
11664 char *hash_pos
= input_buf
+ 6 + 8;
11666 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11667 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11668 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11669 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11670 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11671 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11672 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11673 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11675 digest
[0] -= SHA512M_A
;
11676 digest
[1] -= SHA512M_B
;
11677 digest
[2] -= SHA512M_C
;
11678 digest
[3] -= SHA512M_D
;
11679 digest
[4] -= SHA512M_E
;
11680 digest
[5] -= SHA512M_F
;
11681 digest
[6] -= SHA512M_G
;
11682 digest
[7] -= SHA512M_H
;
11684 return (PARSER_OK
);
11687 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11689 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11691 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11695 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11698 u32
*digest
= (u32
*) hash_buf
->digest
;
11700 salt_t
*salt
= hash_buf
->salt
;
11702 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11703 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11707 digest
[0] = byte_swap_32 (digest
[0]);
11708 digest
[1] = byte_swap_32 (digest
[1]);
11710 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11712 uint salt_len
= input_len
- 16 - 1;
11714 char *salt_buf
= input_buf
+ 16 + 1;
11716 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11718 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11720 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11722 salt
->salt_len
= salt_len
;
11724 return (PARSER_OK
);
11727 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11729 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11731 u32
*digest
= (u32
*) hash_buf
->digest
;
11733 salt_t
*salt
= hash_buf
->salt
;
11735 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11736 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11737 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11738 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11739 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11741 digest
[0] -= SHA1M_A
;
11742 digest
[1] -= SHA1M_B
;
11743 digest
[2] -= SHA1M_C
;
11744 digest
[3] -= SHA1M_D
;
11745 digest
[4] -= SHA1M_E
;
11747 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11749 uint salt_len
= input_len
- 40 - 1;
11751 char *salt_buf
= input_buf
+ 40 + 1;
11753 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11755 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11757 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11759 salt
->salt_len
= salt_len
;
11761 return (PARSER_OK
);
11764 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11766 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11768 u32
*digest
= (u32
*) hash_buf
->digest
;
11770 salt_t
*salt
= hash_buf
->salt
;
11772 char *hash_pos
= input_buf
;
11774 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11775 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11776 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11777 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11778 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11779 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11780 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11781 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11782 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11783 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11784 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11785 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11786 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11787 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11788 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11789 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11791 char *salt_pos
= input_buf
+ 128;
11793 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11794 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11795 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11796 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11798 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11799 salt
->salt_len
= 16;
11801 return (PARSER_OK
);
11804 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11806 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11808 u32
*digest
= (u32
*) hash_buf
->digest
;
11810 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11811 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11812 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11813 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11814 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11815 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11816 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11817 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11819 digest
[0] -= SHA256M_A
;
11820 digest
[1] -= SHA256M_B
;
11821 digest
[2] -= SHA256M_C
;
11822 digest
[3] -= SHA256M_D
;
11823 digest
[4] -= SHA256M_E
;
11824 digest
[5] -= SHA256M_F
;
11825 digest
[6] -= SHA256M_G
;
11826 digest
[7] -= SHA256M_H
;
11828 return (PARSER_OK
);
11831 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11833 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11835 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11839 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11842 u32
*digest
= (u32
*) hash_buf
->digest
;
11844 salt_t
*salt
= hash_buf
->salt
;
11846 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11847 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11848 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11849 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11850 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11851 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11852 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11853 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11855 digest
[0] -= SHA256M_A
;
11856 digest
[1] -= SHA256M_B
;
11857 digest
[2] -= SHA256M_C
;
11858 digest
[3] -= SHA256M_D
;
11859 digest
[4] -= SHA256M_E
;
11860 digest
[5] -= SHA256M_F
;
11861 digest
[6] -= SHA256M_G
;
11862 digest
[7] -= SHA256M_H
;
11864 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11866 uint salt_len
= input_len
- 64 - 1;
11868 char *salt_buf
= input_buf
+ 64 + 1;
11870 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11872 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11874 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11876 salt
->salt_len
= salt_len
;
11878 return (PARSER_OK
);
11881 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11883 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11885 u64
*digest
= (u64
*) hash_buf
->digest
;
11887 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11888 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11889 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11890 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11891 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11892 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11896 digest
[0] -= SHA384M_A
;
11897 digest
[1] -= SHA384M_B
;
11898 digest
[2] -= SHA384M_C
;
11899 digest
[3] -= SHA384M_D
;
11900 digest
[4] -= SHA384M_E
;
11901 digest
[5] -= SHA384M_F
;
11905 return (PARSER_OK
);
11908 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11910 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11912 u64
*digest
= (u64
*) hash_buf
->digest
;
11914 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11915 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11916 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11917 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11918 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11919 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11920 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11921 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11923 digest
[0] -= SHA512M_A
;
11924 digest
[1] -= SHA512M_B
;
11925 digest
[2] -= SHA512M_C
;
11926 digest
[3] -= SHA512M_D
;
11927 digest
[4] -= SHA512M_E
;
11928 digest
[5] -= SHA512M_F
;
11929 digest
[6] -= SHA512M_G
;
11930 digest
[7] -= SHA512M_H
;
11932 return (PARSER_OK
);
11935 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11937 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11939 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11943 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11946 u64
*digest
= (u64
*) hash_buf
->digest
;
11948 salt_t
*salt
= hash_buf
->salt
;
11950 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11951 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11952 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11953 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11954 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11955 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11956 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11957 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11959 digest
[0] -= SHA512M_A
;
11960 digest
[1] -= SHA512M_B
;
11961 digest
[2] -= SHA512M_C
;
11962 digest
[3] -= SHA512M_D
;
11963 digest
[4] -= SHA512M_E
;
11964 digest
[5] -= SHA512M_F
;
11965 digest
[6] -= SHA512M_G
;
11966 digest
[7] -= SHA512M_H
;
11968 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11970 uint salt_len
= input_len
- 128 - 1;
11972 char *salt_buf
= input_buf
+ 128 + 1;
11974 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11976 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11978 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11980 salt
->salt_len
= salt_len
;
11982 return (PARSER_OK
);
11985 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11987 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11989 u64
*digest
= (u64
*) hash_buf
->digest
;
11991 salt_t
*salt
= hash_buf
->salt
;
11993 char *salt_pos
= input_buf
+ 3;
11995 uint iterations_len
= 0;
11997 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12001 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12003 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12004 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12008 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12012 iterations_len
+= 8;
12016 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12019 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12021 char *hash_pos
= strchr (salt_pos
, '$');
12023 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12025 uint salt_len
= hash_pos
- salt_pos
;
12027 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12029 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12031 salt
->salt_len
= salt_len
;
12035 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12037 return (PARSER_OK
);
12040 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12042 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12044 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12046 u64
*digest
= (u64
*) hash_buf
->digest
;
12048 salt_t
*salt
= hash_buf
->salt
;
12050 uint keccak_mdlen
= input_len
/ 2;
12052 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12054 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12056 digest
[i
] = byte_swap_64 (digest
[i
]);
12059 salt
->keccak_mdlen
= keccak_mdlen
;
12061 return (PARSER_OK
);
12064 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12066 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12068 u32
*digest
= (u32
*) hash_buf
->digest
;
12070 salt_t
*salt
= hash_buf
->salt
;
12072 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12075 * Parse that strange long line
12080 size_t in_len
[9] = { 0 };
12082 in_off
[0] = strtok (input_buf
, ":");
12084 in_len
[0] = strlen (in_off
[0]);
12088 for (i
= 1; i
< 9; i
++)
12090 in_off
[i
] = strtok (NULL
, ":");
12092 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12094 in_len
[i
] = strlen (in_off
[i
]);
12097 char *ptr
= (char *) ikepsk
->msg_buf
;
12099 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12100 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12101 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12102 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12103 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12104 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12108 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12110 ptr
= (char *) ikepsk
->nr_buf
;
12112 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12113 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12117 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12120 * Store to database
12125 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12126 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12127 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12128 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12130 digest
[0] = byte_swap_32 (digest
[0]);
12131 digest
[1] = byte_swap_32 (digest
[1]);
12132 digest
[2] = byte_swap_32 (digest
[2]);
12133 digest
[3] = byte_swap_32 (digest
[3]);
12135 salt
->salt_len
= 32;
12137 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12138 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12139 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12140 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12141 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12142 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12143 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12144 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12146 return (PARSER_OK
);
12149 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12151 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12153 u32
*digest
= (u32
*) hash_buf
->digest
;
12155 salt_t
*salt
= hash_buf
->salt
;
12157 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12160 * Parse that strange long line
12165 size_t in_len
[9] = { 0 };
12167 in_off
[0] = strtok (input_buf
, ":");
12169 in_len
[0] = strlen (in_off
[0]);
12173 for (i
= 1; i
< 9; i
++)
12175 in_off
[i
] = strtok (NULL
, ":");
12177 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12179 in_len
[i
] = strlen (in_off
[i
]);
12182 char *ptr
= (char *) ikepsk
->msg_buf
;
12184 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12185 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12186 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12187 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12188 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12189 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12193 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12195 ptr
= (char *) ikepsk
->nr_buf
;
12197 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12198 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12202 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12205 * Store to database
12210 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12211 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12212 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12213 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12214 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12216 salt
->salt_len
= 32;
12218 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12219 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12220 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12221 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12222 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12223 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12224 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12225 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12227 return (PARSER_OK
);
12230 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12232 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12234 u32
*digest
= (u32
*) hash_buf
->digest
;
12236 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12237 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12238 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12239 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12240 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12242 digest
[0] = byte_swap_32 (digest
[0]);
12243 digest
[1] = byte_swap_32 (digest
[1]);
12244 digest
[2] = byte_swap_32 (digest
[2]);
12245 digest
[3] = byte_swap_32 (digest
[3]);
12246 digest
[4] = byte_swap_32 (digest
[4]);
12248 return (PARSER_OK
);
12251 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12253 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12255 u32
*digest
= (u32
*) hash_buf
->digest
;
12257 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12258 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12259 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12260 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12261 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12262 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12263 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12264 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12265 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12266 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12267 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12268 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12269 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12270 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12271 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12272 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12274 return (PARSER_OK
);
12277 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12279 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12281 u32
*digest
= (u32
*) hash_buf
->digest
;
12283 salt_t
*salt
= hash_buf
->salt
;
12285 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12286 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12287 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12288 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12289 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12291 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12293 uint salt_len
= input_len
- 40 - 1;
12295 char *salt_buf
= input_buf
+ 40 + 1;
12297 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12299 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12301 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12303 salt
->salt_len
= salt_len
;
12305 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12307 return (PARSER_OK
);
12310 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12312 u32
*digest
= (u32
*) hash_buf
->digest
;
12314 salt_t
*salt
= hash_buf
->salt
;
12316 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12318 if (input_len
== 0)
12320 log_error ("TrueCrypt container not specified");
12325 FILE *fp
= fopen (input_buf
, "rb");
12329 log_error ("%s: %s", input_buf
, strerror (errno
));
12334 char buf
[512] = { 0 };
12336 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12340 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12342 memcpy (tc
->salt_buf
, buf
, 64);
12344 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12346 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12348 salt
->salt_len
= 4;
12350 salt
->salt_iter
= 1000 - 1;
12352 digest
[0] = tc
->data_buf
[0];
12354 return (PARSER_OK
);
12357 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12359 u32
*digest
= (u32
*) hash_buf
->digest
;
12361 salt_t
*salt
= hash_buf
->salt
;
12363 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12365 if (input_len
== 0)
12367 log_error ("TrueCrypt container not specified");
12372 FILE *fp
= fopen (input_buf
, "rb");
12376 log_error ("%s: %s", input_buf
, strerror (errno
));
12381 char buf
[512] = { 0 };
12383 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12387 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12389 memcpy (tc
->salt_buf
, buf
, 64);
12391 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12393 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12395 salt
->salt_len
= 4;
12397 salt
->salt_iter
= 2000 - 1;
12399 digest
[0] = tc
->data_buf
[0];
12401 return (PARSER_OK
);
12404 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12406 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12408 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12410 u32
*digest
= (u32
*) hash_buf
->digest
;
12412 salt_t
*salt
= hash_buf
->salt
;
12414 char *salt_pos
= input_buf
+ 6;
12416 char *hash_pos
= strchr (salt_pos
, '$');
12418 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12420 uint salt_len
= hash_pos
- salt_pos
;
12422 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12424 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12426 salt
->salt_len
= salt_len
;
12428 salt
->salt_iter
= 1000;
12432 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12434 return (PARSER_OK
);
12437 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12439 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12441 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12443 u32
*digest
= (u32
*) hash_buf
->digest
;
12445 salt_t
*salt
= hash_buf
->salt
;
12447 char *iter_pos
= input_buf
+ 7;
12449 char *salt_pos
= strchr (iter_pos
, '$');
12451 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12455 char *hash_pos
= strchr (salt_pos
, '$');
12457 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12459 uint salt_len
= hash_pos
- salt_pos
;
12461 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12463 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12465 salt
->salt_len
= salt_len
;
12467 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12469 salt
->salt_sign
[0] = atoi (salt_iter
);
12471 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12475 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12477 digest
[0] = byte_swap_32 (digest
[0]);
12478 digest
[1] = byte_swap_32 (digest
[1]);
12479 digest
[2] = byte_swap_32 (digest
[2]);
12480 digest
[3] = byte_swap_32 (digest
[3]);
12481 digest
[4] = byte_swap_32 (digest
[4]);
12483 return (PARSER_OK
);
12486 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12488 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12490 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12492 u32
*digest
= (u32
*) hash_buf
->digest
;
12494 salt_t
*salt
= hash_buf
->salt
;
12496 char *iter_pos
= input_buf
+ 9;
12498 char *salt_pos
= strchr (iter_pos
, '$');
12500 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12504 char *hash_pos
= strchr (salt_pos
, '$');
12506 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12508 uint salt_len
= hash_pos
- salt_pos
;
12510 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12512 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12514 salt
->salt_len
= salt_len
;
12516 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12518 salt
->salt_sign
[0] = atoi (salt_iter
);
12520 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12524 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12526 digest
[0] = byte_swap_32 (digest
[0]);
12527 digest
[1] = byte_swap_32 (digest
[1]);
12528 digest
[2] = byte_swap_32 (digest
[2]);
12529 digest
[3] = byte_swap_32 (digest
[3]);
12530 digest
[4] = byte_swap_32 (digest
[4]);
12531 digest
[5] = byte_swap_32 (digest
[5]);
12532 digest
[6] = byte_swap_32 (digest
[6]);
12533 digest
[7] = byte_swap_32 (digest
[7]);
12535 return (PARSER_OK
);
12538 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12540 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12542 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12544 u64
*digest
= (u64
*) hash_buf
->digest
;
12546 salt_t
*salt
= hash_buf
->salt
;
12548 char *iter_pos
= input_buf
+ 9;
12550 char *salt_pos
= strchr (iter_pos
, '$');
12552 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12556 char *hash_pos
= strchr (salt_pos
, '$');
12558 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12560 uint salt_len
= hash_pos
- salt_pos
;
12562 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12564 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12566 salt
->salt_len
= salt_len
;
12568 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12570 salt
->salt_sign
[0] = atoi (salt_iter
);
12572 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12576 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12578 digest
[0] = byte_swap_64 (digest
[0]);
12579 digest
[1] = byte_swap_64 (digest
[1]);
12580 digest
[2] = byte_swap_64 (digest
[2]);
12581 digest
[3] = byte_swap_64 (digest
[3]);
12582 digest
[4] = byte_swap_64 (digest
[4]);
12583 digest
[5] = byte_swap_64 (digest
[5]);
12584 digest
[6] = byte_swap_64 (digest
[6]);
12585 digest
[7] = byte_swap_64 (digest
[7]);
12587 return (PARSER_OK
);
12590 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12592 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12594 u32
*digest
= (u32
*) hash_buf
->digest
;
12596 salt_t
*salt
= hash_buf
->salt
;
12598 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12604 char *iterations_pos
= input_buf
;
12606 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12608 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12610 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12612 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12616 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12618 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12620 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12622 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12624 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12626 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12631 * pbkdf2 iterations
12634 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12637 * handle salt encoding
12640 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12642 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12644 const char p0
= saltbuf_pos
[i
+ 0];
12645 const char p1
= saltbuf_pos
[i
+ 1];
12647 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12648 | hex_convert (p0
) << 4;
12651 salt
->salt_len
= saltbuf_len
/ 2;
12654 * handle cipher encoding
12657 uint
*tmp
= (uint
*) mymalloc (32);
12659 char *cipherbuf_ptr
= (char *) tmp
;
12661 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12663 const char p0
= cipherbuf_pos
[i
+ 0];
12664 const char p1
= cipherbuf_pos
[i
+ 1];
12666 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12667 | hex_convert (p0
) << 4;
12670 // iv is stored at salt_buf 4 (length 16)
12671 // data is stored at salt_buf 8 (length 16)
12673 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12674 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12675 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12676 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12678 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12679 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12680 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12681 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12685 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12687 const char p0
= cipherbuf_pos
[j
+ 0];
12688 const char p1
= cipherbuf_pos
[j
+ 1];
12690 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12691 | hex_convert (p0
) << 4;
12698 digest
[0] = 0x10101010;
12699 digest
[1] = 0x10101010;
12700 digest
[2] = 0x10101010;
12701 digest
[3] = 0x10101010;
12703 return (PARSER_OK
);
12706 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12708 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12710 u32
*digest
= (u32
*) hash_buf
->digest
;
12712 salt_t
*salt
= hash_buf
->salt
;
12714 char *hashbuf_pos
= input_buf
;
12716 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12718 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12720 uint hash_len
= iterations_pos
- hashbuf_pos
;
12722 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12726 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12728 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12730 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12734 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12736 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12738 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12740 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12742 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12744 salt
->salt_len
= salt_len
;
12746 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12748 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12749 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12750 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12751 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12753 return (PARSER_OK
);
12756 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12758 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12760 u32
*digest
= (u32
*) hash_buf
->digest
;
12762 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12763 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12764 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12765 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12766 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12767 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12768 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12769 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12771 digest
[0] = byte_swap_32 (digest
[0]);
12772 digest
[1] = byte_swap_32 (digest
[1]);
12773 digest
[2] = byte_swap_32 (digest
[2]);
12774 digest
[3] = byte_swap_32 (digest
[3]);
12775 digest
[4] = byte_swap_32 (digest
[4]);
12776 digest
[5] = byte_swap_32 (digest
[5]);
12777 digest
[6] = byte_swap_32 (digest
[6]);
12778 digest
[7] = byte_swap_32 (digest
[7]);
12780 return (PARSER_OK
);
12783 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12785 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12787 u32
*digest
= (u32
*) hash_buf
->digest
;
12789 salt_t
*salt
= hash_buf
->salt
;
12791 char *salt_pos
= input_buf
+ 3;
12793 uint iterations_len
= 0;
12795 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12799 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12801 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12802 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12806 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12810 iterations_len
+= 8;
12814 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12817 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12819 char *hash_pos
= strchr (salt_pos
, '$');
12821 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12823 uint salt_len
= hash_pos
- salt_pos
;
12825 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12827 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12829 salt
->salt_len
= salt_len
;
12833 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12835 return (PARSER_OK
);
12838 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12840 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12842 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12844 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12846 u64
*digest
= (u64
*) hash_buf
->digest
;
12848 salt_t
*salt
= hash_buf
->salt
;
12850 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12852 char *iter_pos
= input_buf
+ 4;
12854 char *salt_pos
= strchr (iter_pos
, '$');
12856 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12860 char *hash_pos
= strchr (salt_pos
, '$');
12862 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12864 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12868 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12869 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12870 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12871 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12872 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12873 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12874 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12875 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12877 uint salt_len
= hash_pos
- salt_pos
- 1;
12879 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12881 salt
->salt_len
= salt_len
/ 2;
12883 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12884 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12885 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12886 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12887 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12888 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12889 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12890 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12892 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12893 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12894 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12895 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12896 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12897 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12898 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12899 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12900 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12901 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12903 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12905 salt
->salt_iter
= atoi (iter_pos
) - 1;
12907 return (PARSER_OK
);
12910 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12912 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12914 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12916 u32
*digest
= (u32
*) hash_buf
->digest
;
12918 salt_t
*salt
= hash_buf
->salt
;
12920 char *salt_pos
= input_buf
+ 14;
12922 char *hash_pos
= strchr (salt_pos
, '*');
12924 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12928 uint salt_len
= hash_pos
- salt_pos
- 1;
12930 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12932 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12934 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12936 salt
->salt_len
= salt_len
;
12938 u8 tmp_buf
[100] = { 0 };
12940 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
12942 memcpy (digest
, tmp_buf
, 32);
12944 digest
[0] = byte_swap_32 (digest
[0]);
12945 digest
[1] = byte_swap_32 (digest
[1]);
12946 digest
[2] = byte_swap_32 (digest
[2]);
12947 digest
[3] = byte_swap_32 (digest
[3]);
12948 digest
[4] = byte_swap_32 (digest
[4]);
12949 digest
[5] = byte_swap_32 (digest
[5]);
12950 digest
[6] = byte_swap_32 (digest
[6]);
12951 digest
[7] = byte_swap_32 (digest
[7]);
12953 digest
[0] -= SHA256M_A
;
12954 digest
[1] -= SHA256M_B
;
12955 digest
[2] -= SHA256M_C
;
12956 digest
[3] -= SHA256M_D
;
12957 digest
[4] -= SHA256M_E
;
12958 digest
[5] -= SHA256M_F
;
12959 digest
[6] -= SHA256M_G
;
12960 digest
[7] -= SHA256M_H
;
12962 return (PARSER_OK
);
12965 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12967 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12969 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12971 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12973 u64
*digest
= (u64
*) hash_buf
->digest
;
12975 salt_t
*salt
= hash_buf
->salt
;
12977 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12979 char *iter_pos
= input_buf
+ 19;
12981 char *salt_pos
= strchr (iter_pos
, '.');
12983 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12987 char *hash_pos
= strchr (salt_pos
, '.');
12989 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12991 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12995 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12996 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12997 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12998 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12999 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13000 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13001 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13002 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13004 uint salt_len
= hash_pos
- salt_pos
- 1;
13008 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13012 for (i
= 0; i
< salt_len
; i
++)
13014 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13017 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13018 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13020 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13022 salt
->salt_len
= salt_len
;
13024 salt
->salt_iter
= atoi (iter_pos
) - 1;
13026 return (PARSER_OK
);
13029 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13031 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13033 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13035 u64
*digest
= (u64
*) hash_buf
->digest
;
13037 salt_t
*salt
= hash_buf
->salt
;
13039 u8 tmp_buf
[120] = { 0 };
13041 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13043 memcpy (digest
, tmp_buf
, 64);
13045 digest
[0] = byte_swap_64 (digest
[0]);
13046 digest
[1] = byte_swap_64 (digest
[1]);
13047 digest
[2] = byte_swap_64 (digest
[2]);
13048 digest
[3] = byte_swap_64 (digest
[3]);
13049 digest
[4] = byte_swap_64 (digest
[4]);
13050 digest
[5] = byte_swap_64 (digest
[5]);
13051 digest
[6] = byte_swap_64 (digest
[6]);
13052 digest
[7] = byte_swap_64 (digest
[7]);
13054 digest
[0] -= SHA512M_A
;
13055 digest
[1] -= SHA512M_B
;
13056 digest
[2] -= SHA512M_C
;
13057 digest
[3] -= SHA512M_D
;
13058 digest
[4] -= SHA512M_E
;
13059 digest
[5] -= SHA512M_F
;
13060 digest
[6] -= SHA512M_G
;
13061 digest
[7] -= SHA512M_H
;
13063 salt
->salt_len
= tmp_len
- 64;
13065 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13067 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13069 char *ptr
= (char *) salt
->salt_buf
;
13071 ptr
[salt
->salt_len
] = 0x80;
13074 return (PARSER_OK
);
13077 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13079 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13081 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13085 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13088 u32
*digest
= (u32
*) hash_buf
->digest
;
13090 salt_t
*salt
= hash_buf
->salt
;
13092 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13093 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13094 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13095 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13097 digest
[0] = byte_swap_32 (digest
[0]);
13098 digest
[1] = byte_swap_32 (digest
[1]);
13099 digest
[2] = byte_swap_32 (digest
[2]);
13100 digest
[3] = byte_swap_32 (digest
[3]);
13102 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13104 uint salt_len
= input_len
- 32 - 1;
13106 char *salt_buf
= input_buf
+ 32 + 1;
13108 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13110 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13112 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13114 salt
->salt_len
= salt_len
;
13116 return (PARSER_OK
);
13119 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13121 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13123 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13127 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13130 u32
*digest
= (u32
*) hash_buf
->digest
;
13132 salt_t
*salt
= hash_buf
->salt
;
13134 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13135 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13136 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13137 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13138 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13140 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13142 uint salt_len
= input_len
- 40 - 1;
13144 char *salt_buf
= input_buf
+ 40 + 1;
13146 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13148 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13150 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13152 salt
->salt_len
= salt_len
;
13154 return (PARSER_OK
);
13157 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13159 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13161 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13165 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13168 u32
*digest
= (u32
*) hash_buf
->digest
;
13170 salt_t
*salt
= hash_buf
->salt
;
13172 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13173 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13174 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13175 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13176 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13177 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13178 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13179 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13181 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13183 uint salt_len
= input_len
- 64 - 1;
13185 char *salt_buf
= input_buf
+ 64 + 1;
13187 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13189 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13191 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13193 salt
->salt_len
= salt_len
;
13195 return (PARSER_OK
);
13198 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13200 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13202 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13206 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13209 u64
*digest
= (u64
*) hash_buf
->digest
;
13211 salt_t
*salt
= hash_buf
->salt
;
13213 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13214 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13215 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13216 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13217 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13218 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13219 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13220 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13222 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13224 uint salt_len
= input_len
- 128 - 1;
13226 char *salt_buf
= input_buf
+ 128 + 1;
13228 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13230 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13232 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13234 salt
->salt_len
= salt_len
;
13236 return (PARSER_OK
);
13239 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13241 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13243 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13245 u32
*digest
= (u32
*) hash_buf
->digest
;
13247 salt_t
*salt
= hash_buf
->salt
;
13249 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13255 char *user_pos
= input_buf
+ 10 + 1;
13257 char *realm_pos
= strchr (user_pos
, '$');
13259 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13261 uint user_len
= realm_pos
- user_pos
;
13263 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13267 char *salt_pos
= strchr (realm_pos
, '$');
13269 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13271 uint realm_len
= salt_pos
- realm_pos
;
13273 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13277 char *data_pos
= strchr (salt_pos
, '$');
13279 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13281 uint salt_len
= data_pos
- salt_pos
;
13283 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13287 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13289 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13295 memcpy (krb5pa
->user
, user_pos
, user_len
);
13296 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13297 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13299 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13301 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13303 const char p0
= data_pos
[i
+ 0];
13304 const char p1
= data_pos
[i
+ 1];
13306 *timestamp_ptr
++ = hex_convert (p1
) << 0
13307 | hex_convert (p0
) << 4;
13310 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13312 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13314 const char p0
= data_pos
[i
+ 0];
13315 const char p1
= data_pos
[i
+ 1];
13317 *checksum_ptr
++ = hex_convert (p1
) << 0
13318 | hex_convert (p0
) << 4;
13322 * copy some data to generic buffers to make sorting happy
13325 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13326 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13327 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13328 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13329 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13330 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13331 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13332 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13333 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13335 salt
->salt_len
= 36;
13337 digest
[0] = krb5pa
->checksum
[0];
13338 digest
[1] = krb5pa
->checksum
[1];
13339 digest
[2] = krb5pa
->checksum
[2];
13340 digest
[3] = krb5pa
->checksum
[3];
13342 return (PARSER_OK
);
13345 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13347 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13349 u32
*digest
= (u32
*) hash_buf
->digest
;
13351 salt_t
*salt
= hash_buf
->salt
;
13357 char *salt_pos
= input_buf
;
13359 char *hash_pos
= strchr (salt_pos
, '$');
13361 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13363 uint salt_len
= hash_pos
- salt_pos
;
13365 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13369 uint hash_len
= input_len
- 1 - salt_len
;
13371 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13379 for (uint i
= 0; i
< salt_len
; i
++)
13381 if (salt_pos
[i
] == ' ') continue;
13386 // SAP user names cannot be longer than 12 characters
13387 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13389 // SAP user name cannot start with ! or ?
13390 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13396 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13398 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13400 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13402 salt
->salt_len
= salt_len
;
13404 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13405 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13409 digest
[0] = byte_swap_32 (digest
[0]);
13410 digest
[1] = byte_swap_32 (digest
[1]);
13412 return (PARSER_OK
);
13415 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13417 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13419 u32
*digest
= (u32
*) hash_buf
->digest
;
13421 salt_t
*salt
= hash_buf
->salt
;
13427 char *salt_pos
= input_buf
;
13429 char *hash_pos
= strchr (salt_pos
, '$');
13431 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13433 uint salt_len
= hash_pos
- salt_pos
;
13435 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13439 uint hash_len
= input_len
- 1 - salt_len
;
13441 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13449 for (uint i
= 0; i
< salt_len
; i
++)
13451 if (salt_pos
[i
] == ' ') continue;
13456 // SAP user names cannot be longer than 12 characters
13457 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13458 // so far nobody complained so we stay with this because it helps in optimization
13459 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13461 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13463 // SAP user name cannot start with ! or ?
13464 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13470 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13472 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13474 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13476 salt
->salt_len
= salt_len
;
13478 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13479 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13480 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13481 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13482 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13484 return (PARSER_OK
);
13487 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13489 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13491 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13493 u64
*digest
= (u64
*) hash_buf
->digest
;
13495 salt_t
*salt
= hash_buf
->salt
;
13497 char *iter_pos
= input_buf
+ 3;
13499 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13501 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13503 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13505 salt
->salt_iter
= salt_iter
;
13507 char *salt_pos
= iter_pos
+ 1;
13511 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13513 salt
->salt_len
= salt_len
;
13515 char *hash_pos
= salt_pos
+ salt_len
;
13517 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13521 char *tmp
= (char *) salt
->salt_buf_pc
;
13523 tmp
[0] = hash_pos
[42];
13527 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13528 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13529 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13530 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13536 return (PARSER_OK
);
13539 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13541 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13543 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13545 u32
*digest
= (u32
*) hash_buf
->digest
;
13547 salt_t
*salt
= hash_buf
->salt
;
13549 char *salt_buf
= input_buf
+ 6;
13551 uint salt_len
= 16;
13553 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13555 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13557 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13559 salt
->salt_len
= salt_len
;
13561 char *hash_pos
= input_buf
+ 6 + 16;
13563 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13564 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13565 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13566 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13567 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13568 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13569 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13570 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13572 return (PARSER_OK
);
13575 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13577 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13579 u32
*digest
= (u32
*) hash_buf
->digest
;
13581 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13582 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13586 return (PARSER_OK
);
13589 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13591 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13593 u32
*digest
= (u32
*) hash_buf
->digest
;
13595 salt_t
*salt
= hash_buf
->salt
;
13597 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13599 char *saltbuf_pos
= input_buf
;
13601 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13603 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13605 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13607 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13608 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13610 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13614 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13616 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13618 char *salt_ptr
= (char *) saltbuf_pos
;
13619 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13624 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13626 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13629 rakp_ptr
[j
] = 0x80;
13631 rakp
->salt_len
= j
;
13633 for (i
= 0; i
< 64; i
++)
13635 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13638 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13639 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13640 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13641 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13642 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13643 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13644 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13645 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13647 salt
->salt_len
= 32; // muss min. 32 haben
13649 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13650 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13651 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13652 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13653 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13655 return (PARSER_OK
);
13658 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13660 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13662 u32
*digest
= (u32
*) hash_buf
->digest
;
13664 salt_t
*salt
= hash_buf
->salt
;
13666 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13668 char *salt_pos
= input_buf
+ 1;
13670 memcpy (salt
->salt_buf
, salt_pos
, 8);
13672 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13673 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13675 salt
->salt_len
= 8;
13677 char *hash_pos
= salt_pos
+ 8;
13679 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13680 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13681 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13682 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13683 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13685 digest
[0] -= SHA1M_A
;
13686 digest
[1] -= SHA1M_B
;
13687 digest
[2] -= SHA1M_C
;
13688 digest
[3] -= SHA1M_D
;
13689 digest
[4] -= SHA1M_E
;
13691 return (PARSER_OK
);
13694 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13696 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13698 u32
*digest
= (u32
*) hash_buf
->digest
;
13700 salt_t
*salt
= hash_buf
->salt
;
13702 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13703 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13704 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13705 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13707 digest
[0] = byte_swap_32 (digest
[0]);
13708 digest
[1] = byte_swap_32 (digest
[1]);
13709 digest
[2] = byte_swap_32 (digest
[2]);
13710 digest
[3] = byte_swap_32 (digest
[3]);
13712 digest
[0] -= MD5M_A
;
13713 digest
[1] -= MD5M_B
;
13714 digest
[2] -= MD5M_C
;
13715 digest
[3] -= MD5M_D
;
13717 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13719 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13721 u32
*salt_buf
= salt
->salt_buf
;
13723 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13724 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13725 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13726 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13728 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13729 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13730 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13731 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13733 salt
->salt_len
= 16 + 1;
13735 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13737 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13739 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13741 return (PARSER_OK
);
13744 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13746 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13748 u32
*digest
= (u32
*) hash_buf
->digest
;
13750 salt_t
*salt
= hash_buf
->salt
;
13752 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13758 char *hashbuf_pos
= input_buf
;
13760 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13762 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13764 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13766 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13770 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13772 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13774 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13776 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13780 char *databuf_pos
= strchr (iteration_pos
, ':');
13782 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13784 const uint iteration_len
= databuf_pos
- iteration_pos
;
13786 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13787 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13789 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13791 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13792 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13798 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13799 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13800 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13801 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13802 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13803 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13804 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13805 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13809 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13811 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13813 const char p0
= saltbuf_pos
[i
+ 0];
13814 const char p1
= saltbuf_pos
[i
+ 1];
13816 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13817 | hex_convert (p0
) << 4;
13820 salt
->salt_buf
[4] = 0x01000000;
13821 salt
->salt_buf
[5] = 0x80;
13823 salt
->salt_len
= saltbuf_len
/ 2;
13827 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13831 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13833 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13835 const char p0
= databuf_pos
[i
+ 0];
13836 const char p1
= databuf_pos
[i
+ 1];
13838 *databuf_ptr
++ = hex_convert (p1
) << 0
13839 | hex_convert (p0
) << 4;
13842 *databuf_ptr
++ = 0x80;
13844 for (uint i
= 0; i
< 512; i
++)
13846 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13849 cloudkey
->data_len
= databuf_len
/ 2;
13851 return (PARSER_OK
);
13854 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13856 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13858 u32
*digest
= (u32
*) hash_buf
->digest
;
13860 salt_t
*salt
= hash_buf
->salt
;
13866 char *hashbuf_pos
= input_buf
;
13868 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13870 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13872 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13874 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13878 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13880 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13882 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13884 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13886 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13890 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13892 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13894 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13896 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13898 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13902 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13904 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13905 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13907 // ok, the plan for this algorithm is the following:
13908 // we have 2 salts here, the domain-name and a random salt
13909 // while both are used in the initial transformation,
13910 // only the random salt is used in the following iterations
13911 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13912 // and one that includes only the real salt (stored into salt_buf[]).
13913 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13915 u8 tmp_buf
[100] = { 0 };
13917 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
13919 memcpy (digest
, tmp_buf
, 20);
13921 digest
[0] = byte_swap_32 (digest
[0]);
13922 digest
[1] = byte_swap_32 (digest
[1]);
13923 digest
[2] = byte_swap_32 (digest
[2]);
13924 digest
[3] = byte_swap_32 (digest
[3]);
13925 digest
[4] = byte_swap_32 (digest
[4]);
13929 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13931 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13933 char *len_ptr
= NULL
;
13935 for (uint i
= 0; i
< domainbuf_len
; i
++)
13937 if (salt_buf_pc_ptr
[i
] == '.')
13939 len_ptr
= &salt_buf_pc_ptr
[i
];
13949 salt
->salt_buf_pc
[7] = domainbuf_len
;
13953 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13955 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13957 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13959 salt
->salt_len
= salt_len
;
13963 salt
->salt_iter
= atoi (iteration_pos
);
13965 return (PARSER_OK
);
13968 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13970 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13972 u32
*digest
= (u32
*) hash_buf
->digest
;
13974 salt_t
*salt
= hash_buf
->salt
;
13976 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13977 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13978 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13979 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13980 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13982 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13984 uint salt_len
= input_len
- 40 - 1;
13986 char *salt_buf
= input_buf
+ 40 + 1;
13988 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13990 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13992 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13994 salt
->salt_len
= salt_len
;
13996 return (PARSER_OK
);
13999 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14001 const u8 ascii_to_ebcdic
[] =
14003 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14004 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14005 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14006 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14007 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14008 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14009 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14010 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14011 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14012 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14013 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14014 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14015 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14016 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14017 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14018 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14021 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14023 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14025 u32
*digest
= (u32
*) hash_buf
->digest
;
14027 salt_t
*salt
= hash_buf
->salt
;
14029 char *salt_pos
= input_buf
+ 6 + 1;
14031 char *digest_pos
= strchr (salt_pos
, '*');
14033 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14035 uint salt_len
= digest_pos
- salt_pos
;
14037 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14039 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14041 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14045 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14046 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14048 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14050 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14052 salt
->salt_len
= salt_len
;
14054 for (uint i
= 0; i
< salt_len
; i
++)
14056 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14058 for (uint i
= salt_len
; i
< 8; i
++)
14060 salt_buf_pc_ptr
[i
] = 0x40;
14065 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14067 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14068 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14070 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14071 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14073 digest
[0] = byte_swap_32 (digest
[0]);
14074 digest
[1] = byte_swap_32 (digest
[1]);
14076 IP (digest
[0], digest
[1], tt
);
14078 digest
[0] = rotr32 (digest
[0], 29);
14079 digest
[1] = rotr32 (digest
[1], 29);
14083 return (PARSER_OK
);
14086 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14088 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14090 u32
*digest
= (u32
*) hash_buf
->digest
;
14092 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14093 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14094 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14095 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14097 digest
[0] = byte_swap_32 (digest
[0]);
14098 digest
[1] = byte_swap_32 (digest
[1]);
14099 digest
[2] = byte_swap_32 (digest
[2]);
14100 digest
[3] = byte_swap_32 (digest
[3]);
14102 return (PARSER_OK
);
14105 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14107 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14109 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14111 u32
*digest
= (u32
*) hash_buf
->digest
;
14113 salt_t
*salt
= hash_buf
->salt
;
14115 u8 tmp_buf
[120] = { 0 };
14117 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14119 tmp_buf
[3] += -4; // dont ask!
14121 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14123 salt
->salt_len
= 5;
14125 memcpy (digest
, tmp_buf
+ 5, 9);
14127 // yes, only 9 byte are needed to crack, but 10 to display
14129 salt
->salt_buf_pc
[7] = input_buf
[20];
14131 return (PARSER_OK
);
14134 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14136 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14138 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14140 u32
*digest
= (u32
*) hash_buf
->digest
;
14142 salt_t
*salt
= hash_buf
->salt
;
14144 u8 tmp_buf
[120] = { 0 };
14146 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14148 tmp_buf
[3] += -4; // dont ask!
14152 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14154 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)
14158 char tmp_iter_buf
[11] = { 0 };
14160 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14162 tmp_iter_buf
[10] = 0;
14164 salt
->salt_iter
= atoi (tmp_iter_buf
);
14166 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14168 return (PARSER_SALT_ITERATION
);
14171 salt
->salt_iter
--; // first round in init
14173 // 2 additional bytes for display only
14175 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14176 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14180 memcpy (digest
, tmp_buf
+ 28, 8);
14182 digest
[0] = byte_swap_32 (digest
[0]);
14183 digest
[1] = byte_swap_32 (digest
[1]);
14187 return (PARSER_OK
);
14190 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14192 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14194 u32
*digest
= (u32
*) hash_buf
->digest
;
14196 salt_t
*salt
= hash_buf
->salt
;
14198 char *salt_buf_pos
= input_buf
;
14200 char *hash_buf_pos
= salt_buf_pos
+ 6;
14202 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14203 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14204 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14205 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14206 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14207 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14208 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14209 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14211 digest
[0] -= SHA256M_A
;
14212 digest
[1] -= SHA256M_B
;
14213 digest
[2] -= SHA256M_C
;
14214 digest
[3] -= SHA256M_D
;
14215 digest
[4] -= SHA256M_E
;
14216 digest
[5] -= SHA256M_F
;
14217 digest
[6] -= SHA256M_G
;
14218 digest
[7] -= SHA256M_H
;
14220 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14222 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14224 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14226 salt
->salt_len
= salt_len
;
14228 return (PARSER_OK
);
14231 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14233 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14235 u32
*digest
= (u32
*) hash_buf
->digest
;
14237 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14239 salt_t
*salt
= hash_buf
->salt
;
14241 char *salt_buf
= input_buf
+ 6;
14243 char *digest_buf
= strchr (salt_buf
, '$');
14245 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14247 uint salt_len
= digest_buf
- salt_buf
;
14249 digest_buf
++; // skip the '$' symbol
14251 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14253 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14255 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14257 salt
->salt_len
= salt_len
;
14259 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14260 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14261 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14262 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14264 digest
[0] = byte_swap_32 (digest
[0]);
14265 digest
[1] = byte_swap_32 (digest
[1]);
14266 digest
[2] = byte_swap_32 (digest
[2]);
14267 digest
[3] = byte_swap_32 (digest
[3]);
14269 digest
[0] -= MD5M_A
;
14270 digest
[1] -= MD5M_B
;
14271 digest
[2] -= MD5M_C
;
14272 digest
[3] -= MD5M_D
;
14274 return (PARSER_OK
);
14277 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14279 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14281 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14283 u32
*digest
= (u32
*) hash_buf
->digest
;
14285 salt_t
*salt
= hash_buf
->salt
;
14287 char *salt_buf
= input_buf
+ 3;
14289 char *digest_buf
= strchr (salt_buf
, '$');
14291 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14293 uint salt_len
= digest_buf
- salt_buf
;
14295 digest_buf
++; // skip the '$' symbol
14297 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14299 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14301 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14303 salt_buf_ptr
[salt_len
] = 0x2d;
14305 salt
->salt_len
= salt_len
+ 1;
14307 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14308 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14309 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14310 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14312 digest
[0] = byte_swap_32 (digest
[0]);
14313 digest
[1] = byte_swap_32 (digest
[1]);
14314 digest
[2] = byte_swap_32 (digest
[2]);
14315 digest
[3] = byte_swap_32 (digest
[3]);
14317 digest
[0] -= MD5M_A
;
14318 digest
[1] -= MD5M_B
;
14319 digest
[2] -= MD5M_C
;
14320 digest
[3] -= MD5M_D
;
14322 return (PARSER_OK
);
14325 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14327 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14329 u32
*digest
= (u32
*) hash_buf
->digest
;
14331 u8 tmp_buf
[100] = { 0 };
14333 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14335 memcpy (digest
, tmp_buf
, 20);
14337 digest
[0] = byte_swap_32 (digest
[0]);
14338 digest
[1] = byte_swap_32 (digest
[1]);
14339 digest
[2] = byte_swap_32 (digest
[2]);
14340 digest
[3] = byte_swap_32 (digest
[3]);
14341 digest
[4] = byte_swap_32 (digest
[4]);
14343 digest
[0] -= SHA1M_A
;
14344 digest
[1] -= SHA1M_B
;
14345 digest
[2] -= SHA1M_C
;
14346 digest
[3] -= SHA1M_D
;
14347 digest
[4] -= SHA1M_E
;
14349 return (PARSER_OK
);
14352 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14354 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14356 u32
*digest
= (u32
*) hash_buf
->digest
;
14358 salt_t
*salt
= hash_buf
->salt
;
14360 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14361 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14362 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14363 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14365 digest
[0] = byte_swap_32 (digest
[0]);
14366 digest
[1] = byte_swap_32 (digest
[1]);
14367 digest
[2] = byte_swap_32 (digest
[2]);
14368 digest
[3] = byte_swap_32 (digest
[3]);
14370 digest
[0] -= MD5M_A
;
14371 digest
[1] -= MD5M_B
;
14372 digest
[2] -= MD5M_C
;
14373 digest
[3] -= MD5M_D
;
14375 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14377 uint salt_len
= input_len
- 32 - 1;
14379 char *salt_buf
= input_buf
+ 32 + 1;
14381 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14383 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14385 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14388 * add static "salt" part
14391 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14395 salt
->salt_len
= salt_len
;
14397 return (PARSER_OK
);
14400 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14402 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14404 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14406 u32
*digest
= (u32
*) hash_buf
->digest
;
14408 salt_t
*salt
= hash_buf
->salt
;
14410 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14416 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14418 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14420 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14422 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14424 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14428 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14430 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14432 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14434 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14438 char *keybuf_pos
= strchr (keylen_pos
, '$');
14440 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14442 uint keylen_len
= keybuf_pos
- keylen_pos
;
14444 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14448 char *databuf_pos
= strchr (keybuf_pos
, '$');
14450 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14452 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14454 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14458 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14460 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14466 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14467 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14468 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14469 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14471 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14472 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14473 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14474 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14476 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14477 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14478 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14479 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14481 salt
->salt_len
= 16;
14482 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14484 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14486 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14489 return (PARSER_OK
);
14492 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14494 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14496 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14498 u32
*digest
= (u32
*) hash_buf
->digest
;
14500 salt_t
*salt
= hash_buf
->salt
;
14506 // first is the N salt parameter
14508 char *N_pos
= input_buf
+ 6;
14510 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14514 salt
->scrypt_N
= atoi (N_pos
);
14518 char *r_pos
= strchr (N_pos
, ':');
14520 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14524 salt
->scrypt_r
= atoi (r_pos
);
14528 char *p_pos
= strchr (r_pos
, ':');
14530 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14534 salt
->scrypt_p
= atoi (p_pos
);
14538 char *saltbuf_pos
= strchr (p_pos
, ':');
14540 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14544 char *hash_pos
= strchr (saltbuf_pos
, ':');
14546 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14552 u8 tmp_buf
[33] = { 0 };
14554 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14556 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14558 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14560 salt
->salt_len
= tmp_len
;
14561 salt
->salt_iter
= 1;
14563 // digest - base64 decode
14565 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14567 tmp_len
= input_len
- (hash_pos
- input_buf
);
14569 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14571 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14573 memcpy (digest
, tmp_buf
, 32);
14575 return (PARSER_OK
);
14578 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14580 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14582 u32
*digest
= (u32
*) hash_buf
->digest
;
14584 salt_t
*salt
= hash_buf
->salt
;
14590 char decrypted
[76] = { 0 }; // iv + hash
14592 juniper_decrypt_hash (input_buf
, decrypted
);
14594 char *md5crypt_hash
= decrypted
+ 12;
14596 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14598 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14600 char *salt_pos
= md5crypt_hash
+ 3;
14602 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14604 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14606 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14610 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14612 return (PARSER_OK
);
14615 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14617 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14619 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14621 u32
*digest
= (u32
*) hash_buf
->digest
;
14623 salt_t
*salt
= hash_buf
->salt
;
14625 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14631 // first is *raw* salt
14633 char *salt_pos
= input_buf
+ 3;
14635 char *hash_pos
= strchr (salt_pos
, '$');
14637 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14639 uint salt_len
= hash_pos
- salt_pos
;
14641 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14645 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14647 memcpy (salt_buf_ptr
, salt_pos
, 14);
14649 salt_buf_ptr
[17] = 0x01;
14650 salt_buf_ptr
[18] = 0x80;
14652 // add some stuff to normal salt to make sorted happy
14654 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14655 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14656 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14657 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14659 salt
->salt_len
= salt_len
;
14660 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14662 // base64 decode hash
14664 u8 tmp_buf
[100] = { 0 };
14666 uint hash_len
= input_len
- 3 - salt_len
- 1;
14668 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14670 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14672 memcpy (digest
, tmp_buf
, 32);
14674 digest
[0] = byte_swap_32 (digest
[0]);
14675 digest
[1] = byte_swap_32 (digest
[1]);
14676 digest
[2] = byte_swap_32 (digest
[2]);
14677 digest
[3] = byte_swap_32 (digest
[3]);
14678 digest
[4] = byte_swap_32 (digest
[4]);
14679 digest
[5] = byte_swap_32 (digest
[5]);
14680 digest
[6] = byte_swap_32 (digest
[6]);
14681 digest
[7] = byte_swap_32 (digest
[7]);
14683 return (PARSER_OK
);
14686 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14688 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14690 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14692 u32
*digest
= (u32
*) hash_buf
->digest
;
14694 salt_t
*salt
= hash_buf
->salt
;
14700 // first is *raw* salt
14702 char *salt_pos
= input_buf
+ 3;
14704 char *hash_pos
= strchr (salt_pos
, '$');
14706 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14708 uint salt_len
= hash_pos
- salt_pos
;
14710 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14712 salt
->salt_len
= salt_len
;
14715 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14717 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14718 salt_buf_ptr
[salt_len
] = 0;
14720 // base64 decode hash
14722 u8 tmp_buf
[100] = { 0 };
14724 uint hash_len
= input_len
- 3 - salt_len
- 1;
14726 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14728 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14730 memcpy (digest
, tmp_buf
, 32);
14733 salt
->scrypt_N
= 16384;
14734 salt
->scrypt_r
= 1;
14735 salt
->scrypt_p
= 1;
14736 salt
->salt_iter
= 1;
14738 return (PARSER_OK
);
14741 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14743 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14745 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14747 u32
*digest
= (u32
*) hash_buf
->digest
;
14749 salt_t
*salt
= hash_buf
->salt
;
14751 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14757 char *version_pos
= input_buf
+ 8 + 1;
14759 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14761 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14763 u32 version_len
= verifierHashSize_pos
- version_pos
;
14765 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14767 verifierHashSize_pos
++;
14769 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14771 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14773 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14775 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14779 char *saltSize_pos
= strchr (keySize_pos
, '*');
14781 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14783 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14785 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14789 char *osalt_pos
= strchr (saltSize_pos
, '*');
14791 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14793 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14795 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14799 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14801 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14803 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14805 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14807 encryptedVerifier_pos
++;
14809 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14811 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14813 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14815 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14817 encryptedVerifierHash_pos
++;
14819 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;
14821 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14823 const uint version
= atoi (version_pos
);
14825 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14827 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14829 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14831 const uint keySize
= atoi (keySize_pos
);
14833 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14835 office2007
->keySize
= keySize
;
14837 const uint saltSize
= atoi (saltSize_pos
);
14839 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14845 salt
->salt_len
= 16;
14846 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14848 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14849 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14850 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14851 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14857 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14858 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14859 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14860 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14862 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14863 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14864 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14865 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14866 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14872 digest
[0] = office2007
->encryptedVerifierHash
[0];
14873 digest
[1] = office2007
->encryptedVerifierHash
[1];
14874 digest
[2] = office2007
->encryptedVerifierHash
[2];
14875 digest
[3] = office2007
->encryptedVerifierHash
[3];
14877 return (PARSER_OK
);
14880 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14882 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14884 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14886 u32
*digest
= (u32
*) hash_buf
->digest
;
14888 salt_t
*salt
= hash_buf
->salt
;
14890 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14896 char *version_pos
= input_buf
+ 8 + 1;
14898 char *spinCount_pos
= strchr (version_pos
, '*');
14900 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14902 u32 version_len
= spinCount_pos
- version_pos
;
14904 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14908 char *keySize_pos
= strchr (spinCount_pos
, '*');
14910 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14912 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
14914 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14918 char *saltSize_pos
= strchr (keySize_pos
, '*');
14920 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14922 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14924 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14928 char *osalt_pos
= strchr (saltSize_pos
, '*');
14930 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14932 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14934 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14938 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14940 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14942 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14944 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14946 encryptedVerifier_pos
++;
14948 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14950 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14952 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14954 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14956 encryptedVerifierHash_pos
++;
14958 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;
14960 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14962 const uint version
= atoi (version_pos
);
14964 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14966 const uint spinCount
= atoi (spinCount_pos
);
14968 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14970 const uint keySize
= atoi (keySize_pos
);
14972 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14974 const uint saltSize
= atoi (saltSize_pos
);
14976 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14982 salt
->salt_len
= 16;
14983 salt
->salt_iter
= spinCount
;
14985 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14986 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14987 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14988 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14994 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14995 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14996 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14997 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14999 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15000 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15001 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15002 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15003 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15004 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15005 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15006 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15012 digest
[0] = office2010
->encryptedVerifierHash
[0];
15013 digest
[1] = office2010
->encryptedVerifierHash
[1];
15014 digest
[2] = office2010
->encryptedVerifierHash
[2];
15015 digest
[3] = office2010
->encryptedVerifierHash
[3];
15017 return (PARSER_OK
);
15020 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15022 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15024 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15026 u32
*digest
= (u32
*) hash_buf
->digest
;
15028 salt_t
*salt
= hash_buf
->salt
;
15030 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15036 char *version_pos
= input_buf
+ 8 + 1;
15038 char *spinCount_pos
= strchr (version_pos
, '*');
15040 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15042 u32 version_len
= spinCount_pos
- version_pos
;
15044 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15048 char *keySize_pos
= strchr (spinCount_pos
, '*');
15050 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15052 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15054 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15058 char *saltSize_pos
= strchr (keySize_pos
, '*');
15060 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15062 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15064 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15068 char *osalt_pos
= strchr (saltSize_pos
, '*');
15070 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15072 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15074 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15078 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15080 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15082 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15084 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15086 encryptedVerifier_pos
++;
15088 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15090 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15092 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15094 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15096 encryptedVerifierHash_pos
++;
15098 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;
15100 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15102 const uint version
= atoi (version_pos
);
15104 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15106 const uint spinCount
= atoi (spinCount_pos
);
15108 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15110 const uint keySize
= atoi (keySize_pos
);
15112 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15114 const uint saltSize
= atoi (saltSize_pos
);
15116 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15122 salt
->salt_len
= 16;
15123 salt
->salt_iter
= spinCount
;
15125 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15126 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15127 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15128 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15134 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15135 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15136 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15137 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15139 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15140 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15141 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15142 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15143 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15144 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15145 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15146 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15152 digest
[0] = office2013
->encryptedVerifierHash
[0];
15153 digest
[1] = office2013
->encryptedVerifierHash
[1];
15154 digest
[2] = office2013
->encryptedVerifierHash
[2];
15155 digest
[3] = office2013
->encryptedVerifierHash
[3];
15157 return (PARSER_OK
);
15160 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15162 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15164 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15166 u32
*digest
= (u32
*) hash_buf
->digest
;
15168 salt_t
*salt
= hash_buf
->salt
;
15170 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15176 char *version_pos
= input_buf
+ 11;
15178 char *osalt_pos
= strchr (version_pos
, '*');
15180 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15182 u32 version_len
= osalt_pos
- version_pos
;
15184 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15188 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15190 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15192 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15194 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15196 encryptedVerifier_pos
++;
15198 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15200 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15202 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15204 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15206 encryptedVerifierHash_pos
++;
15208 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15210 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15212 const uint version
= *version_pos
- 0x30;
15214 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15220 oldoffice01
->version
= version
;
15222 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15223 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15224 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15225 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15227 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15228 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15229 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15230 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15232 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15233 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15234 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15235 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15237 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15238 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15239 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15240 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15246 salt
->salt_len
= 16;
15248 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15249 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15250 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15251 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15253 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15254 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15255 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15256 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15258 // this is a workaround as office produces multiple documents with the same salt
15260 salt
->salt_len
+= 32;
15262 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15263 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15264 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15265 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15266 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15267 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15268 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15269 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15275 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15276 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15277 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15278 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15280 return (PARSER_OK
);
15283 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15285 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15288 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15290 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15292 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15294 u32
*digest
= (u32
*) hash_buf
->digest
;
15296 salt_t
*salt
= hash_buf
->salt
;
15298 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15304 char *version_pos
= input_buf
+ 11;
15306 char *osalt_pos
= strchr (version_pos
, '*');
15308 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15310 u32 version_len
= osalt_pos
- version_pos
;
15312 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15316 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15318 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15320 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15322 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15324 encryptedVerifier_pos
++;
15326 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15328 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15330 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15332 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15334 encryptedVerifierHash_pos
++;
15336 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15338 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15340 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15342 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15346 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15348 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15350 const uint version
= *version_pos
- 0x30;
15352 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15358 oldoffice01
->version
= version
;
15360 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15361 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15362 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15363 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15365 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15366 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15367 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15368 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15370 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15371 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15372 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15373 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15375 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15376 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15377 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15378 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15380 oldoffice01
->rc4key
[1] = 0;
15381 oldoffice01
->rc4key
[0] = 0;
15383 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15384 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15385 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15386 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15387 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15388 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15389 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15390 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15391 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15392 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15394 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15395 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15401 salt
->salt_len
= 16;
15403 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15404 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15405 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15406 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15408 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15409 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15410 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15411 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15413 // this is a workaround as office produces multiple documents with the same salt
15415 salt
->salt_len
+= 32;
15417 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15418 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15419 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15420 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15421 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15422 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15423 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15424 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15430 digest
[0] = oldoffice01
->rc4key
[0];
15431 digest
[1] = oldoffice01
->rc4key
[1];
15435 return (PARSER_OK
);
15438 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15440 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15442 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15444 u32
*digest
= (u32
*) hash_buf
->digest
;
15446 salt_t
*salt
= hash_buf
->salt
;
15448 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15454 char *version_pos
= input_buf
+ 11;
15456 char *osalt_pos
= strchr (version_pos
, '*');
15458 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15460 u32 version_len
= osalt_pos
- version_pos
;
15462 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15466 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15468 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15470 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15472 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15474 encryptedVerifier_pos
++;
15476 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15478 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15480 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15482 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15484 encryptedVerifierHash_pos
++;
15486 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15488 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15490 const uint version
= *version_pos
- 0x30;
15492 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15498 oldoffice34
->version
= version
;
15500 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15501 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15502 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15503 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15505 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15506 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15507 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15508 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15510 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15511 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15512 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15513 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15514 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15516 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15517 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15518 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15519 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15520 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15526 salt
->salt_len
= 16;
15528 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15529 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15530 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15531 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15533 // this is a workaround as office produces multiple documents with the same salt
15535 salt
->salt_len
+= 32;
15537 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15538 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15539 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15540 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15541 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15542 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15543 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15544 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15550 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15551 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15552 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15553 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15555 return (PARSER_OK
);
15558 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15560 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15562 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15565 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15567 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15569 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15571 u32
*digest
= (u32
*) hash_buf
->digest
;
15573 salt_t
*salt
= hash_buf
->salt
;
15575 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15581 char *version_pos
= input_buf
+ 11;
15583 char *osalt_pos
= strchr (version_pos
, '*');
15585 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15587 u32 version_len
= osalt_pos
- version_pos
;
15589 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15593 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15595 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15597 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15599 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15601 encryptedVerifier_pos
++;
15603 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15605 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15607 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15609 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15611 encryptedVerifierHash_pos
++;
15613 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15615 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15617 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15619 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15623 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15625 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15627 const uint version
= *version_pos
- 0x30;
15629 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15635 oldoffice34
->version
= version
;
15637 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15638 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15639 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15640 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15642 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15643 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15644 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15645 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15647 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15648 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15649 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15650 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15651 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15653 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15654 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15655 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15656 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15657 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15659 oldoffice34
->rc4key
[1] = 0;
15660 oldoffice34
->rc4key
[0] = 0;
15662 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15663 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15664 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15665 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15666 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15667 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15668 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15669 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15670 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15671 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15673 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15674 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15680 salt
->salt_len
= 16;
15682 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15683 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15684 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15685 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15687 // this is a workaround as office produces multiple documents with the same salt
15689 salt
->salt_len
+= 32;
15691 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15692 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15693 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15694 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15695 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15696 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15697 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15698 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15704 digest
[0] = oldoffice34
->rc4key
[0];
15705 digest
[1] = oldoffice34
->rc4key
[1];
15709 return (PARSER_OK
);
15712 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15714 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15716 u32
*digest
= (u32
*) hash_buf
->digest
;
15718 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15719 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15720 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15721 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15723 digest
[0] = byte_swap_32 (digest
[0]);
15724 digest
[1] = byte_swap_32 (digest
[1]);
15725 digest
[2] = byte_swap_32 (digest
[2]);
15726 digest
[3] = byte_swap_32 (digest
[3]);
15728 return (PARSER_OK
);
15731 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15733 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15735 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15737 u32
*digest
= (u32
*) hash_buf
->digest
;
15739 salt_t
*salt
= hash_buf
->salt
;
15741 char *signature_pos
= input_buf
;
15743 char *salt_pos
= strchr (signature_pos
, '$');
15745 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15747 u32 signature_len
= salt_pos
- signature_pos
;
15749 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15753 char *hash_pos
= strchr (salt_pos
, '$');
15755 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15757 u32 salt_len
= hash_pos
- salt_pos
;
15759 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15763 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15765 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15767 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15768 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15769 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15770 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15771 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15773 digest
[0] -= SHA1M_A
;
15774 digest
[1] -= SHA1M_B
;
15775 digest
[2] -= SHA1M_C
;
15776 digest
[3] -= SHA1M_D
;
15777 digest
[4] -= SHA1M_E
;
15779 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15781 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15783 salt
->salt_len
= salt_len
;
15785 return (PARSER_OK
);
15788 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15790 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15792 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15794 u32
*digest
= (u32
*) hash_buf
->digest
;
15796 salt_t
*salt
= hash_buf
->salt
;
15798 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15804 char *iter_pos
= input_buf
+ 14;
15806 const int iter
= atoi (iter_pos
);
15808 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15810 salt
->salt_iter
= iter
- 1;
15812 char *salt_pos
= strchr (iter_pos
, '$');
15814 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15818 char *hash_pos
= strchr (salt_pos
, '$');
15820 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15822 const uint salt_len
= hash_pos
- salt_pos
;
15826 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15828 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15830 salt
->salt_len
= salt_len
;
15832 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15833 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15835 // add some stuff to normal salt to make sorted happy
15837 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15838 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15839 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15840 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15841 salt
->salt_buf
[4] = salt
->salt_iter
;
15843 // base64 decode hash
15845 u8 tmp_buf
[100] = { 0 };
15847 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15849 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15851 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15853 memcpy (digest
, tmp_buf
, 32);
15855 digest
[0] = byte_swap_32 (digest
[0]);
15856 digest
[1] = byte_swap_32 (digest
[1]);
15857 digest
[2] = byte_swap_32 (digest
[2]);
15858 digest
[3] = byte_swap_32 (digest
[3]);
15859 digest
[4] = byte_swap_32 (digest
[4]);
15860 digest
[5] = byte_swap_32 (digest
[5]);
15861 digest
[6] = byte_swap_32 (digest
[6]);
15862 digest
[7] = byte_swap_32 (digest
[7]);
15864 return (PARSER_OK
);
15867 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15869 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15871 u32
*digest
= (u32
*) hash_buf
->digest
;
15873 salt_t
*salt
= hash_buf
->salt
;
15875 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15876 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15880 digest
[0] = byte_swap_32 (digest
[0]);
15881 digest
[1] = byte_swap_32 (digest
[1]);
15883 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15884 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15885 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15887 char iter_c
= input_buf
[17];
15888 char iter_d
= input_buf
[19];
15890 // atm only defaults, let's see if there's more request
15891 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15892 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15894 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15896 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15897 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15898 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15899 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15901 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15902 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15903 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15904 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15906 salt
->salt_len
= 16;
15908 return (PARSER_OK
);
15911 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15913 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15915 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15917 u32
*digest
= (u32
*) hash_buf
->digest
;
15919 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15921 salt_t
*salt
= hash_buf
->salt
;
15923 char *salt_pos
= input_buf
+ 10;
15925 char *hash_pos
= strchr (salt_pos
, '$');
15927 uint salt_len
= hash_pos
- salt_pos
;
15929 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15933 uint hash_len
= input_len
- 10 - salt_len
- 1;
15935 // base64 decode salt
15937 u8 tmp_buf
[100] = { 0 };
15939 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
15941 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15943 tmp_buf
[salt_len
] = 0x80;
15945 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15947 salt
->salt_len
= salt_len
;
15949 // base64 decode salt
15951 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15953 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15955 uint user_len
= hash_len
- 32;
15957 const u8
*tmp_hash
= tmp_buf
+ user_len
;
15959 user_len
--; // skip the trailing space
15961 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
15962 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
15963 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
15964 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
15966 digest
[0] = byte_swap_32 (digest
[0]);
15967 digest
[1] = byte_swap_32 (digest
[1]);
15968 digest
[2] = byte_swap_32 (digest
[2]);
15969 digest
[3] = byte_swap_32 (digest
[3]);
15971 // store username for host only (output hash if cracked)
15973 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15974 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15976 return (PARSER_OK
);
15979 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15981 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15983 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15985 u32
*digest
= (u32
*) hash_buf
->digest
;
15987 salt_t
*salt
= hash_buf
->salt
;
15989 char *iter_pos
= input_buf
+ 10;
15991 u32 iter
= atoi (iter_pos
);
15995 return (PARSER_SALT_ITERATION
);
15998 iter
--; // first iteration is special
16000 salt
->salt_iter
= iter
;
16002 char *base64_pos
= strchr (iter_pos
, '}');
16004 if (base64_pos
== NULL
)
16006 return (PARSER_SIGNATURE_UNMATCHED
);
16011 // base64 decode salt
16013 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16015 u8 tmp_buf
[100] = { 0 };
16017 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16019 if (decoded_len
< 24)
16021 return (PARSER_SALT_LENGTH
);
16026 uint salt_len
= decoded_len
- 20;
16028 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16029 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16031 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16033 salt
->salt_len
= salt_len
;
16037 u32
*digest_ptr
= (u32
*) tmp_buf
;
16039 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16040 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16041 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16042 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16043 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16045 return (PARSER_OK
);
16048 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16050 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16052 u32
*digest
= (u32
*) hash_buf
->digest
;
16054 salt_t
*salt
= hash_buf
->salt
;
16056 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16057 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16058 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16059 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16060 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16062 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16064 uint salt_len
= input_len
- 40 - 1;
16066 char *salt_buf
= input_buf
+ 40 + 1;
16068 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16070 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16072 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16074 salt
->salt_len
= salt_len
;
16076 return (PARSER_OK
);
16079 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16081 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16083 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16085 u32
*digest
= (u32
*) hash_buf
->digest
;
16087 salt_t
*salt
= hash_buf
->salt
;
16089 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16095 char *V_pos
= input_buf
+ 5;
16097 char *R_pos
= strchr (V_pos
, '*');
16099 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16101 u32 V_len
= R_pos
- V_pos
;
16105 char *bits_pos
= strchr (R_pos
, '*');
16107 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16109 u32 R_len
= bits_pos
- R_pos
;
16113 char *P_pos
= strchr (bits_pos
, '*');
16115 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16117 u32 bits_len
= P_pos
- bits_pos
;
16121 char *enc_md_pos
= strchr (P_pos
, '*');
16123 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16125 u32 P_len
= enc_md_pos
- P_pos
;
16129 char *id_len_pos
= strchr (enc_md_pos
, '*');
16131 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16133 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16137 char *id_buf_pos
= strchr (id_len_pos
, '*');
16139 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16141 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16145 char *u_len_pos
= strchr (id_buf_pos
, '*');
16147 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16149 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16151 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16155 char *u_buf_pos
= strchr (u_len_pos
, '*');
16157 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16159 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16163 char *o_len_pos
= strchr (u_buf_pos
, '*');
16165 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16167 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16169 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16173 char *o_buf_pos
= strchr (o_len_pos
, '*');
16175 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16177 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16181 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;
16183 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16187 const int V
= atoi (V_pos
);
16188 const int R
= atoi (R_pos
);
16189 const int P
= atoi (P_pos
);
16191 if (V
!= 1) return (PARSER_SALT_VALUE
);
16192 if (R
!= 2) return (PARSER_SALT_VALUE
);
16194 const int enc_md
= atoi (enc_md_pos
);
16196 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16198 const int id_len
= atoi (id_len_pos
);
16199 const int u_len
= atoi (u_len_pos
);
16200 const int o_len
= atoi (o_len_pos
);
16202 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16203 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16204 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16206 const int bits
= atoi (bits_pos
);
16208 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16210 // copy data to esalt
16216 pdf
->enc_md
= enc_md
;
16218 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16219 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16220 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16221 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16222 pdf
->id_len
= id_len
;
16224 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16225 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16226 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16227 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16228 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16229 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16230 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16231 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16232 pdf
->u_len
= u_len
;
16234 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16235 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16236 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16237 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16238 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16239 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16240 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16241 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16242 pdf
->o_len
= o_len
;
16244 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16245 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16246 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16247 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16249 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16250 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16251 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16252 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16253 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16254 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16255 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16256 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16258 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16259 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16260 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16261 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16262 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16263 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16264 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16265 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16267 // we use ID for salt, maybe needs to change, we will see...
16269 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16270 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16271 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16272 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16273 salt
->salt_len
= pdf
->id_len
;
16275 digest
[0] = pdf
->u_buf
[0];
16276 digest
[1] = pdf
->u_buf
[1];
16277 digest
[2] = pdf
->u_buf
[2];
16278 digest
[3] = pdf
->u_buf
[3];
16280 return (PARSER_OK
);
16283 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16285 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16288 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16290 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16292 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16294 u32
*digest
= (u32
*) hash_buf
->digest
;
16296 salt_t
*salt
= hash_buf
->salt
;
16298 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16304 char *V_pos
= input_buf
+ 5;
16306 char *R_pos
= strchr (V_pos
, '*');
16308 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16310 u32 V_len
= R_pos
- V_pos
;
16314 char *bits_pos
= strchr (R_pos
, '*');
16316 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16318 u32 R_len
= bits_pos
- R_pos
;
16322 char *P_pos
= strchr (bits_pos
, '*');
16324 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16326 u32 bits_len
= P_pos
- bits_pos
;
16330 char *enc_md_pos
= strchr (P_pos
, '*');
16332 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16334 u32 P_len
= enc_md_pos
- P_pos
;
16338 char *id_len_pos
= strchr (enc_md_pos
, '*');
16340 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16342 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16346 char *id_buf_pos
= strchr (id_len_pos
, '*');
16348 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16350 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16354 char *u_len_pos
= strchr (id_buf_pos
, '*');
16356 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16358 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16360 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16364 char *u_buf_pos
= strchr (u_len_pos
, '*');
16366 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16368 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16372 char *o_len_pos
= strchr (u_buf_pos
, '*');
16374 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16376 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16378 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16382 char *o_buf_pos
= strchr (o_len_pos
, '*');
16384 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16386 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16390 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16392 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16394 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16396 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16400 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;
16402 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16406 const int V
= atoi (V_pos
);
16407 const int R
= atoi (R_pos
);
16408 const int P
= atoi (P_pos
);
16410 if (V
!= 1) return (PARSER_SALT_VALUE
);
16411 if (R
!= 2) return (PARSER_SALT_VALUE
);
16413 const int enc_md
= atoi (enc_md_pos
);
16415 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16417 const int id_len
= atoi (id_len_pos
);
16418 const int u_len
= atoi (u_len_pos
);
16419 const int o_len
= atoi (o_len_pos
);
16421 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16422 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16423 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16425 const int bits
= atoi (bits_pos
);
16427 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16429 // copy data to esalt
16435 pdf
->enc_md
= enc_md
;
16437 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16438 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16439 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16440 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16441 pdf
->id_len
= id_len
;
16443 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16444 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16445 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16446 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16447 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16448 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16449 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16450 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16451 pdf
->u_len
= u_len
;
16453 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16454 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16455 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16456 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16457 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16458 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16459 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16460 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16461 pdf
->o_len
= o_len
;
16463 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16464 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16465 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16466 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16468 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16469 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16470 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16471 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16472 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16473 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16474 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16475 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16477 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16478 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16479 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16480 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16481 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16482 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16483 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16484 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16486 pdf
->rc4key
[1] = 0;
16487 pdf
->rc4key
[0] = 0;
16489 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16490 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16491 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16492 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16493 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16494 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16495 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16496 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16497 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16498 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16500 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16501 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16503 // we use ID for salt, maybe needs to change, we will see...
16505 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16506 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16507 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16508 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16509 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16510 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16511 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16512 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16513 salt
->salt_len
= pdf
->id_len
+ 16;
16515 digest
[0] = pdf
->rc4key
[0];
16516 digest
[1] = pdf
->rc4key
[1];
16520 return (PARSER_OK
);
16523 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16525 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16527 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16529 u32
*digest
= (u32
*) hash_buf
->digest
;
16531 salt_t
*salt
= hash_buf
->salt
;
16533 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16539 char *V_pos
= input_buf
+ 5;
16541 char *R_pos
= strchr (V_pos
, '*');
16543 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16545 u32 V_len
= R_pos
- V_pos
;
16549 char *bits_pos
= strchr (R_pos
, '*');
16551 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16553 u32 R_len
= bits_pos
- R_pos
;
16557 char *P_pos
= strchr (bits_pos
, '*');
16559 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16561 u32 bits_len
= P_pos
- bits_pos
;
16565 char *enc_md_pos
= strchr (P_pos
, '*');
16567 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16569 u32 P_len
= enc_md_pos
- P_pos
;
16573 char *id_len_pos
= strchr (enc_md_pos
, '*');
16575 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16577 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16581 char *id_buf_pos
= strchr (id_len_pos
, '*');
16583 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16585 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16589 char *u_len_pos
= strchr (id_buf_pos
, '*');
16591 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16593 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16595 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16599 char *u_buf_pos
= strchr (u_len_pos
, '*');
16601 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16603 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16607 char *o_len_pos
= strchr (u_buf_pos
, '*');
16609 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16611 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16613 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16617 char *o_buf_pos
= strchr (o_len_pos
, '*');
16619 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16621 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16625 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;
16627 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16631 const int V
= atoi (V_pos
);
16632 const int R
= atoi (R_pos
);
16633 const int P
= atoi (P_pos
);
16637 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16638 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16640 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16642 const int id_len
= atoi (id_len_pos
);
16643 const int u_len
= atoi (u_len_pos
);
16644 const int o_len
= atoi (o_len_pos
);
16646 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16648 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16649 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16651 const int bits
= atoi (bits_pos
);
16653 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16659 enc_md
= atoi (enc_md_pos
);
16662 // copy data to esalt
16668 pdf
->enc_md
= enc_md
;
16670 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16671 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16672 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16673 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16677 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16678 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16679 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16680 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16683 pdf
->id_len
= id_len
;
16685 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16686 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16687 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16688 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16689 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16690 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16691 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16692 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16693 pdf
->u_len
= u_len
;
16695 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16696 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16697 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16698 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16699 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16700 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16701 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16702 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16703 pdf
->o_len
= o_len
;
16705 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16706 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16707 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16708 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16712 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16713 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16714 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16715 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16718 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16719 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16720 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16721 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16722 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16723 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16724 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16725 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16727 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16728 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16729 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16730 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16731 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16732 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16733 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16734 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16736 // precompute rc4 data for later use
16752 uint salt_pc_block
[32] = { 0 };
16754 char *salt_pc_ptr
= (char *) salt_pc_block
;
16756 memcpy (salt_pc_ptr
, padding
, 32);
16757 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16759 uint salt_pc_digest
[4] = { 0 };
16761 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16763 pdf
->rc4data
[0] = salt_pc_digest
[0];
16764 pdf
->rc4data
[1] = salt_pc_digest
[1];
16766 // we use ID for salt, maybe needs to change, we will see...
16768 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16769 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16770 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16771 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16772 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16773 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16774 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16775 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16776 salt
->salt_len
= pdf
->id_len
+ 16;
16778 salt
->salt_iter
= ROUNDS_PDF14
;
16780 digest
[0] = pdf
->u_buf
[0];
16781 digest
[1] = pdf
->u_buf
[1];
16785 return (PARSER_OK
);
16788 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16790 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16792 if (ret
!= PARSER_OK
)
16797 u32
*digest
= (u32
*) hash_buf
->digest
;
16799 salt_t
*salt
= hash_buf
->salt
;
16801 digest
[0] -= SHA256M_A
;
16802 digest
[1] -= SHA256M_B
;
16803 digest
[2] -= SHA256M_C
;
16804 digest
[3] -= SHA256M_D
;
16805 digest
[4] -= SHA256M_E
;
16806 digest
[5] -= SHA256M_F
;
16807 digest
[6] -= SHA256M_G
;
16808 digest
[7] -= SHA256M_H
;
16810 salt
->salt_buf
[2] = 0x80;
16812 return (PARSER_OK
);
16815 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16817 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16819 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16821 u32
*digest
= (u32
*) hash_buf
->digest
;
16823 salt_t
*salt
= hash_buf
->salt
;
16825 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16831 char *V_pos
= input_buf
+ 5;
16833 char *R_pos
= strchr (V_pos
, '*');
16835 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16837 u32 V_len
= R_pos
- V_pos
;
16841 char *bits_pos
= strchr (R_pos
, '*');
16843 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16845 u32 R_len
= bits_pos
- R_pos
;
16849 char *P_pos
= strchr (bits_pos
, '*');
16851 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16853 u32 bits_len
= P_pos
- bits_pos
;
16857 char *enc_md_pos
= strchr (P_pos
, '*');
16859 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16861 u32 P_len
= enc_md_pos
- P_pos
;
16865 char *id_len_pos
= strchr (enc_md_pos
, '*');
16867 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16869 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16873 char *id_buf_pos
= strchr (id_len_pos
, '*');
16875 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16877 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16881 char *u_len_pos
= strchr (id_buf_pos
, '*');
16883 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16885 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16889 char *u_buf_pos
= strchr (u_len_pos
, '*');
16891 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16893 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16897 char *o_len_pos
= strchr (u_buf_pos
, '*');
16899 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16901 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16905 char *o_buf_pos
= strchr (o_len_pos
, '*');
16907 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16909 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16913 char *last
= strchr (o_buf_pos
, '*');
16915 if (last
== NULL
) last
= input_buf
+ input_len
;
16917 u32 o_buf_len
= last
- o_buf_pos
;
16921 const int V
= atoi (V_pos
);
16922 const int R
= atoi (R_pos
);
16926 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16927 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16929 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16931 const int bits
= atoi (bits_pos
);
16933 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16935 int enc_md
= atoi (enc_md_pos
);
16937 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16939 const uint id_len
= atoi (id_len_pos
);
16940 const uint u_len
= atoi (u_len_pos
);
16941 const uint o_len
= atoi (o_len_pos
);
16943 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16944 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16945 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16946 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16947 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16948 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16949 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16950 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16952 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16953 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16954 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16956 // copy data to esalt
16958 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16960 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16962 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
16965 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16966 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16968 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16969 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16971 salt
->salt_len
= 8;
16972 salt
->salt_iter
= ROUNDS_PDF17L8
;
16974 digest
[0] = pdf
->u_buf
[0];
16975 digest
[1] = pdf
->u_buf
[1];
16976 digest
[2] = pdf
->u_buf
[2];
16977 digest
[3] = pdf
->u_buf
[3];
16978 digest
[4] = pdf
->u_buf
[4];
16979 digest
[5] = pdf
->u_buf
[5];
16980 digest
[6] = pdf
->u_buf
[6];
16981 digest
[7] = pdf
->u_buf
[7];
16983 return (PARSER_OK
);
16986 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16988 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
16990 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
16992 u32
*digest
= (u32
*) hash_buf
->digest
;
16994 salt_t
*salt
= hash_buf
->salt
;
16996 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17004 char *iter_pos
= input_buf
+ 7;
17006 u32 iter
= atoi (iter_pos
);
17008 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17009 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17011 // first is *raw* salt
17013 char *salt_pos
= strchr (iter_pos
, ':');
17015 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17019 char *hash_pos
= strchr (salt_pos
, ':');
17021 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17023 u32 salt_len
= hash_pos
- salt_pos
;
17025 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17029 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17031 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17035 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17037 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17039 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17041 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17042 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17044 salt
->salt_len
= salt_len
;
17045 salt
->salt_iter
= iter
- 1;
17049 u8 tmp_buf
[100] = { 0 };
17051 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17053 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17055 memcpy (digest
, tmp_buf
, 16);
17057 digest
[0] = byte_swap_32 (digest
[0]);
17058 digest
[1] = byte_swap_32 (digest
[1]);
17059 digest
[2] = byte_swap_32 (digest
[2]);
17060 digest
[3] = byte_swap_32 (digest
[3]);
17062 // add some stuff to normal salt to make sorted happy
17064 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17065 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17066 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17067 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17068 salt
->salt_buf
[4] = salt
->salt_iter
;
17070 return (PARSER_OK
);
17073 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17075 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17077 u32
*digest
= (u32
*) hash_buf
->digest
;
17079 salt_t
*salt
= hash_buf
->salt
;
17081 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17082 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17083 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17084 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17086 digest
[0] = byte_swap_32 (digest
[0]);
17087 digest
[1] = byte_swap_32 (digest
[1]);
17088 digest
[2] = byte_swap_32 (digest
[2]);
17089 digest
[3] = byte_swap_32 (digest
[3]);
17091 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17093 uint salt_len
= input_len
- 32 - 1;
17095 char *salt_buf
= input_buf
+ 32 + 1;
17097 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17099 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17101 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17103 salt
->salt_len
= salt_len
;
17105 return (PARSER_OK
);
17108 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17110 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17112 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17114 u32
*digest
= (u32
*) hash_buf
->digest
;
17116 salt_t
*salt
= hash_buf
->salt
;
17118 char *user_pos
= input_buf
+ 10;
17120 char *salt_pos
= strchr (user_pos
, '*');
17122 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17126 char *hash_pos
= strchr (salt_pos
, '*');
17130 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17132 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17134 uint user_len
= salt_pos
- user_pos
- 1;
17136 uint salt_len
= hash_pos
- salt_pos
- 1;
17138 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17144 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17145 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17146 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17147 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17149 digest
[0] = byte_swap_32 (digest
[0]);
17150 digest
[1] = byte_swap_32 (digest
[1]);
17151 digest
[2] = byte_swap_32 (digest
[2]);
17152 digest
[3] = byte_swap_32 (digest
[3]);
17154 digest
[0] -= MD5M_A
;
17155 digest
[1] -= MD5M_B
;
17156 digest
[2] -= MD5M_C
;
17157 digest
[3] -= MD5M_D
;
17163 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17165 // first 4 bytes are the "challenge"
17167 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17168 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17169 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17170 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17172 // append the user name
17174 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17176 salt
->salt_len
= 4 + user_len
;
17178 return (PARSER_OK
);
17181 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17183 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17185 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17187 u32
*digest
= (u32
*) hash_buf
->digest
;
17189 salt_t
*salt
= hash_buf
->salt
;
17191 char *salt_pos
= input_buf
+ 9;
17193 char *hash_pos
= strchr (salt_pos
, '*');
17195 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17199 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17201 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17203 uint salt_len
= hash_pos
- salt_pos
- 1;
17205 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17211 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17212 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17213 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17214 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17215 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17221 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17223 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17225 salt
->salt_len
= salt_len
;
17227 return (PARSER_OK
);
17230 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17232 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17234 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17236 u32
*digest
= (u32
*) hash_buf
->digest
;
17238 salt_t
*salt
= hash_buf
->salt
;
17240 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17246 char *cry_master_len_pos
= input_buf
+ 9;
17248 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17250 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17252 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17254 cry_master_buf_pos
++;
17256 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17258 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17260 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17262 cry_salt_len_pos
++;
17264 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17266 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17268 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17270 cry_salt_buf_pos
++;
17272 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17274 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17276 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17280 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17282 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17284 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17288 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17290 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17292 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17296 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17298 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17300 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17302 public_key_len_pos
++;
17304 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17306 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17308 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17310 public_key_buf_pos
++;
17312 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;
17314 const uint cry_master_len
= atoi (cry_master_len_pos
);
17315 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17316 const uint ckey_len
= atoi (ckey_len_pos
);
17317 const uint public_key_len
= atoi (public_key_len_pos
);
17319 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17320 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17321 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17322 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17324 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17326 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17328 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17331 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17333 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17335 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17338 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17340 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17342 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17345 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17346 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17347 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17350 * store digest (should be unique enought, hopefully)
17353 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17354 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17355 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17356 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17362 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17364 const uint cry_rounds
= atoi (cry_rounds_pos
);
17366 salt
->salt_iter
= cry_rounds
- 1;
17368 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17370 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17372 salt
->salt_len
= salt_len
;
17374 return (PARSER_OK
);
17377 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17379 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17381 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17383 u32
*digest
= (u32
*) hash_buf
->digest
;
17385 salt_t
*salt
= hash_buf
->salt
;
17387 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17389 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17391 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17393 memcpy (temp_input_buf
, input_buf
, input_len
);
17397 char *URI_server_pos
= temp_input_buf
+ 6;
17399 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17401 if (URI_client_pos
== NULL
)
17403 myfree (temp_input_buf
);
17405 return (PARSER_SEPARATOR_UNMATCHED
);
17408 URI_client_pos
[0] = 0;
17411 uint URI_server_len
= strlen (URI_server_pos
);
17413 if (URI_server_len
> 512)
17415 myfree (temp_input_buf
);
17417 return (PARSER_SALT_LENGTH
);
17422 char *user_pos
= strchr (URI_client_pos
, '*');
17424 if (user_pos
== NULL
)
17426 myfree (temp_input_buf
);
17428 return (PARSER_SEPARATOR_UNMATCHED
);
17434 uint URI_client_len
= strlen (URI_client_pos
);
17436 if (URI_client_len
> 512)
17438 myfree (temp_input_buf
);
17440 return (PARSER_SALT_LENGTH
);
17445 char *realm_pos
= strchr (user_pos
, '*');
17447 if (realm_pos
== NULL
)
17449 myfree (temp_input_buf
);
17451 return (PARSER_SEPARATOR_UNMATCHED
);
17457 uint user_len
= strlen (user_pos
);
17459 if (user_len
> 116)
17461 myfree (temp_input_buf
);
17463 return (PARSER_SALT_LENGTH
);
17468 char *method_pos
= strchr (realm_pos
, '*');
17470 if (method_pos
== NULL
)
17472 myfree (temp_input_buf
);
17474 return (PARSER_SEPARATOR_UNMATCHED
);
17480 uint realm_len
= strlen (realm_pos
);
17482 if (realm_len
> 116)
17484 myfree (temp_input_buf
);
17486 return (PARSER_SALT_LENGTH
);
17491 char *URI_prefix_pos
= strchr (method_pos
, '*');
17493 if (URI_prefix_pos
== NULL
)
17495 myfree (temp_input_buf
);
17497 return (PARSER_SEPARATOR_UNMATCHED
);
17500 URI_prefix_pos
[0] = 0;
17503 uint method_len
= strlen (method_pos
);
17505 if (method_len
> 246)
17507 myfree (temp_input_buf
);
17509 return (PARSER_SALT_LENGTH
);
17514 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17516 if (URI_resource_pos
== NULL
)
17518 myfree (temp_input_buf
);
17520 return (PARSER_SEPARATOR_UNMATCHED
);
17523 URI_resource_pos
[0] = 0;
17524 URI_resource_pos
++;
17526 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17528 if (URI_prefix_len
> 245)
17530 myfree (temp_input_buf
);
17532 return (PARSER_SALT_LENGTH
);
17537 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17539 if (URI_suffix_pos
== NULL
)
17541 myfree (temp_input_buf
);
17543 return (PARSER_SEPARATOR_UNMATCHED
);
17546 URI_suffix_pos
[0] = 0;
17549 uint URI_resource_len
= strlen (URI_resource_pos
);
17551 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17553 myfree (temp_input_buf
);
17555 return (PARSER_SALT_LENGTH
);
17560 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17562 if (nonce_pos
== NULL
)
17564 myfree (temp_input_buf
);
17566 return (PARSER_SEPARATOR_UNMATCHED
);
17572 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17574 if (URI_suffix_len
> 245)
17576 myfree (temp_input_buf
);
17578 return (PARSER_SALT_LENGTH
);
17583 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17585 if (nonce_client_pos
== NULL
)
17587 myfree (temp_input_buf
);
17589 return (PARSER_SEPARATOR_UNMATCHED
);
17592 nonce_client_pos
[0] = 0;
17593 nonce_client_pos
++;
17595 uint nonce_len
= strlen (nonce_pos
);
17597 if (nonce_len
< 1 || nonce_len
> 50)
17599 myfree (temp_input_buf
);
17601 return (PARSER_SALT_LENGTH
);
17606 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17608 if (nonce_count_pos
== NULL
)
17610 myfree (temp_input_buf
);
17612 return (PARSER_SEPARATOR_UNMATCHED
);
17615 nonce_count_pos
[0] = 0;
17618 uint nonce_client_len
= strlen (nonce_client_pos
);
17620 if (nonce_client_len
> 50)
17622 myfree (temp_input_buf
);
17624 return (PARSER_SALT_LENGTH
);
17629 char *qop_pos
= strchr (nonce_count_pos
, '*');
17631 if (qop_pos
== NULL
)
17633 myfree (temp_input_buf
);
17635 return (PARSER_SEPARATOR_UNMATCHED
);
17641 uint nonce_count_len
= strlen (nonce_count_pos
);
17643 if (nonce_count_len
> 50)
17645 myfree (temp_input_buf
);
17647 return (PARSER_SALT_LENGTH
);
17652 char *directive_pos
= strchr (qop_pos
, '*');
17654 if (directive_pos
== NULL
)
17656 myfree (temp_input_buf
);
17658 return (PARSER_SEPARATOR_UNMATCHED
);
17661 directive_pos
[0] = 0;
17664 uint qop_len
= strlen (qop_pos
);
17668 myfree (temp_input_buf
);
17670 return (PARSER_SALT_LENGTH
);
17675 char *digest_pos
= strchr (directive_pos
, '*');
17677 if (digest_pos
== NULL
)
17679 myfree (temp_input_buf
);
17681 return (PARSER_SEPARATOR_UNMATCHED
);
17687 uint directive_len
= strlen (directive_pos
);
17689 if (directive_len
!= 3)
17691 myfree (temp_input_buf
);
17693 return (PARSER_SALT_LENGTH
);
17696 if (memcmp (directive_pos
, "MD5", 3))
17698 log_info ("ERROR: only the MD5 directive is currently supported\n");
17700 myfree (temp_input_buf
);
17702 return (PARSER_SIP_AUTH_DIRECTIVE
);
17706 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17711 uint md5_max_len
= 4 * 64;
17713 uint md5_remaining_len
= md5_max_len
;
17715 uint tmp_md5_buf
[64] = { 0 };
17717 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17719 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17721 md5_len
+= method_len
+ 1;
17722 tmp_md5_ptr
+= method_len
+ 1;
17724 if (URI_prefix_len
> 0)
17726 md5_remaining_len
= md5_max_len
- md5_len
;
17728 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17730 md5_len
+= URI_prefix_len
+ 1;
17731 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17734 md5_remaining_len
= md5_max_len
- md5_len
;
17736 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17738 md5_len
+= URI_resource_len
;
17739 tmp_md5_ptr
+= URI_resource_len
;
17741 if (URI_suffix_len
> 0)
17743 md5_remaining_len
= md5_max_len
- md5_len
;
17745 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17747 md5_len
+= 1 + URI_suffix_len
;
17750 uint tmp_digest
[4] = { 0 };
17752 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17754 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17755 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17756 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17757 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17763 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17765 uint esalt_len
= 0;
17767 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17769 // there are 2 possibilities for the esalt:
17771 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17773 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17775 if (esalt_len
> max_esalt_len
)
17777 myfree (temp_input_buf
);
17779 return (PARSER_SALT_LENGTH
);
17782 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17794 esalt_len
= 1 + nonce_len
+ 1 + 32;
17796 if (esalt_len
> max_esalt_len
)
17798 myfree (temp_input_buf
);
17800 return (PARSER_SALT_LENGTH
);
17803 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17811 // add 0x80 to esalt
17813 esalt_buf_ptr
[esalt_len
] = 0x80;
17815 sip
->esalt_len
= esalt_len
;
17821 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17823 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17825 uint max_salt_len
= 119;
17827 if (salt_len
> max_salt_len
)
17829 myfree (temp_input_buf
);
17831 return (PARSER_SALT_LENGTH
);
17834 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17836 sip
->salt_len
= salt_len
;
17839 * fake salt (for sorting)
17842 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17846 uint fake_salt_len
= salt_len
;
17848 if (fake_salt_len
> max_salt_len
)
17850 fake_salt_len
= max_salt_len
;
17853 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17855 salt
->salt_len
= fake_salt_len
;
17861 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17862 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17863 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17864 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17866 digest
[0] = byte_swap_32 (digest
[0]);
17867 digest
[1] = byte_swap_32 (digest
[1]);
17868 digest
[2] = byte_swap_32 (digest
[2]);
17869 digest
[3] = byte_swap_32 (digest
[3]);
17871 myfree (temp_input_buf
);
17873 return (PARSER_OK
);
17876 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17878 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17880 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17882 u32
*digest
= (u32
*) hash_buf
->digest
;
17884 salt_t
*salt
= hash_buf
->salt
;
17888 char *digest_pos
= input_buf
;
17890 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17897 char *salt_buf
= input_buf
+ 8 + 1;
17901 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17903 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17905 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17907 salt
->salt_len
= salt_len
;
17909 return (PARSER_OK
);
17912 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17914 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17916 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17918 u32
*digest
= (u32
*) hash_buf
->digest
;
17920 salt_t
*salt
= hash_buf
->salt
;
17922 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17928 char *p_buf_pos
= input_buf
+ 4;
17930 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17932 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17934 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17936 NumCyclesPower_pos
++;
17938 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17940 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17942 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17946 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17948 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17950 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
17954 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17956 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17958 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17962 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17964 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17966 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
17970 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17972 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17974 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17978 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17980 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17982 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
17986 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17988 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17990 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
17994 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17996 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17998 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18002 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;
18004 const uint iter
= atoi (NumCyclesPower_pos
);
18005 const uint crc
= atoi (crc_buf_pos
);
18006 const uint p_buf
= atoi (p_buf_pos
);
18007 const uint salt_len
= atoi (salt_len_pos
);
18008 const uint iv_len
= atoi (iv_len_pos
);
18009 const uint unpack_size
= atoi (unpack_size_pos
);
18010 const uint data_len
= atoi (data_len_pos
);
18016 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18017 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18019 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18021 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18023 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18029 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18030 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18031 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18032 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18034 seven_zip
->iv_len
= iv_len
;
18036 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18038 seven_zip
->salt_len
= 0;
18040 seven_zip
->crc
= crc
;
18042 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18044 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18046 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18049 seven_zip
->data_len
= data_len
;
18051 seven_zip
->unpack_size
= unpack_size
;
18055 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18056 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18057 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18058 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18060 salt
->salt_len
= 16;
18062 salt
->salt_sign
[0] = iter
;
18064 salt
->salt_iter
= 1 << iter
;
18075 return (PARSER_OK
);
18078 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18080 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18082 u32
*digest
= (u32
*) hash_buf
->digest
;
18084 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18085 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18086 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18087 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18088 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18089 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18090 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18091 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18093 digest
[0] = byte_swap_32 (digest
[0]);
18094 digest
[1] = byte_swap_32 (digest
[1]);
18095 digest
[2] = byte_swap_32 (digest
[2]);
18096 digest
[3] = byte_swap_32 (digest
[3]);
18097 digest
[4] = byte_swap_32 (digest
[4]);
18098 digest
[5] = byte_swap_32 (digest
[5]);
18099 digest
[6] = byte_swap_32 (digest
[6]);
18100 digest
[7] = byte_swap_32 (digest
[7]);
18102 return (PARSER_OK
);
18105 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18107 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18109 u32
*digest
= (u32
*) hash_buf
->digest
;
18111 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18112 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18113 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18114 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18115 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18116 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18117 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18118 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18119 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18120 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18121 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18122 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18123 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18124 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18125 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18126 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18128 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18129 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18130 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18131 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18132 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18133 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18134 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18135 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18136 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18137 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18138 digest
[10] = byte_swap_32 (digest
[10]);
18139 digest
[11] = byte_swap_32 (digest
[11]);
18140 digest
[12] = byte_swap_32 (digest
[12]);
18141 digest
[13] = byte_swap_32 (digest
[13]);
18142 digest
[14] = byte_swap_32 (digest
[14]);
18143 digest
[15] = byte_swap_32 (digest
[15]);
18145 return (PARSER_OK
);
18148 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18150 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18152 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18154 u32
*digest
= (u32
*) hash_buf
->digest
;
18156 salt_t
*salt
= hash_buf
->salt
;
18158 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18166 char *iter_pos
= input_buf
+ 4;
18168 u32 iter
= atoi (iter_pos
);
18170 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18171 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18173 // first is *raw* salt
18175 char *salt_pos
= strchr (iter_pos
, ':');
18177 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18181 char *hash_pos
= strchr (salt_pos
, ':');
18183 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18185 u32 salt_len
= hash_pos
- salt_pos
;
18187 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18191 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18193 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18197 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18199 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18201 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18203 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18204 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18206 salt
->salt_len
= salt_len
;
18207 salt
->salt_iter
= iter
- 1;
18211 u8 tmp_buf
[100] = { 0 };
18213 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18215 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18217 memcpy (digest
, tmp_buf
, 16);
18219 // add some stuff to normal salt to make sorted happy
18221 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18222 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18223 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18224 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18225 salt
->salt_buf
[4] = salt
->salt_iter
;
18227 return (PARSER_OK
);
18230 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18232 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18234 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18236 u32
*digest
= (u32
*) hash_buf
->digest
;
18238 salt_t
*salt
= hash_buf
->salt
;
18240 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18248 char *iter_pos
= input_buf
+ 5;
18250 u32 iter
= atoi (iter_pos
);
18252 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18253 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18255 // first is *raw* salt
18257 char *salt_pos
= strchr (iter_pos
, ':');
18259 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18263 char *hash_pos
= strchr (salt_pos
, ':');
18265 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18267 u32 salt_len
= hash_pos
- salt_pos
;
18269 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18273 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18275 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18279 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18281 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18283 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18285 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18286 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18288 salt
->salt_len
= salt_len
;
18289 salt
->salt_iter
= iter
- 1;
18293 u8 tmp_buf
[100] = { 0 };
18295 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18297 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18299 memcpy (digest
, tmp_buf
, 16);
18301 digest
[0] = byte_swap_32 (digest
[0]);
18302 digest
[1] = byte_swap_32 (digest
[1]);
18303 digest
[2] = byte_swap_32 (digest
[2]);
18304 digest
[3] = byte_swap_32 (digest
[3]);
18306 // add some stuff to normal salt to make sorted happy
18308 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18309 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18310 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18311 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18312 salt
->salt_buf
[4] = salt
->salt_iter
;
18314 return (PARSER_OK
);
18317 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18319 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18321 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18323 u64
*digest
= (u64
*) hash_buf
->digest
;
18325 salt_t
*salt
= hash_buf
->salt
;
18327 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18335 char *iter_pos
= input_buf
+ 7;
18337 u32 iter
= atoi (iter_pos
);
18339 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18340 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18342 // first is *raw* salt
18344 char *salt_pos
= strchr (iter_pos
, ':');
18346 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18350 char *hash_pos
= strchr (salt_pos
, ':');
18352 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18354 u32 salt_len
= hash_pos
- salt_pos
;
18356 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18360 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18362 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18366 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18368 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18370 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18372 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18373 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18375 salt
->salt_len
= salt_len
;
18376 salt
->salt_iter
= iter
- 1;
18380 u8 tmp_buf
[100] = { 0 };
18382 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18384 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18386 memcpy (digest
, tmp_buf
, 64);
18388 digest
[0] = byte_swap_64 (digest
[0]);
18389 digest
[1] = byte_swap_64 (digest
[1]);
18390 digest
[2] = byte_swap_64 (digest
[2]);
18391 digest
[3] = byte_swap_64 (digest
[3]);
18392 digest
[4] = byte_swap_64 (digest
[4]);
18393 digest
[5] = byte_swap_64 (digest
[5]);
18394 digest
[6] = byte_swap_64 (digest
[6]);
18395 digest
[7] = byte_swap_64 (digest
[7]);
18397 // add some stuff to normal salt to make sorted happy
18399 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18400 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18401 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18402 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18403 salt
->salt_buf
[4] = salt
->salt_iter
;
18405 return (PARSER_OK
);
18408 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18410 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18412 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18414 uint
*digest
= (uint
*) hash_buf
->digest
;
18416 salt_t
*salt
= hash_buf
->salt
;
18422 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18424 char *hash_pos
= strchr (salt_pos
, '$');
18426 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18428 u32 salt_len
= hash_pos
- salt_pos
;
18430 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18434 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18436 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18440 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18441 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18459 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18460 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18462 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18463 salt
->salt_len
= 8;
18465 return (PARSER_OK
);
18468 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18470 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18472 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18474 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18476 if (c19
& 3) return (PARSER_HASH_VALUE
);
18478 salt_t
*salt
= hash_buf
->salt
;
18480 u32
*digest
= (u32
*) hash_buf
->digest
;
18484 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18485 | itoa64_to_int (input_buf
[2]) << 6
18486 | itoa64_to_int (input_buf
[3]) << 12
18487 | itoa64_to_int (input_buf
[4]) << 18;
18491 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18492 | itoa64_to_int (input_buf
[6]) << 6
18493 | itoa64_to_int (input_buf
[7]) << 12
18494 | itoa64_to_int (input_buf
[8]) << 18;
18496 salt
->salt_len
= 4;
18498 u8 tmp_buf
[100] = { 0 };
18500 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18502 memcpy (digest
, tmp_buf
, 8);
18506 IP (digest
[0], digest
[1], tt
);
18508 digest
[0] = rotr32 (digest
[0], 31);
18509 digest
[1] = rotr32 (digest
[1], 31);
18513 return (PARSER_OK
);
18516 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18518 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18520 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18522 u32
*digest
= (u32
*) hash_buf
->digest
;
18524 salt_t
*salt
= hash_buf
->salt
;
18530 char *type_pos
= input_buf
+ 6 + 1;
18532 char *salt_pos
= strchr (type_pos
, '*');
18534 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18536 u32 type_len
= salt_pos
- type_pos
;
18538 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18542 char *crypted_pos
= strchr (salt_pos
, '*');
18544 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18546 u32 salt_len
= crypted_pos
- salt_pos
;
18548 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18552 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18554 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18560 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18561 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18563 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18564 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18566 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18567 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18568 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18569 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18571 salt
->salt_len
= 24;
18572 salt
->salt_iter
= ROUNDS_RAR3
;
18574 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18575 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18577 digest
[0] = 0xc43d7b00;
18578 digest
[1] = 0x40070000;
18582 return (PARSER_OK
);
18585 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18587 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18589 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18591 u32
*digest
= (u32
*) hash_buf
->digest
;
18593 salt_t
*salt
= hash_buf
->salt
;
18595 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18601 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18603 char *param1_pos
= strchr (param0_pos
, '$');
18605 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18607 u32 param0_len
= param1_pos
- param0_pos
;
18611 char *param2_pos
= strchr (param1_pos
, '$');
18613 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18615 u32 param1_len
= param2_pos
- param1_pos
;
18619 char *param3_pos
= strchr (param2_pos
, '$');
18621 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18623 u32 param2_len
= param3_pos
- param2_pos
;
18627 char *param4_pos
= strchr (param3_pos
, '$');
18629 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18631 u32 param3_len
= param4_pos
- param3_pos
;
18635 char *param5_pos
= strchr (param4_pos
, '$');
18637 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18639 u32 param4_len
= param5_pos
- param4_pos
;
18643 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18645 char *salt_buf
= param1_pos
;
18646 char *iv
= param3_pos
;
18647 char *pswcheck
= param5_pos
;
18649 const uint salt_len
= atoi (param0_pos
);
18650 const uint iterations
= atoi (param2_pos
);
18651 const uint pswcheck_len
= atoi (param4_pos
);
18657 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18658 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18659 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18661 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18662 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18663 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18669 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18670 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18671 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18672 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18674 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18675 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18676 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18677 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18679 salt
->salt_len
= 16;
18681 salt
->salt_sign
[0] = iterations
;
18683 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18689 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18690 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18694 return (PARSER_OK
);
18697 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18699 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18701 u32
*digest
= (u32
*) hash_buf
->digest
;
18703 salt_t
*salt
= hash_buf
->salt
;
18705 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18706 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18707 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18708 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18709 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18710 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18711 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18712 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18714 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18716 uint salt_len
= input_len
- 64 - 1;
18718 char *salt_buf
= input_buf
+ 64 + 1;
18720 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18722 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18724 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18726 salt
->salt_len
= salt_len
;
18729 * we can precompute the first sha256 transform
18732 uint w
[16] = { 0 };
18734 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18735 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18736 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18737 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18738 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18739 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18740 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18741 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18742 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18743 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18744 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18745 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18746 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18747 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18748 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18749 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18751 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
18753 sha256_64 (w
, pc256
);
18755 salt
->salt_buf_pc
[0] = pc256
[0];
18756 salt
->salt_buf_pc
[1] = pc256
[1];
18757 salt
->salt_buf_pc
[2] = pc256
[2];
18758 salt
->salt_buf_pc
[3] = pc256
[3];
18759 salt
->salt_buf_pc
[4] = pc256
[4];
18760 salt
->salt_buf_pc
[5] = pc256
[5];
18761 salt
->salt_buf_pc
[6] = pc256
[6];
18762 salt
->salt_buf_pc
[7] = pc256
[7];
18764 digest
[0] -= pc256
[0];
18765 digest
[1] -= pc256
[1];
18766 digest
[2] -= pc256
[2];
18767 digest
[3] -= pc256
[3];
18768 digest
[4] -= pc256
[4];
18769 digest
[5] -= pc256
[5];
18770 digest
[6] -= pc256
[6];
18771 digest
[7] -= pc256
[7];
18773 return (PARSER_OK
);
18776 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18778 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18780 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18782 u32
*digest
= (u32
*) hash_buf
->digest
;
18784 salt_t
*salt
= hash_buf
->salt
;
18790 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18792 char *data_buf_pos
= strchr (data_len_pos
, '$');
18794 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18796 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18798 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18799 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18803 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18805 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18807 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18809 u32 data_len
= atoi (data_len_pos
);
18811 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18817 char *salt_pos
= data_buf_pos
;
18819 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18820 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18821 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
18822 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
18824 // this is actually the CT, which is also the hash later (if matched)
18826 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
18827 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
18828 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
18829 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
18831 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18833 salt
->salt_iter
= 10 - 1;
18839 digest
[0] = salt
->salt_buf
[4];
18840 digest
[1] = salt
->salt_buf
[5];
18841 digest
[2] = salt
->salt_buf
[6];
18842 digest
[3] = salt
->salt_buf
[7];
18844 return (PARSER_OK
);
18847 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18849 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18851 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18853 u32
*digest
= (u32
*) hash_buf
->digest
;
18855 salt_t
*salt
= hash_buf
->salt
;
18861 char *salt_pos
= input_buf
+ 11 + 1;
18863 char *iter_pos
= strchr (salt_pos
, ',');
18865 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18867 u32 salt_len
= iter_pos
- salt_pos
;
18869 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18873 char *hash_pos
= strchr (iter_pos
, ',');
18875 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18877 u32 iter_len
= hash_pos
- iter_pos
;
18879 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18883 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18885 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18891 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18892 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18893 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
18894 salt
->salt_buf
[3] = 0x00018000;
18896 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18897 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18898 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18899 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18901 salt
->salt_len
= salt_len
/ 2;
18903 salt
->salt_iter
= atoi (iter_pos
) - 1;
18909 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18910 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18911 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18912 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18913 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18914 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18915 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18916 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18918 return (PARSER_OK
);
18921 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18923 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
18925 u32
*digest
= (u32
*) hash_buf
->digest
;
18927 salt_t
*salt
= hash_buf
->salt
;
18933 char *hash_pos
= input_buf
+ 64;
18934 char *salt1_pos
= input_buf
+ 128;
18935 char *salt2_pos
= input_buf
;
18941 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
18942 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
18943 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
18944 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
18946 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
18947 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
18948 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
18949 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
18951 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
18952 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
18953 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
18954 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
18956 salt
->salt_len
= 48;
18958 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
18964 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18965 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18966 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18967 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18968 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18969 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18970 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18971 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18973 return (PARSER_OK
);
18977 * parallel running threads
18982 BOOL WINAPI
sigHandler_default (DWORD sig
)
18986 case CTRL_CLOSE_EVENT
:
18989 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18990 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18991 * function otherwise it is too late (e.g. after returning from this function)
18996 SetConsoleCtrlHandler (NULL
, TRUE
);
19003 case CTRL_LOGOFF_EVENT
:
19004 case CTRL_SHUTDOWN_EVENT
:
19008 SetConsoleCtrlHandler (NULL
, TRUE
);
19016 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19020 case CTRL_CLOSE_EVENT
:
19024 SetConsoleCtrlHandler (NULL
, TRUE
);
19031 case CTRL_LOGOFF_EVENT
:
19032 case CTRL_SHUTDOWN_EVENT
:
19036 SetConsoleCtrlHandler (NULL
, TRUE
);
19044 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19046 if (callback
== NULL
)
19048 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19052 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19058 void sigHandler_default (int sig
)
19062 signal (sig
, NULL
);
19065 void sigHandler_benchmark (int sig
)
19069 signal (sig
, NULL
);
19072 void hc_signal (void (callback
) (int))
19074 if (callback
== NULL
) callback
= SIG_DFL
;
19076 signal (SIGINT
, callback
);
19077 signal (SIGTERM
, callback
);
19078 signal (SIGABRT
, callback
);
19083 void status_display ();
19085 void *thread_keypress (void *p
)
19087 int benchmark
= *((int *) p
);
19089 uint quiet
= data
.quiet
;
19093 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19095 int ch
= tty_getchar();
19097 if (ch
== -1) break;
19099 if (ch
== 0) continue;
19105 hc_thread_mutex_lock (mux_display
);
19120 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19121 if (quiet
== 0) fflush (stdout
);
19133 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19134 if (quiet
== 0) fflush (stdout
);
19146 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19147 if (quiet
== 0) fflush (stdout
);
19159 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19160 if (quiet
== 0) fflush (stdout
);
19168 if (benchmark
== 1) break;
19170 stop_at_checkpoint ();
19174 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19175 if (quiet
== 0) fflush (stdout
);
19183 if (benchmark
== 1)
19195 hc_thread_mutex_unlock (mux_display
);
19207 bool class_num (const u8 c
)
19209 return ((c
>= '0') && (c
<= '9'));
19212 bool class_lower (const u8 c
)
19214 return ((c
>= 'a') && (c
<= 'z'));
19217 bool class_upper (const u8 c
)
19219 return ((c
>= 'A') && (c
<= 'Z'));
19222 bool class_alpha (const u8 c
)
19224 return (class_lower (c
) || class_upper (c
));
19227 int conv_ctoi (const u8 c
)
19233 else if (class_upper (c
))
19235 return c
- 'A' + 10;
19241 int conv_itoc (const u8 c
)
19249 return c
+ 'A' - 10;
19259 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19260 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19261 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19262 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19263 #define MAX_KERNEL_RULES 255
19264 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19265 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19266 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19268 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19269 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19270 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19271 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19273 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19278 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19280 switch (rule_buf
[rule_pos
])
19286 case RULE_OP_MANGLE_NOOP
:
19287 SET_NAME (rule
, rule_buf
[rule_pos
]);
19290 case RULE_OP_MANGLE_LREST
:
19291 SET_NAME (rule
, rule_buf
[rule_pos
]);
19294 case RULE_OP_MANGLE_UREST
:
19295 SET_NAME (rule
, rule_buf
[rule_pos
]);
19298 case RULE_OP_MANGLE_LREST_UFIRST
:
19299 SET_NAME (rule
, rule_buf
[rule_pos
]);
19302 case RULE_OP_MANGLE_UREST_LFIRST
:
19303 SET_NAME (rule
, rule_buf
[rule_pos
]);
19306 case RULE_OP_MANGLE_TREST
:
19307 SET_NAME (rule
, rule_buf
[rule_pos
]);
19310 case RULE_OP_MANGLE_TOGGLE_AT
:
19311 SET_NAME (rule
, rule_buf
[rule_pos
]);
19312 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19315 case RULE_OP_MANGLE_REVERSE
:
19316 SET_NAME (rule
, rule_buf
[rule_pos
]);
19319 case RULE_OP_MANGLE_DUPEWORD
:
19320 SET_NAME (rule
, rule_buf
[rule_pos
]);
19323 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19324 SET_NAME (rule
, rule_buf
[rule_pos
]);
19325 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19328 case RULE_OP_MANGLE_REFLECT
:
19329 SET_NAME (rule
, rule_buf
[rule_pos
]);
19332 case RULE_OP_MANGLE_ROTATE_LEFT
:
19333 SET_NAME (rule
, rule_buf
[rule_pos
]);
19336 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19337 SET_NAME (rule
, rule_buf
[rule_pos
]);
19340 case RULE_OP_MANGLE_APPEND
:
19341 SET_NAME (rule
, rule_buf
[rule_pos
]);
19342 SET_P0 (rule
, rule_buf
[rule_pos
]);
19345 case RULE_OP_MANGLE_PREPEND
:
19346 SET_NAME (rule
, rule_buf
[rule_pos
]);
19347 SET_P0 (rule
, rule_buf
[rule_pos
]);
19350 case RULE_OP_MANGLE_DELETE_FIRST
:
19351 SET_NAME (rule
, rule_buf
[rule_pos
]);
19354 case RULE_OP_MANGLE_DELETE_LAST
:
19355 SET_NAME (rule
, rule_buf
[rule_pos
]);
19358 case RULE_OP_MANGLE_DELETE_AT
:
19359 SET_NAME (rule
, rule_buf
[rule_pos
]);
19360 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19363 case RULE_OP_MANGLE_EXTRACT
:
19364 SET_NAME (rule
, rule_buf
[rule_pos
]);
19365 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19366 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19369 case RULE_OP_MANGLE_OMIT
:
19370 SET_NAME (rule
, rule_buf
[rule_pos
]);
19371 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19372 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19375 case RULE_OP_MANGLE_INSERT
:
19376 SET_NAME (rule
, rule_buf
[rule_pos
]);
19377 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19378 SET_P1 (rule
, rule_buf
[rule_pos
]);
19381 case RULE_OP_MANGLE_OVERSTRIKE
:
19382 SET_NAME (rule
, rule_buf
[rule_pos
]);
19383 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19384 SET_P1 (rule
, rule_buf
[rule_pos
]);
19387 case RULE_OP_MANGLE_TRUNCATE_AT
:
19388 SET_NAME (rule
, rule_buf
[rule_pos
]);
19389 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19392 case RULE_OP_MANGLE_REPLACE
:
19393 SET_NAME (rule
, rule_buf
[rule_pos
]);
19394 SET_P0 (rule
, rule_buf
[rule_pos
]);
19395 SET_P1 (rule
, rule_buf
[rule_pos
]);
19398 case RULE_OP_MANGLE_PURGECHAR
:
19402 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19406 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19407 SET_NAME (rule
, rule_buf
[rule_pos
]);
19408 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19411 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19412 SET_NAME (rule
, rule_buf
[rule_pos
]);
19413 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19416 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19417 SET_NAME (rule
, rule_buf
[rule_pos
]);
19420 case RULE_OP_MANGLE_SWITCH_FIRST
:
19421 SET_NAME (rule
, rule_buf
[rule_pos
]);
19424 case RULE_OP_MANGLE_SWITCH_LAST
:
19425 SET_NAME (rule
, rule_buf
[rule_pos
]);
19428 case RULE_OP_MANGLE_SWITCH_AT
:
19429 SET_NAME (rule
, rule_buf
[rule_pos
]);
19430 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19431 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19434 case RULE_OP_MANGLE_CHR_SHIFTL
:
19435 SET_NAME (rule
, rule_buf
[rule_pos
]);
19436 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19439 case RULE_OP_MANGLE_CHR_SHIFTR
:
19440 SET_NAME (rule
, rule_buf
[rule_pos
]);
19441 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19444 case RULE_OP_MANGLE_CHR_INCR
:
19445 SET_NAME (rule
, rule_buf
[rule_pos
]);
19446 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19449 case RULE_OP_MANGLE_CHR_DECR
:
19450 SET_NAME (rule
, rule_buf
[rule_pos
]);
19451 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19454 case RULE_OP_MANGLE_REPLACE_NP1
:
19455 SET_NAME (rule
, rule_buf
[rule_pos
]);
19456 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19459 case RULE_OP_MANGLE_REPLACE_NM1
:
19460 SET_NAME (rule
, rule_buf
[rule_pos
]);
19461 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19464 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19465 SET_NAME (rule
, rule_buf
[rule_pos
]);
19466 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19469 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19470 SET_NAME (rule
, rule_buf
[rule_pos
]);
19471 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19474 case RULE_OP_MANGLE_TITLE
:
19475 SET_NAME (rule
, rule_buf
[rule_pos
]);
19484 if (rule_pos
< rule_len
) return (-1);
19489 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19493 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19497 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19501 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19505 case RULE_OP_MANGLE_NOOP
:
19506 rule_buf
[rule_pos
] = rule_cmd
;
19509 case RULE_OP_MANGLE_LREST
:
19510 rule_buf
[rule_pos
] = rule_cmd
;
19513 case RULE_OP_MANGLE_UREST
:
19514 rule_buf
[rule_pos
] = rule_cmd
;
19517 case RULE_OP_MANGLE_LREST_UFIRST
:
19518 rule_buf
[rule_pos
] = rule_cmd
;
19521 case RULE_OP_MANGLE_UREST_LFIRST
:
19522 rule_buf
[rule_pos
] = rule_cmd
;
19525 case RULE_OP_MANGLE_TREST
:
19526 rule_buf
[rule_pos
] = rule_cmd
;
19529 case RULE_OP_MANGLE_TOGGLE_AT
:
19530 rule_buf
[rule_pos
] = rule_cmd
;
19531 GET_P0_CONV (rule
);
19534 case RULE_OP_MANGLE_REVERSE
:
19535 rule_buf
[rule_pos
] = rule_cmd
;
19538 case RULE_OP_MANGLE_DUPEWORD
:
19539 rule_buf
[rule_pos
] = rule_cmd
;
19542 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19543 rule_buf
[rule_pos
] = rule_cmd
;
19544 GET_P0_CONV (rule
);
19547 case RULE_OP_MANGLE_REFLECT
:
19548 rule_buf
[rule_pos
] = rule_cmd
;
19551 case RULE_OP_MANGLE_ROTATE_LEFT
:
19552 rule_buf
[rule_pos
] = rule_cmd
;
19555 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19556 rule_buf
[rule_pos
] = rule_cmd
;
19559 case RULE_OP_MANGLE_APPEND
:
19560 rule_buf
[rule_pos
] = rule_cmd
;
19564 case RULE_OP_MANGLE_PREPEND
:
19565 rule_buf
[rule_pos
] = rule_cmd
;
19569 case RULE_OP_MANGLE_DELETE_FIRST
:
19570 rule_buf
[rule_pos
] = rule_cmd
;
19573 case RULE_OP_MANGLE_DELETE_LAST
:
19574 rule_buf
[rule_pos
] = rule_cmd
;
19577 case RULE_OP_MANGLE_DELETE_AT
:
19578 rule_buf
[rule_pos
] = rule_cmd
;
19579 GET_P0_CONV (rule
);
19582 case RULE_OP_MANGLE_EXTRACT
:
19583 rule_buf
[rule_pos
] = rule_cmd
;
19584 GET_P0_CONV (rule
);
19585 GET_P1_CONV (rule
);
19588 case RULE_OP_MANGLE_OMIT
:
19589 rule_buf
[rule_pos
] = rule_cmd
;
19590 GET_P0_CONV (rule
);
19591 GET_P1_CONV (rule
);
19594 case RULE_OP_MANGLE_INSERT
:
19595 rule_buf
[rule_pos
] = rule_cmd
;
19596 GET_P0_CONV (rule
);
19600 case RULE_OP_MANGLE_OVERSTRIKE
:
19601 rule_buf
[rule_pos
] = rule_cmd
;
19602 GET_P0_CONV (rule
);
19606 case RULE_OP_MANGLE_TRUNCATE_AT
:
19607 rule_buf
[rule_pos
] = rule_cmd
;
19608 GET_P0_CONV (rule
);
19611 case RULE_OP_MANGLE_REPLACE
:
19612 rule_buf
[rule_pos
] = rule_cmd
;
19617 case RULE_OP_MANGLE_PURGECHAR
:
19621 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19625 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19626 rule_buf
[rule_pos
] = rule_cmd
;
19627 GET_P0_CONV (rule
);
19630 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19631 rule_buf
[rule_pos
] = rule_cmd
;
19632 GET_P0_CONV (rule
);
19635 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19636 rule_buf
[rule_pos
] = rule_cmd
;
19639 case RULE_OP_MANGLE_SWITCH_FIRST
:
19640 rule_buf
[rule_pos
] = rule_cmd
;
19643 case RULE_OP_MANGLE_SWITCH_LAST
:
19644 rule_buf
[rule_pos
] = rule_cmd
;
19647 case RULE_OP_MANGLE_SWITCH_AT
:
19648 rule_buf
[rule_pos
] = rule_cmd
;
19649 GET_P0_CONV (rule
);
19650 GET_P1_CONV (rule
);
19653 case RULE_OP_MANGLE_CHR_SHIFTL
:
19654 rule_buf
[rule_pos
] = rule_cmd
;
19655 GET_P0_CONV (rule
);
19658 case RULE_OP_MANGLE_CHR_SHIFTR
:
19659 rule_buf
[rule_pos
] = rule_cmd
;
19660 GET_P0_CONV (rule
);
19663 case RULE_OP_MANGLE_CHR_INCR
:
19664 rule_buf
[rule_pos
] = rule_cmd
;
19665 GET_P0_CONV (rule
);
19668 case RULE_OP_MANGLE_CHR_DECR
:
19669 rule_buf
[rule_pos
] = rule_cmd
;
19670 GET_P0_CONV (rule
);
19673 case RULE_OP_MANGLE_REPLACE_NP1
:
19674 rule_buf
[rule_pos
] = rule_cmd
;
19675 GET_P0_CONV (rule
);
19678 case RULE_OP_MANGLE_REPLACE_NM1
:
19679 rule_buf
[rule_pos
] = rule_cmd
;
19680 GET_P0_CONV (rule
);
19683 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19684 rule_buf
[rule_pos
] = rule_cmd
;
19685 GET_P0_CONV (rule
);
19688 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19689 rule_buf
[rule_pos
] = rule_cmd
;
19690 GET_P0_CONV (rule
);
19693 case RULE_OP_MANGLE_TITLE
:
19694 rule_buf
[rule_pos
] = rule_cmd
;
19698 return rule_pos
- 1;
19716 * CPU rules : this is from hashcat sources, cpu based rules
19719 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19720 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19722 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19723 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19724 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19726 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19727 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19728 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19730 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19734 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19739 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19743 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19748 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19752 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19757 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19762 for (l
= 0; l
< arr_len
; l
++)
19764 r
= arr_len
- 1 - l
;
19768 MANGLE_SWITCH (arr
, l
, r
);
19774 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19776 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19778 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19780 return (arr_len
* 2);
19783 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19785 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19787 int orig_len
= arr_len
;
19791 for (i
= 0; i
< times
; i
++)
19793 memcpy (&arr
[arr_len
], arr
, orig_len
);
19795 arr_len
+= orig_len
;
19801 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19803 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19805 mangle_double (arr
, arr_len
);
19807 mangle_reverse (arr
+ arr_len
, arr_len
);
19809 return (arr_len
* 2);
19812 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19817 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19819 MANGLE_SWITCH (arr
, l
, r
);
19825 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19830 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19832 MANGLE_SWITCH (arr
, l
, r
);
19838 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19840 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19844 return (arr_len
+ 1);
19847 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19849 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19853 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19855 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19860 return (arr_len
+ 1);
19863 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19865 if (upos
>= arr_len
) return (arr_len
);
19869 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19871 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19874 return (arr_len
- 1);
19877 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19879 if (upos
>= arr_len
) return (arr_len
);
19881 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19885 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19887 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19893 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19895 if (upos
>= arr_len
) return (arr_len
);
19897 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19901 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19903 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19906 return (arr_len
- ulen
);
19909 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19911 if (upos
>= arr_len
) return (arr_len
);
19913 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19917 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19919 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19924 return (arr_len
+ 1);
19927 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
)
19929 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19931 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19933 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19935 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19937 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19939 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19941 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19943 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19945 return (arr_len
+ arr2_cpy
);
19948 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19950 if (upos
>= arr_len
) return (arr_len
);
19957 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19959 if (upos
>= arr_len
) return (arr_len
);
19961 memset (arr
+ upos
, 0, arr_len
- upos
);
19966 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19970 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19972 if (arr
[arr_pos
] != oldc
) continue;
19974 arr
[arr_pos
] = newc
;
19980 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19986 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19988 if (arr
[arr_pos
] == c
) continue;
19990 arr
[ret_len
] = arr
[arr_pos
];
19998 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20000 if (ulen
> arr_len
) return (arr_len
);
20002 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20004 char cs
[100] = { 0 };
20006 memcpy (cs
, arr
, ulen
);
20010 for (i
= 0; i
< ulen
; i
++)
20014 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20020 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20022 if (ulen
> arr_len
) return (arr_len
);
20024 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20026 int upos
= arr_len
- ulen
;
20030 for (i
= 0; i
< ulen
; i
++)
20032 char c
= arr
[upos
+ i
];
20034 arr_len
= mangle_append (arr
, arr_len
, c
);
20040 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20042 if ( arr_len
== 0) return (arr_len
);
20043 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20045 char c
= arr
[upos
];
20049 for (i
= 0; i
< ulen
; i
++)
20051 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20057 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20059 if ( arr_len
== 0) return (arr_len
);
20060 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20064 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20066 int new_pos
= arr_pos
* 2;
20068 arr
[new_pos
] = arr
[arr_pos
];
20070 arr
[new_pos
+ 1] = arr
[arr_pos
];
20073 return (arr_len
* 2);
20076 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20078 if (upos
>= arr_len
) return (arr_len
);
20079 if (upos2
>= arr_len
) return (arr_len
);
20081 MANGLE_SWITCH (arr
, upos
, upos2
);
20086 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20088 MANGLE_SWITCH (arr
, upos
, upos2
);
20093 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20095 if (upos
>= arr_len
) return (arr_len
);
20102 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20104 if (upos
>= arr_len
) return (arr_len
);
20111 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20113 if (upos
>= arr_len
) return (arr_len
);
20120 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20122 if (upos
>= arr_len
) return (arr_len
);
20129 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20131 int upper_next
= 1;
20135 for (pos
= 0; pos
< arr_len
; pos
++)
20137 if (arr
[pos
] == ' ')
20148 MANGLE_UPPER_AT (arr
, pos
);
20152 MANGLE_LOWER_AT (arr
, pos
);
20159 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20161 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20167 for (j
= 0; j
< rp_gen_num
; j
++)
20174 switch ((char) get_random_num (0, 9))
20177 r
= get_random_num (0, sizeof (grp_op_nop
));
20178 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20182 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20183 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20184 p1
= get_random_num (0, sizeof (grp_pos
));
20185 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20189 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20190 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20191 p1
= get_random_num (1, 6);
20192 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20196 r
= get_random_num (0, sizeof (grp_op_chr
));
20197 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20198 p1
= get_random_num (0x20, 0x7e);
20199 rule_buf
[rule_pos
++] = (char) p1
;
20203 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20204 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20205 p1
= get_random_num (0x20, 0x7e);
20206 rule_buf
[rule_pos
++] = (char) p1
;
20207 p2
= get_random_num (0x20, 0x7e);
20209 p2
= get_random_num (0x20, 0x7e);
20210 rule_buf
[rule_pos
++] = (char) p2
;
20214 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20215 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20216 p1
= get_random_num (0, sizeof (grp_pos
));
20217 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20218 p2
= get_random_num (0x20, 0x7e);
20219 rule_buf
[rule_pos
++] = (char) p2
;
20223 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20224 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20225 p1
= get_random_num (0, sizeof (grp_pos
));
20226 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20227 p2
= get_random_num (0, sizeof (grp_pos
));
20229 p2
= get_random_num (0, sizeof (grp_pos
));
20230 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20234 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20235 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20236 p1
= get_random_num (0, sizeof (grp_pos
));
20237 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20238 p2
= get_random_num (1, sizeof (grp_pos
));
20240 p2
= get_random_num (1, sizeof (grp_pos
));
20241 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20245 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20246 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20247 p1
= get_random_num (0, sizeof (grp_pos
));
20248 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20249 p2
= get_random_num (1, sizeof (grp_pos
));
20250 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20251 p3
= get_random_num (0, sizeof (grp_pos
));
20252 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20260 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20262 char mem
[BLOCK_SIZE
] = { 0 };
20264 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20266 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20268 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20270 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20272 int out_len
= in_len
;
20273 int mem_len
= in_len
;
20275 memcpy (out
, in
, out_len
);
20279 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20284 switch (rule
[rule_pos
])
20289 case RULE_OP_MANGLE_NOOP
:
20292 case RULE_OP_MANGLE_LREST
:
20293 out_len
= mangle_lrest (out
, out_len
);
20296 case RULE_OP_MANGLE_UREST
:
20297 out_len
= mangle_urest (out
, out_len
);
20300 case RULE_OP_MANGLE_LREST_UFIRST
:
20301 out_len
= mangle_lrest (out
, out_len
);
20302 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20305 case RULE_OP_MANGLE_UREST_LFIRST
:
20306 out_len
= mangle_urest (out
, out_len
);
20307 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20310 case RULE_OP_MANGLE_TREST
:
20311 out_len
= mangle_trest (out
, out_len
);
20314 case RULE_OP_MANGLE_TOGGLE_AT
:
20315 NEXT_RULEPOS (rule_pos
);
20316 NEXT_RPTOI (rule
, rule_pos
, upos
);
20317 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20320 case RULE_OP_MANGLE_REVERSE
:
20321 out_len
= mangle_reverse (out
, out_len
);
20324 case RULE_OP_MANGLE_DUPEWORD
:
20325 out_len
= mangle_double (out
, out_len
);
20328 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20329 NEXT_RULEPOS (rule_pos
);
20330 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20331 out_len
= mangle_double_times (out
, out_len
, ulen
);
20334 case RULE_OP_MANGLE_REFLECT
:
20335 out_len
= mangle_reflect (out
, out_len
);
20338 case RULE_OP_MANGLE_ROTATE_LEFT
:
20339 mangle_rotate_left (out
, out_len
);
20342 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20343 mangle_rotate_right (out
, out_len
);
20346 case RULE_OP_MANGLE_APPEND
:
20347 NEXT_RULEPOS (rule_pos
);
20348 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20351 case RULE_OP_MANGLE_PREPEND
:
20352 NEXT_RULEPOS (rule_pos
);
20353 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20356 case RULE_OP_MANGLE_DELETE_FIRST
:
20357 out_len
= mangle_delete_at (out
, out_len
, 0);
20360 case RULE_OP_MANGLE_DELETE_LAST
:
20361 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20364 case RULE_OP_MANGLE_DELETE_AT
:
20365 NEXT_RULEPOS (rule_pos
);
20366 NEXT_RPTOI (rule
, rule_pos
, upos
);
20367 out_len
= mangle_delete_at (out
, out_len
, upos
);
20370 case RULE_OP_MANGLE_EXTRACT
:
20371 NEXT_RULEPOS (rule_pos
);
20372 NEXT_RPTOI (rule
, rule_pos
, upos
);
20373 NEXT_RULEPOS (rule_pos
);
20374 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20375 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20378 case RULE_OP_MANGLE_OMIT
:
20379 NEXT_RULEPOS (rule_pos
);
20380 NEXT_RPTOI (rule
, rule_pos
, upos
);
20381 NEXT_RULEPOS (rule_pos
);
20382 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20383 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20386 case RULE_OP_MANGLE_INSERT
:
20387 NEXT_RULEPOS (rule_pos
);
20388 NEXT_RPTOI (rule
, rule_pos
, upos
);
20389 NEXT_RULEPOS (rule_pos
);
20390 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20393 case RULE_OP_MANGLE_OVERSTRIKE
:
20394 NEXT_RULEPOS (rule_pos
);
20395 NEXT_RPTOI (rule
, rule_pos
, upos
);
20396 NEXT_RULEPOS (rule_pos
);
20397 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20400 case RULE_OP_MANGLE_TRUNCATE_AT
:
20401 NEXT_RULEPOS (rule_pos
);
20402 NEXT_RPTOI (rule
, rule_pos
, upos
);
20403 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20406 case RULE_OP_MANGLE_REPLACE
:
20407 NEXT_RULEPOS (rule_pos
);
20408 NEXT_RULEPOS (rule_pos
);
20409 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20412 case RULE_OP_MANGLE_PURGECHAR
:
20413 NEXT_RULEPOS (rule_pos
);
20414 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20417 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20421 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20422 NEXT_RULEPOS (rule_pos
);
20423 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20424 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20427 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20428 NEXT_RULEPOS (rule_pos
);
20429 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20430 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20433 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20434 out_len
= mangle_dupechar (out
, out_len
);
20437 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20438 NEXT_RULEPOS (rule_pos
);
20439 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20440 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20443 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20444 NEXT_RULEPOS (rule_pos
);
20445 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20446 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20449 case RULE_OP_MANGLE_SWITCH_FIRST
:
20450 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20453 case RULE_OP_MANGLE_SWITCH_LAST
:
20454 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20457 case RULE_OP_MANGLE_SWITCH_AT
:
20458 NEXT_RULEPOS (rule_pos
);
20459 NEXT_RPTOI (rule
, rule_pos
, upos
);
20460 NEXT_RULEPOS (rule_pos
);
20461 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20462 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20465 case RULE_OP_MANGLE_CHR_SHIFTL
:
20466 NEXT_RULEPOS (rule_pos
);
20467 NEXT_RPTOI (rule
, rule_pos
, upos
);
20468 mangle_chr_shiftl (out
, out_len
, upos
);
20471 case RULE_OP_MANGLE_CHR_SHIFTR
:
20472 NEXT_RULEPOS (rule_pos
);
20473 NEXT_RPTOI (rule
, rule_pos
, upos
);
20474 mangle_chr_shiftr (out
, out_len
, upos
);
20477 case RULE_OP_MANGLE_CHR_INCR
:
20478 NEXT_RULEPOS (rule_pos
);
20479 NEXT_RPTOI (rule
, rule_pos
, upos
);
20480 mangle_chr_incr (out
, out_len
, upos
);
20483 case RULE_OP_MANGLE_CHR_DECR
:
20484 NEXT_RULEPOS (rule_pos
);
20485 NEXT_RPTOI (rule
, rule_pos
, upos
);
20486 mangle_chr_decr (out
, out_len
, upos
);
20489 case RULE_OP_MANGLE_REPLACE_NP1
:
20490 NEXT_RULEPOS (rule_pos
);
20491 NEXT_RPTOI (rule
, rule_pos
, upos
);
20492 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20495 case RULE_OP_MANGLE_REPLACE_NM1
:
20496 NEXT_RULEPOS (rule_pos
);
20497 NEXT_RPTOI (rule
, rule_pos
, upos
);
20498 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20501 case RULE_OP_MANGLE_TITLE
:
20502 out_len
= mangle_title (out
, out_len
);
20505 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20506 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20507 NEXT_RULEPOS (rule_pos
);
20508 NEXT_RPTOI (rule
, rule_pos
, upos
);
20509 NEXT_RULEPOS (rule_pos
);
20510 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20511 NEXT_RULEPOS (rule_pos
);
20512 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20513 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20516 case RULE_OP_MANGLE_APPEND_MEMORY
:
20517 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20518 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20519 memcpy (out
+ out_len
, mem
, mem_len
);
20520 out_len
+= mem_len
;
20523 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20524 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20525 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20526 memcpy (mem
+ mem_len
, out
, out_len
);
20527 out_len
+= mem_len
;
20528 memcpy (out
, mem
, out_len
);
20531 case RULE_OP_MEMORIZE_WORD
:
20532 memcpy (mem
, out
, out_len
);
20536 case RULE_OP_REJECT_LESS
:
20537 NEXT_RULEPOS (rule_pos
);
20538 NEXT_RPTOI (rule
, rule_pos
, upos
);
20539 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20542 case RULE_OP_REJECT_GREATER
:
20543 NEXT_RULEPOS (rule_pos
);
20544 NEXT_RPTOI (rule
, rule_pos
, upos
);
20545 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20548 case RULE_OP_REJECT_CONTAIN
:
20549 NEXT_RULEPOS (rule_pos
);
20550 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20553 case RULE_OP_REJECT_NOT_CONTAIN
:
20554 NEXT_RULEPOS (rule_pos
);
20555 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20558 case RULE_OP_REJECT_EQUAL_FIRST
:
20559 NEXT_RULEPOS (rule_pos
);
20560 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20563 case RULE_OP_REJECT_EQUAL_LAST
:
20564 NEXT_RULEPOS (rule_pos
);
20565 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20568 case RULE_OP_REJECT_EQUAL_AT
:
20569 NEXT_RULEPOS (rule_pos
);
20570 NEXT_RPTOI (rule
, rule_pos
, upos
);
20571 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20572 NEXT_RULEPOS (rule_pos
);
20573 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20576 case RULE_OP_REJECT_CONTAINS
:
20577 NEXT_RULEPOS (rule_pos
);
20578 NEXT_RPTOI (rule
, rule_pos
, upos
);
20579 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20580 NEXT_RULEPOS (rule_pos
);
20581 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20582 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20585 case RULE_OP_REJECT_MEMORY
:
20586 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20590 return (RULE_RC_SYNTAX_ERROR
);
20595 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);