2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
19 #define GET_ACCEL(x) KERNEL_ACCEL_ ## x
20 #define GET_LOOPS(x) KERNEL_LOOPS_ ## x
26 u32
rotl32 (const u32 a
, const u32 n
)
28 return ((a
<< n
) | (a
>> (32 - n
)));
31 u32
rotr32 (const u32 a
, const u32 n
)
33 return ((a
>> n
) | (a
<< (32 - n
)));
36 u64
rotl64 (const u64 a
, const u64 n
)
38 return ((a
<< n
) | (a
>> (64 - n
)));
41 u64
rotr64 (const u64 a
, const u64 n
)
43 return ((a
>> n
) | (a
<< (64 - n
)));
46 u32
byte_swap_32 (const u32 n
)
48 return (n
& 0xff000000) >> 24
49 | (n
& 0x00ff0000) >> 8
50 | (n
& 0x0000ff00) << 8
51 | (n
& 0x000000ff) << 24;
54 u64
byte_swap_64 (const u64 n
)
56 return (n
& 0xff00000000000000ULL
) >> 56
57 | (n
& 0x00ff000000000000ULL
) >> 40
58 | (n
& 0x0000ff0000000000ULL
) >> 24
59 | (n
& 0x000000ff00000000ULL
) >> 8
60 | (n
& 0x00000000ff000000ULL
) << 8
61 | (n
& 0x0000000000ff0000ULL
) << 24
62 | (n
& 0x000000000000ff00ULL
) << 40
63 | (n
& 0x00000000000000ffULL
) << 56;
67 * ciphers for use on cpu
74 * hashes for use on cpu
78 #include "cpu-sha256.c"
86 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
92 for (int i
= 0; i
< last_len
; i
++)
100 char s
[4096] = { 0 };
102 int max_len
= (int) sizeof (s
);
104 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
106 if (len
> max_len
) len
= max_len
;
108 fwrite (s
, len
, 1, fp
);
115 void log_out_nn (FILE *fp
, const char *fmt
, ...)
117 if (SUPPRESS_OUTPUT
) return;
123 log_final (fp
, fmt
, ap
);
128 void log_info_nn (const char *fmt
, ...)
130 if (SUPPRESS_OUTPUT
) return;
136 log_final (stdout
, fmt
, ap
);
141 void log_error_nn (const char *fmt
, ...)
143 if (SUPPRESS_OUTPUT
) return;
149 log_final (stderr
, fmt
, ap
);
154 void log_out (FILE *fp
, const char *fmt
, ...)
156 if (SUPPRESS_OUTPUT
) return;
162 log_final (fp
, fmt
, ap
);
171 void log_info (const char *fmt
, ...)
173 if (SUPPRESS_OUTPUT
) return;
179 log_final (stdout
, fmt
, ap
);
183 fputc ('\n', stdout
);
188 void log_error (const char *fmt
, ...)
190 if (SUPPRESS_OUTPUT
) return;
192 fputc ('\n', stderr
);
193 fputc ('\n', stderr
);
199 log_final (stderr
, fmt
, ap
);
203 fputc ('\n', stderr
);
204 fputc ('\n', stderr
);
213 u8
int_to_base32 (const u8 c
)
215 static const u8 tbl
[0x20] =
217 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
218 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
224 u8
base32_to_int (const u8 c
)
226 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
227 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
232 u8
int_to_itoa32 (const u8 c
)
234 static const u8 tbl
[0x20] =
236 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
237 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
243 u8
itoa32_to_int (const u8 c
)
245 if ((c
>= '0') && (c
<= '9')) return c
- '0';
246 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
251 u8
int_to_itoa64 (const u8 c
)
253 static const u8 tbl
[0x40] =
255 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
256 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
257 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
258 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
264 u8
itoa64_to_int (const u8 c
)
266 static const u8 tbl
[0x100] =
268 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
269 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
270 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
271 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
272 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
273 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
274 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
275 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
276 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
277 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
278 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
279 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
280 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
281 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
282 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
283 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
289 u8
int_to_base64 (const u8 c
)
291 static const u8 tbl
[0x40] =
293 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
294 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
295 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
296 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
302 u8
base64_to_int (const u8 c
)
304 static const u8 tbl
[0x100] =
306 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
308 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
309 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
310 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
311 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
313 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
327 u8
int_to_bf64 (const u8 c
)
329 static const u8 tbl
[0x40] =
331 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
332 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
333 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
334 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
340 u8
bf64_to_int (const u8 c
)
342 static const u8 tbl
[0x100] =
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
346 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
347 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
348 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
349 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
350 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
351 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
365 u8
int_to_lotus64 (const u8 c
)
367 if (c
< 10) return '0' + c
;
368 else if (c
< 36) return 'A' + c
- 10;
369 else if (c
< 62) return 'a' + c
- 36;
370 else if (c
== 62) return '+';
371 else if (c
== 63) return '/';
376 u8
lotus64_to_int (const u8 c
)
378 if ((c
>= '0') && (c
<= '9')) return c
- '0';
379 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
380 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
381 else if (c
== '+') return 62;
382 else if (c
== '/') return 63;
388 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
390 const u8
*in_ptr
= in_buf
;
392 u8
*out_ptr
= out_buf
;
394 for (int i
= 0; i
< in_len
; i
+= 8)
396 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
397 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
398 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
399 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
400 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
401 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
402 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
403 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
405 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
406 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
407 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
408 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
409 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
415 for (int i
= 0; i
< in_len
; i
++)
417 if (in_buf
[i
] != '=') continue;
422 int out_len
= (in_len
* 5) / 8;
427 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
429 const u8
*in_ptr
= in_buf
;
431 u8
*out_ptr
= out_buf
;
433 for (int i
= 0; i
< in_len
; i
+= 5)
435 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
436 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
437 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
438 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
439 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
440 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
441 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
442 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
444 out_ptr
[0] = out_val0
& 0x7f;
445 out_ptr
[1] = out_val1
& 0x7f;
446 out_ptr
[2] = out_val2
& 0x7f;
447 out_ptr
[3] = out_val3
& 0x7f;
448 out_ptr
[4] = out_val4
& 0x7f;
449 out_ptr
[5] = out_val5
& 0x7f;
450 out_ptr
[6] = out_val6
& 0x7f;
451 out_ptr
[7] = out_val7
& 0x7f;
457 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
461 out_buf
[out_len
] = '=';
469 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
471 const u8
*in_ptr
= in_buf
;
473 u8
*out_ptr
= out_buf
;
475 for (int i
= 0; i
< in_len
; i
+= 4)
477 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
478 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
479 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
480 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
482 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
483 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
484 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
490 for (int i
= 0; i
< in_len
; i
++)
492 if (in_buf
[i
] != '=') continue;
497 int out_len
= (in_len
* 6) / 8;
502 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
504 const u8
*in_ptr
= in_buf
;
506 u8
*out_ptr
= out_buf
;
508 for (int i
= 0; i
< in_len
; i
+= 3)
510 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
511 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
512 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
513 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
515 out_ptr
[0] = out_val0
& 0x7f;
516 out_ptr
[1] = out_val1
& 0x7f;
517 out_ptr
[2] = out_val2
& 0x7f;
518 out_ptr
[3] = out_val3
& 0x7f;
524 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
528 out_buf
[out_len
] = '=';
536 int is_valid_hex_char (const u8 c
)
538 if ((c
>= '0') && (c
<= '9')) return 1;
539 if ((c
>= 'A') && (c
<= 'F')) return 1;
540 if ((c
>= 'a') && (c
<= 'f')) return 1;
545 u8
hex_convert (const u8 c
)
547 return (c
& 15) + (c
>> 6) * 9;
550 u8
hex_to_u8 (const u8 hex
[2])
554 v
|= (hex_convert (hex
[1]) << 0);
555 v
|= (hex_convert (hex
[0]) << 4);
560 u32
hex_to_u32 (const u8 hex
[8])
564 v
|= ((u32
) hex_convert (hex
[7])) << 0;
565 v
|= ((u32
) hex_convert (hex
[6])) << 4;
566 v
|= ((u32
) hex_convert (hex
[5])) << 8;
567 v
|= ((u32
) hex_convert (hex
[4])) << 12;
568 v
|= ((u32
) hex_convert (hex
[3])) << 16;
569 v
|= ((u32
) hex_convert (hex
[2])) << 20;
570 v
|= ((u32
) hex_convert (hex
[1])) << 24;
571 v
|= ((u32
) hex_convert (hex
[0])) << 28;
576 u64
hex_to_u64 (const u8 hex
[16])
580 v
|= ((u64
) hex_convert (hex
[15]) << 0);
581 v
|= ((u64
) hex_convert (hex
[14]) << 4);
582 v
|= ((u64
) hex_convert (hex
[13]) << 8);
583 v
|= ((u64
) hex_convert (hex
[12]) << 12);
584 v
|= ((u64
) hex_convert (hex
[11]) << 16);
585 v
|= ((u64
) hex_convert (hex
[10]) << 20);
586 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
587 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
588 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
589 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
590 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
591 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
592 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
593 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
594 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
595 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
600 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
602 hex
[0] = v
>> 28 & 15;
603 hex
[1] = v
>> 24 & 15;
604 hex
[2] = v
>> 20 & 15;
605 hex
[3] = v
>> 16 & 15;
606 hex
[4] = v
>> 12 & 15;
607 hex
[5] = v
>> 8 & 15;
608 hex
[6] = v
>> 4 & 15;
609 hex
[7] = v
>> 0 & 15;
613 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
614 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
615 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
616 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
617 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
618 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
619 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
620 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
627 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
631 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
640 for (int i
= 0; i
< 16; i
+= 4)
650 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
657 out
[i
+ 0] = _out
[0];
658 out
[i
+ 1] = _out
[1];
659 out
[i
+ 2] = _out
[2];
660 out
[i
+ 3] = _out
[3];
669 static void juniper_decrypt_hash (char *in
, char *out
)
673 u8 base64_buf
[100] = { 0 };
675 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
679 u32 juniper_iv
[4] = { 0 };
681 memcpy (juniper_iv
, base64_buf
, 12);
683 memcpy (out
, juniper_iv
, 12);
687 u32 juniper_key
[4] = { 0 };
689 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
690 juniper_key
[1] = byte_swap_32 (0x8df91059);
691 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
692 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
696 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
697 u32
*out_ptr
= (u32
*) (out
+ 12);
699 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
702 void phpass_decode (u8 digest
[16], u8 buf
[22])
706 l
= itoa64_to_int (buf
[ 0]) << 0;
707 l
|= itoa64_to_int (buf
[ 1]) << 6;
708 l
|= itoa64_to_int (buf
[ 2]) << 12;
709 l
|= itoa64_to_int (buf
[ 3]) << 18;
711 digest
[ 0] = (l
>> 0) & 0xff;
712 digest
[ 1] = (l
>> 8) & 0xff;
713 digest
[ 2] = (l
>> 16) & 0xff;
715 l
= itoa64_to_int (buf
[ 4]) << 0;
716 l
|= itoa64_to_int (buf
[ 5]) << 6;
717 l
|= itoa64_to_int (buf
[ 6]) << 12;
718 l
|= itoa64_to_int (buf
[ 7]) << 18;
720 digest
[ 3] = (l
>> 0) & 0xff;
721 digest
[ 4] = (l
>> 8) & 0xff;
722 digest
[ 5] = (l
>> 16) & 0xff;
724 l
= itoa64_to_int (buf
[ 8]) << 0;
725 l
|= itoa64_to_int (buf
[ 9]) << 6;
726 l
|= itoa64_to_int (buf
[10]) << 12;
727 l
|= itoa64_to_int (buf
[11]) << 18;
729 digest
[ 6] = (l
>> 0) & 0xff;
730 digest
[ 7] = (l
>> 8) & 0xff;
731 digest
[ 8] = (l
>> 16) & 0xff;
733 l
= itoa64_to_int (buf
[12]) << 0;
734 l
|= itoa64_to_int (buf
[13]) << 6;
735 l
|= itoa64_to_int (buf
[14]) << 12;
736 l
|= itoa64_to_int (buf
[15]) << 18;
738 digest
[ 9] = (l
>> 0) & 0xff;
739 digest
[10] = (l
>> 8) & 0xff;
740 digest
[11] = (l
>> 16) & 0xff;
742 l
= itoa64_to_int (buf
[16]) << 0;
743 l
|= itoa64_to_int (buf
[17]) << 6;
744 l
|= itoa64_to_int (buf
[18]) << 12;
745 l
|= itoa64_to_int (buf
[19]) << 18;
747 digest
[12] = (l
>> 0) & 0xff;
748 digest
[13] = (l
>> 8) & 0xff;
749 digest
[14] = (l
>> 16) & 0xff;
751 l
= itoa64_to_int (buf
[20]) << 0;
752 l
|= itoa64_to_int (buf
[21]) << 6;
754 digest
[15] = (l
>> 0) & 0xff;
757 void phpass_encode (u8 digest
[16], u8 buf
[22])
761 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
763 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
766 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
768 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
770 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
773 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
775 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
777 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[11] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
784 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[15] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
791 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[19] = int_to_itoa64 (l
& 0x3f);
796 l
= (digest
[15] << 0);
798 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[21] = int_to_itoa64 (l
& 0x3f);
802 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
806 l
= itoa64_to_int (buf
[ 0]) << 0;
807 l
|= itoa64_to_int (buf
[ 1]) << 6;
808 l
|= itoa64_to_int (buf
[ 2]) << 12;
809 l
|= itoa64_to_int (buf
[ 3]) << 18;
811 digest
[ 0] = (l
>> 16) & 0xff;
812 digest
[ 6] = (l
>> 8) & 0xff;
813 digest
[12] = (l
>> 0) & 0xff;
815 l
= itoa64_to_int (buf
[ 4]) << 0;
816 l
|= itoa64_to_int (buf
[ 5]) << 6;
817 l
|= itoa64_to_int (buf
[ 6]) << 12;
818 l
|= itoa64_to_int (buf
[ 7]) << 18;
820 digest
[ 1] = (l
>> 16) & 0xff;
821 digest
[ 7] = (l
>> 8) & 0xff;
822 digest
[13] = (l
>> 0) & 0xff;
824 l
= itoa64_to_int (buf
[ 8]) << 0;
825 l
|= itoa64_to_int (buf
[ 9]) << 6;
826 l
|= itoa64_to_int (buf
[10]) << 12;
827 l
|= itoa64_to_int (buf
[11]) << 18;
829 digest
[ 2] = (l
>> 16) & 0xff;
830 digest
[ 8] = (l
>> 8) & 0xff;
831 digest
[14] = (l
>> 0) & 0xff;
833 l
= itoa64_to_int (buf
[12]) << 0;
834 l
|= itoa64_to_int (buf
[13]) << 6;
835 l
|= itoa64_to_int (buf
[14]) << 12;
836 l
|= itoa64_to_int (buf
[15]) << 18;
838 digest
[ 3] = (l
>> 16) & 0xff;
839 digest
[ 9] = (l
>> 8) & 0xff;
840 digest
[15] = (l
>> 0) & 0xff;
842 l
= itoa64_to_int (buf
[16]) << 0;
843 l
|= itoa64_to_int (buf
[17]) << 6;
844 l
|= itoa64_to_int (buf
[18]) << 12;
845 l
|= itoa64_to_int (buf
[19]) << 18;
847 digest
[ 4] = (l
>> 16) & 0xff;
848 digest
[10] = (l
>> 8) & 0xff;
849 digest
[ 5] = (l
>> 0) & 0xff;
851 l
= itoa64_to_int (buf
[20]) << 0;
852 l
|= itoa64_to_int (buf
[21]) << 6;
854 digest
[11] = (l
>> 0) & 0xff;
857 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
861 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
863 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
866 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
870 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
873 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
877 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
884 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
891 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 l
= (digest
[11] << 0);
898 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
902 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
906 l
= itoa64_to_int (buf
[ 0]) << 0;
907 l
|= itoa64_to_int (buf
[ 1]) << 6;
908 l
|= itoa64_to_int (buf
[ 2]) << 12;
909 l
|= itoa64_to_int (buf
[ 3]) << 18;
911 digest
[ 0] = (l
>> 16) & 0xff;
912 digest
[21] = (l
>> 8) & 0xff;
913 digest
[42] = (l
>> 0) & 0xff;
915 l
= itoa64_to_int (buf
[ 4]) << 0;
916 l
|= itoa64_to_int (buf
[ 5]) << 6;
917 l
|= itoa64_to_int (buf
[ 6]) << 12;
918 l
|= itoa64_to_int (buf
[ 7]) << 18;
920 digest
[22] = (l
>> 16) & 0xff;
921 digest
[43] = (l
>> 8) & 0xff;
922 digest
[ 1] = (l
>> 0) & 0xff;
924 l
= itoa64_to_int (buf
[ 8]) << 0;
925 l
|= itoa64_to_int (buf
[ 9]) << 6;
926 l
|= itoa64_to_int (buf
[10]) << 12;
927 l
|= itoa64_to_int (buf
[11]) << 18;
929 digest
[44] = (l
>> 16) & 0xff;
930 digest
[ 2] = (l
>> 8) & 0xff;
931 digest
[23] = (l
>> 0) & 0xff;
933 l
= itoa64_to_int (buf
[12]) << 0;
934 l
|= itoa64_to_int (buf
[13]) << 6;
935 l
|= itoa64_to_int (buf
[14]) << 12;
936 l
|= itoa64_to_int (buf
[15]) << 18;
938 digest
[ 3] = (l
>> 16) & 0xff;
939 digest
[24] = (l
>> 8) & 0xff;
940 digest
[45] = (l
>> 0) & 0xff;
942 l
= itoa64_to_int (buf
[16]) << 0;
943 l
|= itoa64_to_int (buf
[17]) << 6;
944 l
|= itoa64_to_int (buf
[18]) << 12;
945 l
|= itoa64_to_int (buf
[19]) << 18;
947 digest
[25] = (l
>> 16) & 0xff;
948 digest
[46] = (l
>> 8) & 0xff;
949 digest
[ 4] = (l
>> 0) & 0xff;
951 l
= itoa64_to_int (buf
[20]) << 0;
952 l
|= itoa64_to_int (buf
[21]) << 6;
953 l
|= itoa64_to_int (buf
[22]) << 12;
954 l
|= itoa64_to_int (buf
[23]) << 18;
956 digest
[47] = (l
>> 16) & 0xff;
957 digest
[ 5] = (l
>> 8) & 0xff;
958 digest
[26] = (l
>> 0) & 0xff;
960 l
= itoa64_to_int (buf
[24]) << 0;
961 l
|= itoa64_to_int (buf
[25]) << 6;
962 l
|= itoa64_to_int (buf
[26]) << 12;
963 l
|= itoa64_to_int (buf
[27]) << 18;
965 digest
[ 6] = (l
>> 16) & 0xff;
966 digest
[27] = (l
>> 8) & 0xff;
967 digest
[48] = (l
>> 0) & 0xff;
969 l
= itoa64_to_int (buf
[28]) << 0;
970 l
|= itoa64_to_int (buf
[29]) << 6;
971 l
|= itoa64_to_int (buf
[30]) << 12;
972 l
|= itoa64_to_int (buf
[31]) << 18;
974 digest
[28] = (l
>> 16) & 0xff;
975 digest
[49] = (l
>> 8) & 0xff;
976 digest
[ 7] = (l
>> 0) & 0xff;
978 l
= itoa64_to_int (buf
[32]) << 0;
979 l
|= itoa64_to_int (buf
[33]) << 6;
980 l
|= itoa64_to_int (buf
[34]) << 12;
981 l
|= itoa64_to_int (buf
[35]) << 18;
983 digest
[50] = (l
>> 16) & 0xff;
984 digest
[ 8] = (l
>> 8) & 0xff;
985 digest
[29] = (l
>> 0) & 0xff;
987 l
= itoa64_to_int (buf
[36]) << 0;
988 l
|= itoa64_to_int (buf
[37]) << 6;
989 l
|= itoa64_to_int (buf
[38]) << 12;
990 l
|= itoa64_to_int (buf
[39]) << 18;
992 digest
[ 9] = (l
>> 16) & 0xff;
993 digest
[30] = (l
>> 8) & 0xff;
994 digest
[51] = (l
>> 0) & 0xff;
996 l
= itoa64_to_int (buf
[40]) << 0;
997 l
|= itoa64_to_int (buf
[41]) << 6;
998 l
|= itoa64_to_int (buf
[42]) << 12;
999 l
|= itoa64_to_int (buf
[43]) << 18;
1001 digest
[31] = (l
>> 16) & 0xff;
1002 digest
[52] = (l
>> 8) & 0xff;
1003 digest
[10] = (l
>> 0) & 0xff;
1005 l
= itoa64_to_int (buf
[44]) << 0;
1006 l
|= itoa64_to_int (buf
[45]) << 6;
1007 l
|= itoa64_to_int (buf
[46]) << 12;
1008 l
|= itoa64_to_int (buf
[47]) << 18;
1010 digest
[53] = (l
>> 16) & 0xff;
1011 digest
[11] = (l
>> 8) & 0xff;
1012 digest
[32] = (l
>> 0) & 0xff;
1014 l
= itoa64_to_int (buf
[48]) << 0;
1015 l
|= itoa64_to_int (buf
[49]) << 6;
1016 l
|= itoa64_to_int (buf
[50]) << 12;
1017 l
|= itoa64_to_int (buf
[51]) << 18;
1019 digest
[12] = (l
>> 16) & 0xff;
1020 digest
[33] = (l
>> 8) & 0xff;
1021 digest
[54] = (l
>> 0) & 0xff;
1023 l
= itoa64_to_int (buf
[52]) << 0;
1024 l
|= itoa64_to_int (buf
[53]) << 6;
1025 l
|= itoa64_to_int (buf
[54]) << 12;
1026 l
|= itoa64_to_int (buf
[55]) << 18;
1028 digest
[34] = (l
>> 16) & 0xff;
1029 digest
[55] = (l
>> 8) & 0xff;
1030 digest
[13] = (l
>> 0) & 0xff;
1032 l
= itoa64_to_int (buf
[56]) << 0;
1033 l
|= itoa64_to_int (buf
[57]) << 6;
1034 l
|= itoa64_to_int (buf
[58]) << 12;
1035 l
|= itoa64_to_int (buf
[59]) << 18;
1037 digest
[56] = (l
>> 16) & 0xff;
1038 digest
[14] = (l
>> 8) & 0xff;
1039 digest
[35] = (l
>> 0) & 0xff;
1041 l
= itoa64_to_int (buf
[60]) << 0;
1042 l
|= itoa64_to_int (buf
[61]) << 6;
1043 l
|= itoa64_to_int (buf
[62]) << 12;
1044 l
|= itoa64_to_int (buf
[63]) << 18;
1046 digest
[15] = (l
>> 16) & 0xff;
1047 digest
[36] = (l
>> 8) & 0xff;
1048 digest
[57] = (l
>> 0) & 0xff;
1050 l
= itoa64_to_int (buf
[64]) << 0;
1051 l
|= itoa64_to_int (buf
[65]) << 6;
1052 l
|= itoa64_to_int (buf
[66]) << 12;
1053 l
|= itoa64_to_int (buf
[67]) << 18;
1055 digest
[37] = (l
>> 16) & 0xff;
1056 digest
[58] = (l
>> 8) & 0xff;
1057 digest
[16] = (l
>> 0) & 0xff;
1059 l
= itoa64_to_int (buf
[68]) << 0;
1060 l
|= itoa64_to_int (buf
[69]) << 6;
1061 l
|= itoa64_to_int (buf
[70]) << 12;
1062 l
|= itoa64_to_int (buf
[71]) << 18;
1064 digest
[59] = (l
>> 16) & 0xff;
1065 digest
[17] = (l
>> 8) & 0xff;
1066 digest
[38] = (l
>> 0) & 0xff;
1068 l
= itoa64_to_int (buf
[72]) << 0;
1069 l
|= itoa64_to_int (buf
[73]) << 6;
1070 l
|= itoa64_to_int (buf
[74]) << 12;
1071 l
|= itoa64_to_int (buf
[75]) << 18;
1073 digest
[18] = (l
>> 16) & 0xff;
1074 digest
[39] = (l
>> 8) & 0xff;
1075 digest
[60] = (l
>> 0) & 0xff;
1077 l
= itoa64_to_int (buf
[76]) << 0;
1078 l
|= itoa64_to_int (buf
[77]) << 6;
1079 l
|= itoa64_to_int (buf
[78]) << 12;
1080 l
|= itoa64_to_int (buf
[79]) << 18;
1082 digest
[40] = (l
>> 16) & 0xff;
1083 digest
[61] = (l
>> 8) & 0xff;
1084 digest
[19] = (l
>> 0) & 0xff;
1086 l
= itoa64_to_int (buf
[80]) << 0;
1087 l
|= itoa64_to_int (buf
[81]) << 6;
1088 l
|= itoa64_to_int (buf
[82]) << 12;
1089 l
|= itoa64_to_int (buf
[83]) << 18;
1091 digest
[62] = (l
>> 16) & 0xff;
1092 digest
[20] = (l
>> 8) & 0xff;
1093 digest
[41] = (l
>> 0) & 0xff;
1095 l
= itoa64_to_int (buf
[84]) << 0;
1096 l
|= itoa64_to_int (buf
[85]) << 6;
1098 digest
[63] = (l
>> 0) & 0xff;
1101 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1105 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1107 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1110 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1114 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1117 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1121 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1128 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1135 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1142 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1149 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1156 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1163 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1170 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1177 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1184 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1191 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1198 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1205 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1212 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1219 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1226 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1233 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1240 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1247 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 l
= 0 | 0 | (digest
[63] << 0);
1254 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1258 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1262 l
= itoa64_to_int (buf
[ 0]) << 0;
1263 l
|= itoa64_to_int (buf
[ 1]) << 6;
1264 l
|= itoa64_to_int (buf
[ 2]) << 12;
1265 l
|= itoa64_to_int (buf
[ 3]) << 18;
1267 digest
[ 2] = (l
>> 0) & 0xff;
1268 digest
[ 1] = (l
>> 8) & 0xff;
1269 digest
[ 0] = (l
>> 16) & 0xff;
1271 l
= itoa64_to_int (buf
[ 4]) << 0;
1272 l
|= itoa64_to_int (buf
[ 5]) << 6;
1273 l
|= itoa64_to_int (buf
[ 6]) << 12;
1274 l
|= itoa64_to_int (buf
[ 7]) << 18;
1276 digest
[ 5] = (l
>> 0) & 0xff;
1277 digest
[ 4] = (l
>> 8) & 0xff;
1278 digest
[ 3] = (l
>> 16) & 0xff;
1280 l
= itoa64_to_int (buf
[ 8]) << 0;
1281 l
|= itoa64_to_int (buf
[ 9]) << 6;
1282 l
|= itoa64_to_int (buf
[10]) << 12;
1283 l
|= itoa64_to_int (buf
[11]) << 18;
1285 digest
[ 8] = (l
>> 0) & 0xff;
1286 digest
[ 7] = (l
>> 8) & 0xff;
1287 digest
[ 6] = (l
>> 16) & 0xff;
1289 l
= itoa64_to_int (buf
[12]) << 0;
1290 l
|= itoa64_to_int (buf
[13]) << 6;
1291 l
|= itoa64_to_int (buf
[14]) << 12;
1292 l
|= itoa64_to_int (buf
[15]) << 18;
1294 digest
[11] = (l
>> 0) & 0xff;
1295 digest
[10] = (l
>> 8) & 0xff;
1296 digest
[ 9] = (l
>> 16) & 0xff;
1298 l
= itoa64_to_int (buf
[16]) << 0;
1299 l
|= itoa64_to_int (buf
[17]) << 6;
1300 l
|= itoa64_to_int (buf
[18]) << 12;
1301 l
|= itoa64_to_int (buf
[19]) << 18;
1303 digest
[14] = (l
>> 0) & 0xff;
1304 digest
[13] = (l
>> 8) & 0xff;
1305 digest
[12] = (l
>> 16) & 0xff;
1307 l
= itoa64_to_int (buf
[20]) << 0;
1308 l
|= itoa64_to_int (buf
[21]) << 6;
1309 l
|= itoa64_to_int (buf
[22]) << 12;
1310 l
|= itoa64_to_int (buf
[23]) << 18;
1312 digest
[17] = (l
>> 0) & 0xff;
1313 digest
[16] = (l
>> 8) & 0xff;
1314 digest
[15] = (l
>> 16) & 0xff;
1316 l
= itoa64_to_int (buf
[24]) << 0;
1317 l
|= itoa64_to_int (buf
[25]) << 6;
1318 l
|= itoa64_to_int (buf
[26]) << 12;
1320 digest
[19] = (l
>> 8) & 0xff;
1321 digest
[18] = (l
>> 16) & 0xff;
1324 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1328 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1330 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1333 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1335 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1337 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1340 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1342 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1344 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[11] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1351 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[15] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1358 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[19] = int_to_itoa64 (l
& 0x3f);
1363 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1365 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[23] = int_to_itoa64 (l
& 0x3f);
1370 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1372 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1374 buf
[26] = int_to_itoa64 (l
& 0x3f);
1377 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1381 l
= itoa64_to_int (buf
[ 0]) << 0;
1382 l
|= itoa64_to_int (buf
[ 1]) << 6;
1383 l
|= itoa64_to_int (buf
[ 2]) << 12;
1384 l
|= itoa64_to_int (buf
[ 3]) << 18;
1386 digest
[ 2] = (l
>> 0) & 0xff;
1387 digest
[ 1] = (l
>> 8) & 0xff;
1388 digest
[ 0] = (l
>> 16) & 0xff;
1390 l
= itoa64_to_int (buf
[ 4]) << 0;
1391 l
|= itoa64_to_int (buf
[ 5]) << 6;
1392 l
|= itoa64_to_int (buf
[ 6]) << 12;
1393 l
|= itoa64_to_int (buf
[ 7]) << 18;
1395 digest
[ 5] = (l
>> 0) & 0xff;
1396 digest
[ 4] = (l
>> 8) & 0xff;
1397 digest
[ 3] = (l
>> 16) & 0xff;
1399 l
= itoa64_to_int (buf
[ 8]) << 0;
1400 l
|= itoa64_to_int (buf
[ 9]) << 6;
1401 l
|= itoa64_to_int (buf
[10]) << 12;
1402 l
|= itoa64_to_int (buf
[11]) << 18;
1404 digest
[ 8] = (l
>> 0) & 0xff;
1405 digest
[ 7] = (l
>> 8) & 0xff;
1406 digest
[ 6] = (l
>> 16) & 0xff;
1408 l
= itoa64_to_int (buf
[12]) << 0;
1409 l
|= itoa64_to_int (buf
[13]) << 6;
1410 l
|= itoa64_to_int (buf
[14]) << 12;
1411 l
|= itoa64_to_int (buf
[15]) << 18;
1413 digest
[11] = (l
>> 0) & 0xff;
1414 digest
[10] = (l
>> 8) & 0xff;
1415 digest
[ 9] = (l
>> 16) & 0xff;
1417 l
= itoa64_to_int (buf
[16]) << 0;
1418 l
|= itoa64_to_int (buf
[17]) << 6;
1419 l
|= itoa64_to_int (buf
[18]) << 12;
1420 l
|= itoa64_to_int (buf
[19]) << 18;
1422 digest
[14] = (l
>> 0) & 0xff;
1423 digest
[13] = (l
>> 8) & 0xff;
1424 digest
[12] = (l
>> 16) & 0xff;
1426 l
= itoa64_to_int (buf
[20]) << 0;
1427 l
|= itoa64_to_int (buf
[21]) << 6;
1428 l
|= itoa64_to_int (buf
[22]) << 12;
1429 l
|= itoa64_to_int (buf
[23]) << 18;
1431 digest
[17] = (l
>> 0) & 0xff;
1432 digest
[16] = (l
>> 8) & 0xff;
1433 digest
[15] = (l
>> 16) & 0xff;
1435 l
= itoa64_to_int (buf
[24]) << 0;
1436 l
|= itoa64_to_int (buf
[25]) << 6;
1437 l
|= itoa64_to_int (buf
[26]) << 12;
1438 l
|= itoa64_to_int (buf
[27]) << 18;
1440 digest
[20] = (l
>> 0) & 0xff;
1441 digest
[19] = (l
>> 8) & 0xff;
1442 digest
[18] = (l
>> 16) & 0xff;
1444 l
= itoa64_to_int (buf
[28]) << 0;
1445 l
|= itoa64_to_int (buf
[29]) << 6;
1446 l
|= itoa64_to_int (buf
[30]) << 12;
1447 l
|= itoa64_to_int (buf
[31]) << 18;
1449 digest
[23] = (l
>> 0) & 0xff;
1450 digest
[22] = (l
>> 8) & 0xff;
1451 digest
[21] = (l
>> 16) & 0xff;
1453 l
= itoa64_to_int (buf
[32]) << 0;
1454 l
|= itoa64_to_int (buf
[33]) << 6;
1455 l
|= itoa64_to_int (buf
[34]) << 12;
1456 l
|= itoa64_to_int (buf
[35]) << 18;
1458 digest
[26] = (l
>> 0) & 0xff;
1459 digest
[25] = (l
>> 8) & 0xff;
1460 digest
[24] = (l
>> 16) & 0xff;
1462 l
= itoa64_to_int (buf
[36]) << 0;
1463 l
|= itoa64_to_int (buf
[37]) << 6;
1464 l
|= itoa64_to_int (buf
[38]) << 12;
1465 l
|= itoa64_to_int (buf
[39]) << 18;
1467 digest
[29] = (l
>> 0) & 0xff;
1468 digest
[28] = (l
>> 8) & 0xff;
1469 digest
[27] = (l
>> 16) & 0xff;
1471 l
= itoa64_to_int (buf
[40]) << 0;
1472 l
|= itoa64_to_int (buf
[41]) << 6;
1473 l
|= itoa64_to_int (buf
[42]) << 12;
1475 //digest[32] = (l >> 0) & 0xff;
1476 digest
[31] = (l
>> 8) & 0xff;
1477 digest
[30] = (l
>> 16) & 0xff;
1480 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1484 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1486 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1489 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1491 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1493 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1496 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1498 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1500 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[11] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1507 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[15] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1514 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[19] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1521 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[23] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1528 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[27] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1535 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[31] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1542 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[35] = int_to_itoa64 (l
& 0x3f);
1547 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1549 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[39] = int_to_itoa64 (l
& 0x3f);
1554 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1556 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1558 buf
[42] = int_to_itoa64 (l
& 0x3f);
1561 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1565 l
= itoa64_to_int (buf
[ 0]) << 0;
1566 l
|= itoa64_to_int (buf
[ 1]) << 6;
1567 l
|= itoa64_to_int (buf
[ 2]) << 12;
1568 l
|= itoa64_to_int (buf
[ 3]) << 18;
1570 digest
[ 2] = (l
>> 0) & 0xff;
1571 digest
[ 1] = (l
>> 8) & 0xff;
1572 digest
[ 0] = (l
>> 16) & 0xff;
1574 l
= itoa64_to_int (buf
[ 4]) << 0;
1575 l
|= itoa64_to_int (buf
[ 5]) << 6;
1576 l
|= itoa64_to_int (buf
[ 6]) << 12;
1577 l
|= itoa64_to_int (buf
[ 7]) << 18;
1579 digest
[ 5] = (l
>> 0) & 0xff;
1580 digest
[ 4] = (l
>> 8) & 0xff;
1581 digest
[ 3] = (l
>> 16) & 0xff;
1583 l
= itoa64_to_int (buf
[ 8]) << 0;
1584 l
|= itoa64_to_int (buf
[ 9]) << 6;
1585 l
|= itoa64_to_int (buf
[10]) << 12;
1586 l
|= itoa64_to_int (buf
[11]) << 18;
1588 digest
[ 8] = (l
>> 0) & 0xff;
1589 digest
[ 7] = (l
>> 8) & 0xff;
1590 digest
[ 6] = (l
>> 16) & 0xff;
1592 l
= itoa64_to_int (buf
[12]) << 0;
1593 l
|= itoa64_to_int (buf
[13]) << 6;
1594 l
|= itoa64_to_int (buf
[14]) << 12;
1595 l
|= itoa64_to_int (buf
[15]) << 18;
1597 digest
[11] = (l
>> 0) & 0xff;
1598 digest
[10] = (l
>> 8) & 0xff;
1599 digest
[ 9] = (l
>> 16) & 0xff;
1601 l
= itoa64_to_int (buf
[16]) << 0;
1602 l
|= itoa64_to_int (buf
[17]) << 6;
1603 l
|= itoa64_to_int (buf
[18]) << 12;
1604 l
|= itoa64_to_int (buf
[19]) << 18;
1606 digest
[14] = (l
>> 0) & 0xff;
1607 digest
[13] = (l
>> 8) & 0xff;
1608 digest
[12] = (l
>> 16) & 0xff;
1610 l
= itoa64_to_int (buf
[20]) << 0;
1611 l
|= itoa64_to_int (buf
[21]) << 6;
1612 l
|= itoa64_to_int (buf
[22]) << 12;
1613 l
|= itoa64_to_int (buf
[23]) << 18;
1615 digest
[17] = (l
>> 0) & 0xff;
1616 digest
[16] = (l
>> 8) & 0xff;
1617 digest
[15] = (l
>> 16) & 0xff;
1619 l
= itoa64_to_int (buf
[24]) << 0;
1620 l
|= itoa64_to_int (buf
[25]) << 6;
1621 l
|= itoa64_to_int (buf
[26]) << 12;
1622 l
|= itoa64_to_int (buf
[27]) << 18;
1624 digest
[20] = (l
>> 0) & 0xff;
1625 digest
[19] = (l
>> 8) & 0xff;
1626 digest
[18] = (l
>> 16) & 0xff;
1628 l
= itoa64_to_int (buf
[28]) << 0;
1629 l
|= itoa64_to_int (buf
[29]) << 6;
1630 l
|= itoa64_to_int (buf
[30]) << 12;
1631 l
|= itoa64_to_int (buf
[31]) << 18;
1633 digest
[23] = (l
>> 0) & 0xff;
1634 digest
[22] = (l
>> 8) & 0xff;
1635 digest
[21] = (l
>> 16) & 0xff;
1637 l
= itoa64_to_int (buf
[32]) << 0;
1638 l
|= itoa64_to_int (buf
[33]) << 6;
1639 l
|= itoa64_to_int (buf
[34]) << 12;
1640 l
|= itoa64_to_int (buf
[35]) << 18;
1642 digest
[26] = (l
>> 0) & 0xff;
1643 digest
[25] = (l
>> 8) & 0xff;
1644 digest
[24] = (l
>> 16) & 0xff;
1646 l
= itoa64_to_int (buf
[36]) << 0;
1647 l
|= itoa64_to_int (buf
[37]) << 6;
1648 l
|= itoa64_to_int (buf
[38]) << 12;
1649 l
|= itoa64_to_int (buf
[39]) << 18;
1651 digest
[29] = (l
>> 0) & 0xff;
1652 digest
[28] = (l
>> 8) & 0xff;
1653 digest
[27] = (l
>> 16) & 0xff;
1655 l
= itoa64_to_int (buf
[40]) << 0;
1656 l
|= itoa64_to_int (buf
[41]) << 6;
1657 l
|= itoa64_to_int (buf
[42]) << 12;
1658 l
|= itoa64_to_int (buf
[43]) << 18;
1660 digest
[32] = (l
>> 0) & 0xff;
1661 digest
[31] = (l
>> 8) & 0xff;
1662 digest
[30] = (l
>> 16) & 0xff;
1664 l
= itoa64_to_int (buf
[44]) << 0;
1665 l
|= itoa64_to_int (buf
[45]) << 6;
1666 l
|= itoa64_to_int (buf
[46]) << 12;
1667 l
|= itoa64_to_int (buf
[47]) << 18;
1669 digest
[35] = (l
>> 0) & 0xff;
1670 digest
[34] = (l
>> 8) & 0xff;
1671 digest
[33] = (l
>> 16) & 0xff;
1673 l
= itoa64_to_int (buf
[48]) << 0;
1674 l
|= itoa64_to_int (buf
[49]) << 6;
1675 l
|= itoa64_to_int (buf
[50]) << 12;
1676 l
|= itoa64_to_int (buf
[51]) << 18;
1678 digest
[38] = (l
>> 0) & 0xff;
1679 digest
[37] = (l
>> 8) & 0xff;
1680 digest
[36] = (l
>> 16) & 0xff;
1682 l
= itoa64_to_int (buf
[52]) << 0;
1683 l
|= itoa64_to_int (buf
[53]) << 6;
1684 l
|= itoa64_to_int (buf
[54]) << 12;
1685 l
|= itoa64_to_int (buf
[55]) << 18;
1687 digest
[41] = (l
>> 0) & 0xff;
1688 digest
[40] = (l
>> 8) & 0xff;
1689 digest
[39] = (l
>> 16) & 0xff;
1691 l
= itoa64_to_int (buf
[56]) << 0;
1692 l
|= itoa64_to_int (buf
[57]) << 6;
1693 l
|= itoa64_to_int (buf
[58]) << 12;
1694 l
|= itoa64_to_int (buf
[59]) << 18;
1696 digest
[44] = (l
>> 0) & 0xff;
1697 digest
[43] = (l
>> 8) & 0xff;
1698 digest
[42] = (l
>> 16) & 0xff;
1700 l
= itoa64_to_int (buf
[60]) << 0;
1701 l
|= itoa64_to_int (buf
[61]) << 6;
1702 l
|= itoa64_to_int (buf
[62]) << 12;
1703 l
|= itoa64_to_int (buf
[63]) << 18;
1705 digest
[47] = (l
>> 0) & 0xff;
1706 digest
[46] = (l
>> 8) & 0xff;
1707 digest
[45] = (l
>> 16) & 0xff;
1709 l
= itoa64_to_int (buf
[64]) << 0;
1710 l
|= itoa64_to_int (buf
[65]) << 6;
1711 l
|= itoa64_to_int (buf
[66]) << 12;
1712 l
|= itoa64_to_int (buf
[67]) << 18;
1714 digest
[50] = (l
>> 0) & 0xff;
1715 digest
[49] = (l
>> 8) & 0xff;
1716 digest
[48] = (l
>> 16) & 0xff;
1718 l
= itoa64_to_int (buf
[68]) << 0;
1719 l
|= itoa64_to_int (buf
[69]) << 6;
1720 l
|= itoa64_to_int (buf
[70]) << 12;
1721 l
|= itoa64_to_int (buf
[71]) << 18;
1723 digest
[53] = (l
>> 0) & 0xff;
1724 digest
[52] = (l
>> 8) & 0xff;
1725 digest
[51] = (l
>> 16) & 0xff;
1727 l
= itoa64_to_int (buf
[72]) << 0;
1728 l
|= itoa64_to_int (buf
[73]) << 6;
1729 l
|= itoa64_to_int (buf
[74]) << 12;
1730 l
|= itoa64_to_int (buf
[75]) << 18;
1732 digest
[56] = (l
>> 0) & 0xff;
1733 digest
[55] = (l
>> 8) & 0xff;
1734 digest
[54] = (l
>> 16) & 0xff;
1736 l
= itoa64_to_int (buf
[76]) << 0;
1737 l
|= itoa64_to_int (buf
[77]) << 6;
1738 l
|= itoa64_to_int (buf
[78]) << 12;
1739 l
|= itoa64_to_int (buf
[79]) << 18;
1741 digest
[59] = (l
>> 0) & 0xff;
1742 digest
[58] = (l
>> 8) & 0xff;
1743 digest
[57] = (l
>> 16) & 0xff;
1745 l
= itoa64_to_int (buf
[80]) << 0;
1746 l
|= itoa64_to_int (buf
[81]) << 6;
1747 l
|= itoa64_to_int (buf
[82]) << 12;
1748 l
|= itoa64_to_int (buf
[83]) << 18;
1750 digest
[62] = (l
>> 0) & 0xff;
1751 digest
[61] = (l
>> 8) & 0xff;
1752 digest
[60] = (l
>> 16) & 0xff;
1754 l
= itoa64_to_int (buf
[84]) << 0;
1755 l
|= itoa64_to_int (buf
[85]) << 6;
1757 digest
[63] = (l
>> 16) & 0xff;
1760 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1764 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1766 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1769 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1771 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1773 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1776 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1778 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1780 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[11] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1787 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[15] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1794 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[19] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1801 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[23] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1808 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[27] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1815 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[31] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1822 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[35] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1829 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[39] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1836 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[43] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1843 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[47] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1850 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[51] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1857 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[55] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1864 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[59] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1871 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[63] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1878 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[67] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1885 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[71] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1892 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[75] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1899 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[79] = int_to_itoa64 (l
& 0x3f);
1904 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1906 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[83] = int_to_itoa64 (l
& 0x3f);
1911 l
= 0 | 0 | (digest
[63] << 16);
1913 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1917 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1921 l
= itoa64_to_int (buf
[ 0]) << 0;
1922 l
|= itoa64_to_int (buf
[ 1]) << 6;
1923 l
|= itoa64_to_int (buf
[ 2]) << 12;
1924 l
|= itoa64_to_int (buf
[ 3]) << 18;
1926 digest
[ 0] = (l
>> 16) & 0xff;
1927 digest
[10] = (l
>> 8) & 0xff;
1928 digest
[20] = (l
>> 0) & 0xff;
1930 l
= itoa64_to_int (buf
[ 4]) << 0;
1931 l
|= itoa64_to_int (buf
[ 5]) << 6;
1932 l
|= itoa64_to_int (buf
[ 6]) << 12;
1933 l
|= itoa64_to_int (buf
[ 7]) << 18;
1935 digest
[21] = (l
>> 16) & 0xff;
1936 digest
[ 1] = (l
>> 8) & 0xff;
1937 digest
[11] = (l
>> 0) & 0xff;
1939 l
= itoa64_to_int (buf
[ 8]) << 0;
1940 l
|= itoa64_to_int (buf
[ 9]) << 6;
1941 l
|= itoa64_to_int (buf
[10]) << 12;
1942 l
|= itoa64_to_int (buf
[11]) << 18;
1944 digest
[12] = (l
>> 16) & 0xff;
1945 digest
[22] = (l
>> 8) & 0xff;
1946 digest
[ 2] = (l
>> 0) & 0xff;
1948 l
= itoa64_to_int (buf
[12]) << 0;
1949 l
|= itoa64_to_int (buf
[13]) << 6;
1950 l
|= itoa64_to_int (buf
[14]) << 12;
1951 l
|= itoa64_to_int (buf
[15]) << 18;
1953 digest
[ 3] = (l
>> 16) & 0xff;
1954 digest
[13] = (l
>> 8) & 0xff;
1955 digest
[23] = (l
>> 0) & 0xff;
1957 l
= itoa64_to_int (buf
[16]) << 0;
1958 l
|= itoa64_to_int (buf
[17]) << 6;
1959 l
|= itoa64_to_int (buf
[18]) << 12;
1960 l
|= itoa64_to_int (buf
[19]) << 18;
1962 digest
[24] = (l
>> 16) & 0xff;
1963 digest
[ 4] = (l
>> 8) & 0xff;
1964 digest
[14] = (l
>> 0) & 0xff;
1966 l
= itoa64_to_int (buf
[20]) << 0;
1967 l
|= itoa64_to_int (buf
[21]) << 6;
1968 l
|= itoa64_to_int (buf
[22]) << 12;
1969 l
|= itoa64_to_int (buf
[23]) << 18;
1971 digest
[15] = (l
>> 16) & 0xff;
1972 digest
[25] = (l
>> 8) & 0xff;
1973 digest
[ 5] = (l
>> 0) & 0xff;
1975 l
= itoa64_to_int (buf
[24]) << 0;
1976 l
|= itoa64_to_int (buf
[25]) << 6;
1977 l
|= itoa64_to_int (buf
[26]) << 12;
1978 l
|= itoa64_to_int (buf
[27]) << 18;
1980 digest
[ 6] = (l
>> 16) & 0xff;
1981 digest
[16] = (l
>> 8) & 0xff;
1982 digest
[26] = (l
>> 0) & 0xff;
1984 l
= itoa64_to_int (buf
[28]) << 0;
1985 l
|= itoa64_to_int (buf
[29]) << 6;
1986 l
|= itoa64_to_int (buf
[30]) << 12;
1987 l
|= itoa64_to_int (buf
[31]) << 18;
1989 digest
[27] = (l
>> 16) & 0xff;
1990 digest
[ 7] = (l
>> 8) & 0xff;
1991 digest
[17] = (l
>> 0) & 0xff;
1993 l
= itoa64_to_int (buf
[32]) << 0;
1994 l
|= itoa64_to_int (buf
[33]) << 6;
1995 l
|= itoa64_to_int (buf
[34]) << 12;
1996 l
|= itoa64_to_int (buf
[35]) << 18;
1998 digest
[18] = (l
>> 16) & 0xff;
1999 digest
[28] = (l
>> 8) & 0xff;
2000 digest
[ 8] = (l
>> 0) & 0xff;
2002 l
= itoa64_to_int (buf
[36]) << 0;
2003 l
|= itoa64_to_int (buf
[37]) << 6;
2004 l
|= itoa64_to_int (buf
[38]) << 12;
2005 l
|= itoa64_to_int (buf
[39]) << 18;
2007 digest
[ 9] = (l
>> 16) & 0xff;
2008 digest
[19] = (l
>> 8) & 0xff;
2009 digest
[29] = (l
>> 0) & 0xff;
2011 l
= itoa64_to_int (buf
[40]) << 0;
2012 l
|= itoa64_to_int (buf
[41]) << 6;
2013 l
|= itoa64_to_int (buf
[42]) << 12;
2015 digest
[31] = (l
>> 8) & 0xff;
2016 digest
[30] = (l
>> 0) & 0xff;
2019 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2023 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2025 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2028 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2032 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2035 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2039 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2046 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2053 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2060 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2067 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2074 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2081 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2088 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2095 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2097 buf
[42] = int_to_itoa64 (l
& 0x3f);
2100 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2104 l
= itoa64_to_int (buf
[ 0]) << 0;
2105 l
|= itoa64_to_int (buf
[ 1]) << 6;
2106 l
|= itoa64_to_int (buf
[ 2]) << 12;
2107 l
|= itoa64_to_int (buf
[ 3]) << 18;
2109 digest
[ 0] = (l
>> 0) & 0xff;
2110 digest
[ 1] = (l
>> 8) & 0xff;
2111 digest
[ 2] = (l
>> 16) & 0xff;
2113 l
= itoa64_to_int (buf
[ 4]) << 0;
2114 l
|= itoa64_to_int (buf
[ 5]) << 6;
2115 l
|= itoa64_to_int (buf
[ 6]) << 12;
2116 l
|= itoa64_to_int (buf
[ 7]) << 18;
2118 digest
[ 3] = (l
>> 0) & 0xff;
2119 digest
[ 4] = (l
>> 8) & 0xff;
2120 digest
[ 5] = (l
>> 16) & 0xff;
2122 l
= itoa64_to_int (buf
[ 8]) << 0;
2123 l
|= itoa64_to_int (buf
[ 9]) << 6;
2124 l
|= itoa64_to_int (buf
[10]) << 12;
2125 l
|= itoa64_to_int (buf
[11]) << 18;
2127 digest
[ 6] = (l
>> 0) & 0xff;
2128 digest
[ 7] = (l
>> 8) & 0xff;
2129 digest
[ 8] = (l
>> 16) & 0xff;
2131 l
= itoa64_to_int (buf
[12]) << 0;
2132 l
|= itoa64_to_int (buf
[13]) << 6;
2133 l
|= itoa64_to_int (buf
[14]) << 12;
2134 l
|= itoa64_to_int (buf
[15]) << 18;
2136 digest
[ 9] = (l
>> 0) & 0xff;
2137 digest
[10] = (l
>> 8) & 0xff;
2138 digest
[11] = (l
>> 16) & 0xff;
2140 l
= itoa64_to_int (buf
[16]) << 0;
2141 l
|= itoa64_to_int (buf
[17]) << 6;
2142 l
|= itoa64_to_int (buf
[18]) << 12;
2143 l
|= itoa64_to_int (buf
[19]) << 18;
2145 digest
[12] = (l
>> 0) & 0xff;
2146 digest
[13] = (l
>> 8) & 0xff;
2147 digest
[14] = (l
>> 16) & 0xff;
2149 l
= itoa64_to_int (buf
[20]) << 0;
2150 l
|= itoa64_to_int (buf
[21]) << 6;
2151 l
|= itoa64_to_int (buf
[22]) << 12;
2152 l
|= itoa64_to_int (buf
[23]) << 18;
2154 digest
[15] = (l
>> 0) & 0xff;
2155 digest
[16] = (l
>> 8) & 0xff;
2156 digest
[17] = (l
>> 16) & 0xff;
2158 l
= itoa64_to_int (buf
[24]) << 0;
2159 l
|= itoa64_to_int (buf
[25]) << 6;
2160 l
|= itoa64_to_int (buf
[26]) << 12;
2161 l
|= itoa64_to_int (buf
[27]) << 18;
2163 digest
[18] = (l
>> 0) & 0xff;
2164 digest
[19] = (l
>> 8) & 0xff;
2165 digest
[20] = (l
>> 16) & 0xff;
2167 l
= itoa64_to_int (buf
[28]) << 0;
2168 l
|= itoa64_to_int (buf
[29]) << 6;
2169 l
|= itoa64_to_int (buf
[30]) << 12;
2170 l
|= itoa64_to_int (buf
[31]) << 18;
2172 digest
[21] = (l
>> 0) & 0xff;
2173 digest
[22] = (l
>> 8) & 0xff;
2174 digest
[23] = (l
>> 16) & 0xff;
2176 l
= itoa64_to_int (buf
[32]) << 0;
2177 l
|= itoa64_to_int (buf
[33]) << 6;
2178 l
|= itoa64_to_int (buf
[34]) << 12;
2179 l
|= itoa64_to_int (buf
[35]) << 18;
2181 digest
[24] = (l
>> 0) & 0xff;
2182 digest
[25] = (l
>> 8) & 0xff;
2183 digest
[26] = (l
>> 16) & 0xff;
2185 l
= itoa64_to_int (buf
[36]) << 0;
2186 l
|= itoa64_to_int (buf
[37]) << 6;
2187 l
|= itoa64_to_int (buf
[38]) << 12;
2188 l
|= itoa64_to_int (buf
[39]) << 18;
2190 digest
[27] = (l
>> 0) & 0xff;
2191 digest
[28] = (l
>> 8) & 0xff;
2192 digest
[29] = (l
>> 16) & 0xff;
2194 l
= itoa64_to_int (buf
[40]) << 0;
2195 l
|= itoa64_to_int (buf
[41]) << 6;
2196 l
|= itoa64_to_int (buf
[42]) << 12;
2197 l
|= itoa64_to_int (buf
[43]) << 18;
2199 digest
[30] = (l
>> 0) & 0xff;
2200 digest
[31] = (l
>> 8) & 0xff;
2201 digest
[32] = (l
>> 16) & 0xff;
2236 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2240 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2242 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2245 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2247 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2249 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2252 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2254 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2256 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[11] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2263 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[15] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2270 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[19] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2277 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[23] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2284 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[27] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2291 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[31] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2298 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[35] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2305 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[39] = int_to_itoa64 (l
& 0x3f);
2310 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2312 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2315 //buf[43] = int_to_itoa64 (l & 0x3f);
2323 static struct termio savemodes
;
2324 static int havemodes
= 0;
2328 struct termio modmodes
;
2330 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2334 modmodes
= savemodes
;
2335 modmodes
.c_lflag
&= ~ICANON
;
2336 modmodes
.c_cc
[VMIN
] = 1;
2337 modmodes
.c_cc
[VTIME
] = 0;
2339 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2348 FD_SET (fileno (stdin
), &rfds
);
2355 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2357 if (retval
== 0) return 0;
2358 if (retval
== -1) return -1;
2365 if (!havemodes
) return 0;
2367 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2372 static struct termios savemodes
;
2373 static int havemodes
= 0;
2377 struct termios modmodes
;
2379 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2383 modmodes
= savemodes
;
2384 modmodes
.c_lflag
&= ~ICANON
;
2385 modmodes
.c_cc
[VMIN
] = 1;
2386 modmodes
.c_cc
[VTIME
] = 0;
2388 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2397 FD_SET (fileno (stdin
), &rfds
);
2404 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2406 if (retval
== 0) return 0;
2407 if (retval
== -1) return -1;
2414 if (!havemodes
) return 0;
2416 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2421 static DWORD saveMode
= 0;
2425 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2427 GetConsoleMode (stdinHandle
, &saveMode
);
2428 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2435 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2437 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2439 if (rc
== WAIT_TIMEOUT
) return 0;
2440 if (rc
== WAIT_ABANDONED
) return -1;
2441 if (rc
== WAIT_FAILED
) return -1;
2443 // The whole ReadConsoleInput () part is a workaround.
2444 // For some unknown reason, maybe a mingw bug, a random signal
2445 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2446 // Then it wants to read with getche () a keyboard input
2447 // which has never been made.
2449 INPUT_RECORD buf
[100];
2453 memset (buf
, 0, sizeof (buf
));
2455 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2457 FlushConsoleInputBuffer (stdinHandle
);
2459 for (uint i
= 0; i
< num
; i
++)
2461 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2463 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2465 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2467 return KeyEvent
.uChar
.AsciiChar
;
2475 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2477 SetConsoleMode (stdinHandle
, saveMode
);
2487 #define MSG_ENOMEM "Insufficient memory available"
2489 void *mycalloc (size_t nmemb
, size_t size
)
2491 void *p
= calloc (nmemb
, size
);
2495 log_error ("ERROR: %s", MSG_ENOMEM
);
2503 void *mymalloc (size_t size
)
2505 void *p
= malloc (size
);
2509 log_error ("ERROR: %s", MSG_ENOMEM
);
2514 memset (p
, 0, size
);
2519 void myfree (void *ptr
)
2521 if (ptr
== NULL
) return;
2526 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2528 void *p
= realloc (ptr
, oldsz
+ add
);
2532 log_error ("ERROR: %s", MSG_ENOMEM
);
2537 memset ((char *) p
+ oldsz
, 0, add
);
2542 char *mystrdup (const char *s
)
2544 const size_t len
= strlen (s
);
2546 char *b
= (char *) mymalloc (len
+ 1);
2553 FILE *logfile_open (char *logfile
)
2555 FILE *fp
= fopen (logfile
, "ab");
2565 void logfile_close (FILE *fp
)
2567 if (fp
== stdout
) return;
2572 void logfile_append (const char *fmt
, ...)
2574 if (data
.logfile_disable
== 1) return;
2576 FILE *fp
= logfile_open (data
.logfile
);
2582 vfprintf (fp
, fmt
, ap
);
2593 int logfile_generate_id ()
2595 const int n
= rand ();
2604 char *logfile_generate_topid ()
2606 const int id
= logfile_generate_id ();
2608 char *topid
= (char *) mymalloc (1 + 16 + 1);
2610 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2615 char *logfile_generate_subid ()
2617 const int id
= logfile_generate_id ();
2619 char *subid
= (char *) mymalloc (1 + 16 + 1);
2621 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2631 void lock_file (FILE *fp
)
2635 memset (&lock
, 0, sizeof (struct flock
));
2637 lock
.l_type
= F_WRLCK
;
2638 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2642 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2649 void unlock_file (FILE *fp
)
2653 memset (&lock
, 0, sizeof (struct flock
));
2655 lock
.l_type
= F_UNLCK
;
2656 fcntl(fileno(fp
), F_SETLK
, &lock
);
2663 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2665 FlushFileBuffers (h
);
2674 #if defined(_WIN) && defined(HAVE_NVAPI)
2675 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2679 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2683 log_info ("WARN: No NvAPI adapters found");
2690 #endif // _WIN && HAVE_NVAPI
2692 #if defined(LINUX) && defined(HAVE_NVML)
2693 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2697 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2699 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2701 // can be used to determine if the device by index matches the cuda device by index
2702 // char name[100]; memset (name, 0, sizeof (name));
2703 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2710 log_info ("WARN: No NVML adapters found");
2717 #endif // LINUX && HAVE_NVML
2720 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2722 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2724 if (iNumberAdapters
== 0)
2726 log_info ("WARN: No ADL adapters found.");
2735 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2737 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2738 ADLODParameters lpOdParameters;
2740 lpOdParameters.iSize = sizeof (ADLODParameters);
2741 size_t plevels_size = 0;
2743 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2745 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2746 __func__, iAdapterIndex,
2747 lpOdParameters.iNumberOfPerformanceLevels,
2748 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2749 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2751 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2753 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2755 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2757 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2759 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2760 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2761 __func__, iAdapterIndex, j,
2762 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2764 myfree (lpOdPerformanceLevels);
2770 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2772 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2774 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2776 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2778 return lpAdapterInfo
;
2783 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2786 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2790 for (uint i = 0; i < num_adl_adapters; i++)
2792 int opencl_bus_num = hm_device[i].busid;
2793 int opencl_dev_num = hm_device[i].devid;
2795 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2803 if (idx >= DEVICES_MAX) return -1;
2808 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2810 for (uint i = 0; i < opencl_num_devices; i++)
2812 cl_device_topology_amd device_topology;
2814 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2816 hm_device[i].busid = device_topology.pcie.bus;
2817 hm_device[i].devid = device_topology.pcie.device;
2822 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2824 // basically bubble sort
2826 for (int i
= 0; i
< num_adl_adapters
; i
++)
2828 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2830 // get info of adapter [x]
2832 u32 adapter_index_x
= valid_adl_device_list
[j
];
2833 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2835 u32 bus_num_x
= info_x
.iBusNumber
;
2836 u32 dev_num_x
= info_x
.iDeviceNumber
;
2838 // get info of adapter [y]
2840 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2841 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2843 u32 bus_num_y
= info_y
.iBusNumber
;
2844 u32 dev_num_y
= info_y
.iDeviceNumber
;
2848 if (bus_num_y
< bus_num_x
)
2852 else if (bus_num_y
== bus_num_x
)
2854 if (dev_num_y
< dev_num_x
)
2862 u32 temp
= valid_adl_device_list
[j
+ 1];
2864 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2865 valid_adl_device_list
[j
+ 0] = temp
;
2871 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2873 *num_adl_adapters
= 0;
2875 u32
*adl_adapters
= NULL
;
2877 int *bus_numbers
= NULL
;
2878 int *device_numbers
= NULL
;
2880 for (int i
= 0; i
< iNumberAdapters
; i
++)
2882 AdapterInfo info
= lpAdapterInfo
[i
];
2884 if (strlen (info
.strUDID
) < 1) continue;
2887 if (info
.iVendorID
!= 1002) continue;
2889 if (info
.iVendorID
!= 0x1002) continue;
2892 if (info
.iBusNumber
< 0) continue;
2893 if (info
.iDeviceNumber
< 0) continue;
2897 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2899 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2906 if (found
) continue;
2908 // add it to the list
2910 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2912 adl_adapters
[*num_adl_adapters
] = i
;
2914 // rest is just bookkeeping
2916 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2917 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2919 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2920 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2922 (*num_adl_adapters
)++;
2925 myfree (bus_numbers
);
2926 myfree (device_numbers
);
2928 // sort the list by increasing bus id, device id number
2930 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2932 return adl_adapters
;
2935 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2937 // loop through all valid devices
2939 for (int i
= 0; i
< num_adl_adapters
; i
++)
2941 u32 adapter_index
= valid_adl_device_list
[i
];
2945 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2947 // unfortunately this doesn't work since bus id and dev id are not unique
2948 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2949 // if (opencl_device_index == -1) continue;
2951 int opencl_device_index
= i
;
2953 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2955 // get fanspeed info
2957 if (hm_device
[opencl_device_index
].od_version
== 5)
2959 ADLFanSpeedInfo FanSpeedInfo
;
2961 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2963 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2965 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2967 // check read and write capability in fanspeedinfo
2969 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2970 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2972 hm_device
[opencl_device_index
].fan_supported
= 1;
2976 hm_device
[opencl_device_index
].fan_supported
= 0;
2979 else // od_version == 6
2981 ADLOD6FanSpeedInfo faninfo
;
2983 memset (&faninfo
, 0, sizeof (faninfo
));
2985 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2987 // check read capability in fanspeedinfo
2989 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2991 hm_device
[opencl_device_index
].fan_supported
= 1;
2995 hm_device
[opencl_device_index
].fan_supported
= 0;
3003 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3005 for (int i
= 0; i
< num_adl_adapters
; i
++)
3007 u32 adapter_index
= valid_adl_device_list
[i
];
3011 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3013 // get overdrive version
3015 int od_supported
= 0;
3019 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3021 // store the overdrive version in hm_device
3023 // unfortunately this doesn't work since bus id and dev id are not unique
3024 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3025 // if (opencl_device_index == -1) continue;
3027 int opencl_device_index
= i
;
3029 hm_device
[opencl_device_index
].od_version
= od_version
;
3035 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3037 for (int i
= 0; i
< num_adl_adapters
; i
++)
3039 u32 adapter_index
= valid_adl_device_list
[i
];
3043 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3045 // store the iAdapterIndex in hm_device
3047 // unfortunately this doesn't work since bus id and dev id are not unique
3048 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3049 // if (opencl_device_index == -1) continue;
3051 int opencl_device_index
= i
;
3053 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3056 return num_adl_adapters
;
3060 int hm_get_temperature_with_device_id (const uint device_id
)
3062 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3065 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3069 if (data
.hm_device
[device_id
].od_version
== 5)
3071 ADLTemperature Temperature
;
3073 Temperature
.iSize
= sizeof (ADLTemperature
);
3075 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3077 return Temperature
.iTemperature
/ 1000;
3079 else if (data
.hm_device
[device_id
].od_version
== 6)
3081 int Temperature
= 0;
3083 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3085 return Temperature
/ 1000;
3091 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3092 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3094 #if defined(LINUX) && defined(HAVE_NVML)
3095 int temperature
= 0;
3097 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3102 #if defined(WIN) && defined(HAVE_NVAPI)
3103 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3105 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3106 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3107 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3108 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3110 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3112 return pThermalSettings
.sensor
[0].currentTemp
;
3113 #endif // WIN && HAVE_NVAPI
3115 #endif // HAVE_NVML || HAVE_NVAPI
3120 int hm_get_fanspeed_with_device_id (const uint device_id
)
3122 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3123 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3125 if (data
.hm_device
[device_id
].fan_supported
== 1)
3128 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3132 if (data
.hm_device
[device_id
].od_version
== 5)
3134 ADLFanSpeedValue lpFanSpeedValue
;
3136 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3138 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3139 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3140 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3142 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3144 return lpFanSpeedValue
.iFanSpeed
;
3146 else // od_version == 6
3148 ADLOD6FanSpeedInfo faninfo
;
3150 memset (&faninfo
, 0, sizeof (faninfo
));
3152 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3154 return faninfo
.iFanSpeedPercent
;
3160 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3161 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3163 #if defined(LINUX) && defined(HAVE_NVML)
3166 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3171 #if defined(WIN) && defined(HAVE_NVAPI)
3174 hm_NvAPI_GPU_GetTachReading (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &speed
);
3179 #endif // HAVE_NVML || HAVE_NVAPI
3185 int hm_get_utilization_with_device_id (const uint device_id
)
3187 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3190 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3194 ADLPMActivity PMActivity
;
3196 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3198 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3200 return PMActivity
.iActivityPercent
;
3205 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3206 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3208 #if defined(LINUX) && defined(HAVE_NVML)
3209 nvmlUtilization_t utilization
;
3211 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3213 return utilization
.gpu
;
3216 #if defined(WIN) && defined(HAVE_NVAPI)
3217 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3219 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3221 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3223 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3226 #endif // HAVE_NVML || HAVE_NVAPI
3232 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3234 if (data
.hm_device
[device_id
].fan_supported
== 1)
3238 if (data
.hm_device
[device_id
].od_version
== 5)
3240 ADLFanSpeedValue lpFanSpeedValue
;
3242 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3244 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3245 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3246 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3247 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3249 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3253 else // od_version == 6
3255 ADLOD6FanSpeedValue fan_speed_value
;
3257 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3259 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3260 fan_speed_value
.iFanSpeed
= fanspeed
;
3262 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3273 // helper function for status display
3275 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3277 #define VALUE_NOT_AVAILABLE "N/A"
3281 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3285 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3288 #endif // HAVE_HWMON
3294 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3296 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3298 if (css_cnt
> SP_PW_MAX
)
3300 log_error ("ERROR: mask length is too long");
3305 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3307 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3309 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3310 uint cs_len
= css
[css_pos
].cs_len
;
3312 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3314 uint c
= cs_buf
[cs_pos
] & 0xff;
3321 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3323 cs_t
*cs
= &css
[css_cnt
];
3325 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3327 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3331 for (i
= 0; i
< cs
->cs_len
; i
++)
3333 const uint u
= cs
->cs_buf
[i
];
3338 for (i
= 0; i
< in_len
; i
++)
3340 uint u
= in_buf
[i
] & 0xff;
3342 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3344 if (css_uniq
[u
] == 1) continue;
3348 cs
->cs_buf
[cs
->cs_len
] = u
;
3356 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3360 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3362 uint p0
= in_buf
[in_pos
] & 0xff;
3364 if (interpret
== 1 && p0
== '?')
3368 if (in_pos
== in_len
) break;
3370 uint p1
= in_buf
[in_pos
] & 0xff;
3374 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3376 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3378 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3380 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3382 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3384 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3386 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3387 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3389 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3390 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3392 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3393 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3395 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3396 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3398 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3400 default: log_error ("Syntax error: %s", in_buf
);
3406 if (data
.hex_charset
)
3410 if (in_pos
== in_len
)
3412 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3417 uint p1
= in_buf
[in_pos
] & 0xff;
3419 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3421 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3428 chr
= hex_convert (p1
) << 0;
3429 chr
|= hex_convert (p0
) << 4;
3431 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3437 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3443 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3447 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3449 sum
*= css
[css_pos
].cs_len
;
3455 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3457 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3462 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3464 char p0
= mask_buf
[mask_pos
];
3470 if (mask_pos
== mask_len
) break;
3472 char p1
= mask_buf
[mask_pos
];
3478 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3480 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3482 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3484 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3486 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3488 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3490 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3491 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3493 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3494 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3496 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3497 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3499 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3500 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3502 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3504 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3510 if (data
.hex_charset
)
3514 // if there is no 2nd hex character, show an error:
3516 if (mask_pos
== mask_len
)
3518 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3523 char p1
= mask_buf
[mask_pos
];
3525 // if they are not valid hex character, show an error:
3527 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3529 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3536 chr
|= hex_convert (p1
) << 0;
3537 chr
|= hex_convert (p0
) << 4;
3539 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3545 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3552 log_error ("ERROR: invalid mask length (0)");
3562 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3564 for (int i
= 0; i
< css_cnt
; i
++)
3566 uint len
= css
[i
].cs_len
;
3567 u64 next
= val
/ len
;
3568 uint pos
= val
% len
;
3569 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3574 void mp_cut_at (char *mask
, uint max
)
3578 uint mask_len
= strlen (mask
);
3580 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3582 if (mask
[i
] == '?') i
++;
3588 void mp_setup_sys (cs_t
*mp_sys
)
3592 uint donec
[CHARSIZ
] = { 0 };
3594 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3595 mp_sys
[0].cs_buf
[pos
++] = chr
;
3596 mp_sys
[0].cs_len
= pos
; }
3598 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3599 mp_sys
[1].cs_buf
[pos
++] = chr
;
3600 mp_sys
[1].cs_len
= pos
; }
3602 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3603 mp_sys
[2].cs_buf
[pos
++] = chr
;
3604 mp_sys
[2].cs_len
= pos
; }
3606 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3607 mp_sys
[3].cs_buf
[pos
++] = chr
;
3608 mp_sys
[3].cs_len
= pos
; }
3610 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3611 mp_sys
[4].cs_len
= pos
; }
3613 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3614 mp_sys
[5].cs_len
= pos
; }
3617 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3619 FILE *fp
= fopen (buf
, "rb");
3621 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3623 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3627 char mp_file
[1024] = { 0 };
3629 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3633 len
= in_superchop (mp_file
);
3637 log_info ("WARNING: charset file corrupted");
3639 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3643 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3648 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3650 mp_usr
[index
].cs_len
= 0;
3652 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3655 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3657 char *new_mask_buf
= (char *) mymalloc (256);
3663 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3665 if (css_pos
== len
) break;
3667 char p0
= mask_buf
[mask_pos
];
3669 new_mask_buf
[mask_pos
] = p0
;
3675 if (mask_pos
== mask_len
) break;
3677 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3681 if (data
.hex_charset
)
3685 if (mask_pos
== mask_len
)
3687 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3692 char p1
= mask_buf
[mask_pos
];
3694 // if they are not valid hex character, show an error:
3696 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3698 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3703 new_mask_buf
[mask_pos
] = p1
;
3708 if (css_pos
== len
) return (new_mask_buf
);
3710 myfree (new_mask_buf
);
3719 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3725 for (i
= start
; i
< stop
; i
++)
3727 sum
*= root_css_buf
[i
].cs_len
;
3733 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3737 cs_t
*cs
= &root_css_buf
[start
];
3741 for (i
= start
; i
< stop
; i
++)
3743 const u64 m
= v
% cs
->cs_len
;
3744 const u64 d
= v
/ cs
->cs_len
;
3748 const uint k
= cs
->cs_buf
[m
];
3750 pw_buf
[i
- start
] = (char) k
;
3752 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3756 int sp_comp_val (const void *p1
, const void *p2
)
3758 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3759 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3761 return b2
->val
- b1
->val
;
3764 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
)
3771 * Initialize hcstats
3774 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3776 u64
*root_stats_ptr
= root_stats_buf
;
3778 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3780 for (i
= 0; i
< SP_PW_MAX
; i
++)
3782 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3784 root_stats_ptr
+= CHARSIZ
;
3787 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3789 u64
*markov_stats_ptr
= markov_stats_buf
;
3791 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3793 for (i
= 0; i
< SP_PW_MAX
; i
++)
3795 for (j
= 0; j
< CHARSIZ
; j
++)
3797 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3799 markov_stats_ptr
+= CHARSIZ
;
3809 char hcstat_tmp
[256] = { 0 };
3811 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3813 hcstat
= hcstat_tmp
;
3816 FILE *fd
= fopen (hcstat
, "rb");
3820 log_error ("%s: %s", hcstat
, strerror (errno
));
3825 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3827 log_error ("%s: Could not load data", hcstat
);
3834 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3836 log_error ("%s: Could not load data", hcstat
);
3846 * Markov modifier of hcstat_table on user request
3851 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3852 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3857 /* Add all stats to first position */
3859 for (i
= 1; i
< SP_PW_MAX
; i
++)
3861 u64
*out
= root_stats_buf_by_pos
[0];
3862 u64
*in
= root_stats_buf_by_pos
[i
];
3864 for (j
= 0; j
< CHARSIZ
; j
++)
3870 for (i
= 1; i
< SP_PW_MAX
; i
++)
3872 u64
*out
= markov_stats_buf_by_key
[0][0];
3873 u64
*in
= markov_stats_buf_by_key
[i
][0];
3875 for (j
= 0; j
< CHARSIZ
; j
++)
3877 for (k
= 0; k
< CHARSIZ
; k
++)
3884 /* copy them to all pw_positions */
3886 for (i
= 1; i
< SP_PW_MAX
; i
++)
3888 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3891 for (i
= 1; i
< SP_PW_MAX
; i
++)
3893 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3901 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3903 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3905 for (i
= 0; i
< SP_PW_MAX
; i
++)
3907 root_table_buf_by_pos
[i
] = root_table_ptr
;
3909 root_table_ptr
+= CHARSIZ
;
3912 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3914 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3916 for (i
= 0; i
< SP_PW_MAX
; i
++)
3918 for (j
= 0; j
< CHARSIZ
; j
++)
3920 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3922 markov_table_ptr
+= CHARSIZ
;
3927 * Convert hcstat to tables
3930 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3932 uint key
= i
% CHARSIZ
;
3934 root_table_buf
[i
].key
= key
;
3935 root_table_buf
[i
].val
= root_stats_buf
[i
];
3938 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3940 uint key
= i
% CHARSIZ
;
3942 markov_table_buf
[i
].key
= key
;
3943 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3946 myfree (root_stats_buf
);
3947 myfree (markov_stats_buf
);
3953 for (i
= 0; i
< SP_PW_MAX
; i
++)
3955 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3958 for (i
= 0; i
< SP_PW_MAX
; i
++)
3960 for (j
= 0; j
< CHARSIZ
; j
++)
3962 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3967 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
])
3970 * Convert tables to css
3973 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3975 uint pw_pos
= i
/ CHARSIZ
;
3977 cs_t
*cs
= &root_css_buf
[pw_pos
];
3979 if (cs
->cs_len
== threshold
) continue;
3981 uint key
= root_table_buf
[i
].key
;
3983 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3985 cs
->cs_buf
[cs
->cs_len
] = key
;
3991 * Convert table to css
3994 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3996 uint c
= i
/ CHARSIZ
;
3998 cs_t
*cs
= &markov_css_buf
[c
];
4000 if (cs
->cs_len
== threshold
) continue;
4002 uint pw_pos
= c
/ CHARSIZ
;
4004 uint key
= markov_table_buf
[i
].key
;
4006 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4008 cs
->cs_buf
[cs
->cs_len
] = key
;
4014 for (uint i = 0; i < 8; i++)
4016 for (uint j = 0x20; j < 0x80; j++)
4018 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4020 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4022 for (uint k = 0; k < 10; k++)
4024 printf (" %u\n", ptr->cs_buf[k]);
4031 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4033 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4035 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4045 for (uint j
= 1; j
< CHARSIZ
; j
++)
4055 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4057 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4059 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4061 out
+= CHARSIZ
* CHARSIZ
;
4062 in
+= CHARSIZ
* CHARSIZ
;
4064 for (uint j
= 0; j
< CHARSIZ
; j
++)
4071 for (uint k
= 1; k
< CHARSIZ
; k
++)
4083 * mixed shared functions
4086 void dump_hex (const u8
*s
, const int sz
)
4088 for (int i
= 0; i
< sz
; i
++)
4090 log_info_nn ("%02x ", s
[i
]);
4096 void usage_mini_print (const char *progname
)
4098 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4101 void usage_big_print (const char *progname
)
4103 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4106 char *get_exec_path ()
4108 int exec_path_len
= 1024;
4110 char *exec_path
= (char *) mymalloc (exec_path_len
);
4114 char tmp
[32] = { 0 };
4116 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4118 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4122 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4126 uint size
= exec_path_len
;
4128 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4130 log_error("! executable path buffer too small\n");
4135 const int len
= strlen (exec_path
);
4138 #error Your Operating System is not supported or detected
4146 char *get_install_dir (const char *progname
)
4148 char *install_dir
= mystrdup (progname
);
4149 char *last_slash
= NULL
;
4151 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4155 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4161 install_dir
[0] = '.';
4165 return (install_dir
);
4168 char *get_profile_dir (const char *homedir
)
4170 #define DOT_HASHCAT ".hashcat"
4172 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4174 char *profile_dir
= (char *) mymalloc (len
+ 1);
4176 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4181 char *get_session_dir (const char *profile_dir
)
4183 #define SESSIONS_FOLDER "sessions"
4185 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4187 char *session_dir
= (char *) mymalloc (len
+ 1);
4189 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4194 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4198 FILE *fd
= fopen (filename
, "rb");
4202 log_error ("%s: %s", filename
, strerror (errno
));
4207 #define MAX_KEY_SIZE (1024 * 1024)
4209 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4211 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4217 for (int fpos
= 0; fpos
< nread
; fpos
++)
4219 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4221 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4222 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4223 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4224 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4226 if (kpos
>= 64) kpos
= 0;
4232 void set_cpu_affinity (char *cpu_affinity
)
4235 DWORD_PTR aff_mask
= 0;
4243 char *devices
= strdup (cpu_affinity
);
4245 char *next
= strtok (devices
, ",");
4249 uint cpu_id
= atoi (next
);
4264 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4270 aff_mask
|= 1 << (cpu_id
- 1);
4272 CPU_SET ((cpu_id
- 1), &cpuset
);
4275 } while ((next
= strtok (NULL
, ",")) != NULL
);
4281 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4282 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4284 pthread_t thread
= pthread_self ();
4285 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4289 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4291 char *element
, *end
;
4293 end
= (char *) base
+ nmemb
* size
;
4295 for (element
= (char *) base
; element
< end
; element
+= size
)
4296 if (!compar (element
, key
))
4302 int sort_by_salt (const void *v1
, const void *v2
)
4304 const salt_t
*s1
= (const salt_t
*) v1
;
4305 const salt_t
*s2
= (const salt_t
*) v2
;
4307 const int res1
= s1
->salt_len
- s2
->salt_len
;
4309 if (res1
!= 0) return (res1
);
4311 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4313 if (res2
!= 0) return (res2
);
4321 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4322 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4329 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4330 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4336 int sort_by_salt_buf (const void *v1
, const void *v2
)
4338 const pot_t
*p1
= (const pot_t
*) v1
;
4339 const pot_t
*p2
= (const pot_t
*) v2
;
4341 const hash_t
*h1
= &p1
->hash
;
4342 const hash_t
*h2
= &p2
->hash
;
4344 const salt_t
*s1
= h1
->salt
;
4345 const salt_t
*s2
= h2
->salt
;
4351 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4352 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4358 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4360 const hash_t
*h1
= (const hash_t
*) v1
;
4361 const hash_t
*h2
= (const hash_t
*) v2
;
4363 const salt_t
*s1
= h1
->salt
;
4364 const salt_t
*s2
= h2
->salt
;
4366 // testphase: this should work
4371 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4372 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4375 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4376 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4377 if (s1->salt_len > s2->salt_len) return ( 1);
4378 if (s1->salt_len < s2->salt_len) return (-1);
4380 uint n = s1->salt_len;
4384 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4385 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4392 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4394 const hash_t
*h1
= (const hash_t
*) v1
;
4395 const hash_t
*h2
= (const hash_t
*) v2
;
4397 const salt_t
*s1
= h1
->salt
;
4398 const salt_t
*s2
= h2
->salt
;
4400 // 12 - 2 (since last 2 uints contain the digest)
4405 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4406 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4412 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4414 const hash_t
*h1
= (const hash_t
*) v1
;
4415 const hash_t
*h2
= (const hash_t
*) v2
;
4417 const void *d1
= h1
->digest
;
4418 const void *d2
= h2
->digest
;
4420 return data
.sort_by_digest (d1
, d2
);
4423 int sort_by_hash (const void *v1
, const void *v2
)
4425 const hash_t
*h1
= (const hash_t
*) v1
;
4426 const hash_t
*h2
= (const hash_t
*) v2
;
4430 const salt_t
*s1
= h1
->salt
;
4431 const salt_t
*s2
= h2
->salt
;
4433 int res
= sort_by_salt (s1
, s2
);
4435 if (res
!= 0) return (res
);
4438 const void *d1
= h1
->digest
;
4439 const void *d2
= h2
->digest
;
4441 return data
.sort_by_digest (d1
, d2
);
4444 int sort_by_pot (const void *v1
, const void *v2
)
4446 const pot_t
*p1
= (const pot_t
*) v1
;
4447 const pot_t
*p2
= (const pot_t
*) v2
;
4449 const hash_t
*h1
= &p1
->hash
;
4450 const hash_t
*h2
= &p2
->hash
;
4452 return sort_by_hash (h1
, h2
);
4455 int sort_by_mtime (const void *p1
, const void *p2
)
4457 const char **f1
= (const char **) p1
;
4458 const char **f2
= (const char **) p2
;
4460 struct stat s1
; stat (*f1
, &s1
);
4461 struct stat s2
; stat (*f2
, &s2
);
4463 return s2
.st_mtime
- s1
.st_mtime
;
4466 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4468 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4469 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4471 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4474 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4476 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4477 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4479 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4482 int sort_by_stringptr (const void *p1
, const void *p2
)
4484 const char **s1
= (const char **) p1
;
4485 const char **s2
= (const char **) p2
;
4487 return strcmp (*s1
, *s2
);
4490 int sort_by_dictstat (const void *s1
, const void *s2
)
4492 dictstat_t
*d1
= (dictstat_t
*) s1
;
4493 dictstat_t
*d2
= (dictstat_t
*) s2
;
4496 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4498 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4501 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4504 int sort_by_bitmap (const void *p1
, const void *p2
)
4506 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4507 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4509 return b1
->collisions
- b2
->collisions
;
4512 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4514 const u32
*d1
= (const u32
*) v1
;
4515 const u32
*d2
= (const u32
*) v2
;
4521 if (d1
[n
] > d2
[n
]) return ( 1);
4522 if (d1
[n
] < d2
[n
]) return (-1);
4528 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4530 const u32
*d1
= (const u32
*) v1
;
4531 const u32
*d2
= (const u32
*) v2
;
4537 if (d1
[n
] > d2
[n
]) return ( 1);
4538 if (d1
[n
] < d2
[n
]) return (-1);
4544 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4546 const u32
*d1
= (const u32
*) v1
;
4547 const u32
*d2
= (const u32
*) v2
;
4553 if (d1
[n
] > d2
[n
]) return ( 1);
4554 if (d1
[n
] < d2
[n
]) return (-1);
4560 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4562 const u32
*d1
= (const u32
*) v1
;
4563 const u32
*d2
= (const u32
*) v2
;
4569 if (d1
[n
] > d2
[n
]) return ( 1);
4570 if (d1
[n
] < d2
[n
]) return (-1);
4576 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4578 const u32
*d1
= (const u32
*) v1
;
4579 const u32
*d2
= (const u32
*) v2
;
4585 if (d1
[n
] > d2
[n
]) return ( 1);
4586 if (d1
[n
] < d2
[n
]) return (-1);
4592 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4594 const u32
*d1
= (const u32
*) v1
;
4595 const u32
*d2
= (const u32
*) v2
;
4601 if (d1
[n
] > d2
[n
]) return ( 1);
4602 if (d1
[n
] < d2
[n
]) return (-1);
4608 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4610 const u32
*d1
= (const u32
*) v1
;
4611 const u32
*d2
= (const u32
*) v2
;
4617 if (d1
[n
] > d2
[n
]) return ( 1);
4618 if (d1
[n
] < d2
[n
]) return (-1);
4624 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4626 const u32
*d1
= (const u32
*) v1
;
4627 const u32
*d2
= (const u32
*) v2
;
4633 if (d1
[n
] > d2
[n
]) return ( 1);
4634 if (d1
[n
] < d2
[n
]) return (-1);
4640 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4642 const u64
*d1
= (const u64
*) v1
;
4643 const u64
*d2
= (const u64
*) v2
;
4649 if (d1
[n
] > d2
[n
]) return ( 1);
4650 if (d1
[n
] < d2
[n
]) return (-1);
4656 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4658 const u64
*d1
= (const u64
*) v1
;
4659 const u64
*d2
= (const u64
*) v2
;
4665 if (d1
[n
] > d2
[n
]) return ( 1);
4666 if (d1
[n
] < d2
[n
]) return (-1);
4672 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4674 const u64
*d1
= (const u64
*) v1
;
4675 const u64
*d2
= (const u64
*) v2
;
4681 if (d1
[n
] > d2
[n
]) return ( 1);
4682 if (d1
[n
] < d2
[n
]) return (-1);
4688 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4690 const u32
*d1
= (const u32
*) v1
;
4691 const u32
*d2
= (const u32
*) v2
;
4693 const uint dgst_pos0
= data
.dgst_pos0
;
4694 const uint dgst_pos1
= data
.dgst_pos1
;
4695 const uint dgst_pos2
= data
.dgst_pos2
;
4696 const uint dgst_pos3
= data
.dgst_pos3
;
4698 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4699 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4700 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4701 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4702 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4703 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4704 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4705 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4710 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
)
4712 uint outfile_autohex
= data
.outfile_autohex
;
4714 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4716 FILE *debug_fp
= NULL
;
4718 if (debug_file
!= NULL
)
4720 debug_fp
= fopen (debug_file
, "ab");
4722 lock_file (debug_fp
);
4729 if (debug_fp
== NULL
)
4731 log_info ("WARNING: Could not open debug-file for writing");
4735 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4737 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4739 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4742 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4744 if (debug_mode
== 4)
4746 fputc (':', debug_fp
);
4748 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4751 fputc ('\n', debug_fp
);
4753 if (debug_file
!= NULL
) fclose (debug_fp
);
4757 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4759 int needs_hexify
= 0;
4761 if (outfile_autohex
== 1)
4763 for (uint i
= 0; i
< plain_len
; i
++)
4765 if (plain_ptr
[i
] < 0x20)
4772 if (plain_ptr
[i
] > 0x7f)
4781 if (needs_hexify
== 1)
4783 fprintf (fp
, "$HEX[");
4785 for (uint i
= 0; i
< plain_len
; i
++)
4787 fprintf (fp
, "%02x", plain_ptr
[i
]);
4794 fwrite (plain_ptr
, plain_len
, 1, fp
);
4798 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
)
4800 uint outfile_format
= data
.outfile_format
;
4802 char separator
= data
.separator
;
4804 if (outfile_format
& OUTFILE_FMT_HASH
)
4806 fprintf (out_fp
, "%s", out_buf
);
4808 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4810 fputc (separator
, out_fp
);
4813 else if (data
.username
)
4815 if (username
!= NULL
)
4817 for (uint i
= 0; i
< user_len
; i
++)
4819 fprintf (out_fp
, "%c", username
[i
]);
4822 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4824 fputc (separator
, out_fp
);
4829 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4831 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4833 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4835 fputc (separator
, out_fp
);
4839 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4841 for (uint i
= 0; i
< plain_len
; i
++)
4843 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4846 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4848 fputc (separator
, out_fp
);
4852 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4855 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4860 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4862 fprintf (out_fp
, "%llu", crackpos
);
4867 fputc ('\n', out_fp
);
4870 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
)
4874 pot_key
.hash
.salt
= hashes_buf
->salt
;
4875 pot_key
.hash
.digest
= hashes_buf
->digest
;
4877 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4883 input_buf
[input_len
] = 0;
4886 unsigned char *username
= NULL
;
4891 user_t
*user
= hashes_buf
->hash_info
->user
;
4895 username
= (unsigned char *) (user
->user_name
);
4897 user_len
= user
->user_len
;
4901 // do output the line
4902 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4906 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4907 #define LM_MASKED_PLAIN "[notfound]"
4909 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
)
4915 pot_left_key
.hash
.salt
= hash_left
->salt
;
4916 pot_left_key
.hash
.digest
= hash_left
->digest
;
4918 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4922 uint weak_hash_found
= 0;
4924 pot_t pot_right_key
;
4926 pot_right_key
.hash
.salt
= hash_right
->salt
;
4927 pot_right_key
.hash
.digest
= hash_right
->digest
;
4929 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4931 if (pot_right_ptr
== NULL
)
4933 // special case, if "weak hash"
4935 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4937 weak_hash_found
= 1;
4939 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4941 // in theory this is not needed, but we are paranoia:
4943 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4944 pot_right_ptr
->plain_len
= 0;
4948 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4950 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
4955 // at least one half was found:
4959 input_buf
[input_len
] = 0;
4963 unsigned char *username
= NULL
;
4968 user_t
*user
= hash_left
->hash_info
->user
;
4972 username
= (unsigned char *) (user
->user_name
);
4974 user_len
= user
->user_len
;
4978 // mask the part which was not found
4980 uint left_part_masked
= 0;
4981 uint right_part_masked
= 0;
4983 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
4985 if (pot_left_ptr
== NULL
)
4987 left_part_masked
= 1;
4989 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4991 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
4993 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4994 pot_left_ptr
->plain_len
= mask_plain_len
;
4997 if (pot_right_ptr
== NULL
)
4999 right_part_masked
= 1;
5001 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5003 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5005 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5006 pot_right_ptr
->plain_len
= mask_plain_len
;
5009 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5013 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5015 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5017 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5019 // do output the line
5021 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5023 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5025 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5026 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5029 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
)
5033 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5035 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5037 if (pot_ptr
== NULL
)
5041 input_buf
[input_len
] = 0;
5043 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5047 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
)
5053 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5055 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5059 pot_t pot_right_key
;
5061 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5063 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5065 uint weak_hash_found
= 0;
5067 if (pot_right_ptr
== NULL
)
5069 // special case, if "weak hash"
5071 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5073 weak_hash_found
= 1;
5075 // we just need that pot_right_ptr is not a NULL pointer
5077 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5081 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5083 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5088 // ... at least one part was not cracked
5092 input_buf
[input_len
] = 0;
5094 // only show the hash part which is still not cracked
5096 uint user_len
= input_len
- 32;
5098 char *hash_output
= (char *) mymalloc (33);
5100 memcpy (hash_output
, input_buf
, input_len
);
5102 if (pot_left_ptr
!= NULL
)
5104 // only show right part (because left part was already found)
5106 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5108 hash_output
[user_len
+ 16] = 0;
5111 if (pot_right_ptr
!= NULL
)
5113 // only show left part (because right part was already found)
5115 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5117 hash_output
[user_len
+ 16] = 0;
5120 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5122 myfree (hash_output
);
5124 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5127 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5129 uint opencl_platforms_filter
= 0;
5131 if (opencl_platforms
)
5133 char *platforms
= strdup (opencl_platforms
);
5135 char *next
= strtok (platforms
, ",");
5139 int platform
= atoi (next
);
5141 if (platform
< 1 || platform
> 32)
5143 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5148 opencl_platforms_filter
|= 1 << (platform
- 1);
5150 } while ((next
= strtok (NULL
, ",")) != NULL
);
5156 opencl_platforms_filter
= -1;
5159 return opencl_platforms_filter
;
5162 u32
setup_devices_filter (char *opencl_devices
)
5164 u32 devices_filter
= 0;
5168 char *devices
= strdup (opencl_devices
);
5170 char *next
= strtok (devices
, ",");
5174 int device_id
= atoi (next
);
5176 if (device_id
< 1 || device_id
> 32)
5178 log_error ("ERROR: invalid device_id %u specified", device_id
);
5183 devices_filter
|= 1 << (device_id
- 1);
5185 } while ((next
= strtok (NULL
, ",")) != NULL
);
5191 devices_filter
= -1;
5194 return devices_filter
;
5197 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5199 cl_device_type device_types_filter
= 0;
5201 if (opencl_device_types
)
5203 char *device_types
= strdup (opencl_device_types
);
5205 char *next
= strtok (device_types
, ",");
5209 int device_type
= atoi (next
);
5211 if (device_type
< 1 || device_type
> 3)
5213 log_error ("ERROR: invalid device_type %u specified", device_type
);
5218 device_types_filter
|= 1 << device_type
;
5220 } while ((next
= strtok (NULL
, ",")) != NULL
);
5222 free (device_types
);
5226 // Do not use CPU by default, this often reduces GPU performance because
5227 // the CPU is too busy to handle GPU synchronization
5229 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5232 return device_types_filter
;
5235 u32
get_random_num (const u32 min
, const u32 max
)
5237 if (min
== max
) return (min
);
5239 return ((rand () % (max
- min
)) + min
);
5242 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5244 u32 quotient
= dividend
/ divisor
;
5246 if (dividend
% divisor
) quotient
++;
5251 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5253 u64 quotient
= dividend
/ divisor
;
5255 if (dividend
% divisor
) quotient
++;
5260 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5262 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5263 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5265 if (tm
->tm_year
- 70)
5267 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5268 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5270 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5272 else if (tm
->tm_yday
)
5274 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5275 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5277 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5279 else if (tm
->tm_hour
)
5281 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5282 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5284 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5286 else if (tm
->tm_min
)
5288 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5289 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5291 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5295 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5297 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5301 void format_speed_display (float val
, char *buf
, size_t len
)
5312 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5323 /* generate output */
5327 snprintf (buf
, len
- 1, "%.0f ", val
);
5331 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5335 void lowercase (u8
*buf
, int len
)
5337 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5340 void uppercase (u8
*buf
, int len
)
5342 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5345 int fgetl (FILE *fp
, char *line_buf
)
5351 const int c
= fgetc (fp
);
5353 if (c
== EOF
) break;
5355 line_buf
[line_len
] = (char) c
;
5359 if (line_len
== BUFSIZ
) line_len
--;
5361 if (c
== '\n') break;
5364 if (line_len
== 0) return 0;
5366 if (line_buf
[line_len
- 1] == '\n')
5370 line_buf
[line_len
] = 0;
5373 if (line_len
== 0) return 0;
5375 if (line_buf
[line_len
- 1] == '\r')
5379 line_buf
[line_len
] = 0;
5385 int in_superchop (char *buf
)
5387 int len
= strlen (buf
);
5391 if (buf
[len
- 1] == '\n')
5398 if (buf
[len
- 1] == '\r')
5413 char **scan_directory (const char *path
)
5415 char *tmp_path
= mystrdup (path
);
5417 size_t tmp_path_len
= strlen (tmp_path
);
5419 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5421 tmp_path
[tmp_path_len
- 1] = 0;
5423 tmp_path_len
= strlen (tmp_path
);
5426 char **files
= NULL
;
5432 if ((d
= opendir (tmp_path
)) != NULL
)
5438 memset (&e
, 0, sizeof (e
));
5439 struct dirent
*de
= NULL
;
5441 if (readdir_r (d
, &e
, &de
) != 0)
5443 log_error ("ERROR: readdir_r() failed");
5448 if (de
== NULL
) break;
5452 while ((de
= readdir (d
)) != NULL
)
5455 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5457 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5459 char *path_file
= (char *) mymalloc (path_size
+ 1);
5461 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5463 path_file
[path_size
] = 0;
5467 if ((d_test
= opendir (path_file
)) != NULL
)
5475 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5479 files
[num_files
- 1] = path_file
;
5485 else if (errno
== ENOTDIR
)
5487 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5491 files
[num_files
- 1] = mystrdup (path
);
5494 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5498 files
[num_files
- 1] = NULL
;
5505 int count_dictionaries (char **dictionary_files
)
5507 if (dictionary_files
== NULL
) return 0;
5511 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5519 char *stroptitype (const uint opti_type
)
5523 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5524 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5525 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5526 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5527 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5528 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5529 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5530 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5531 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5532 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5533 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5534 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5535 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5536 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5542 char *strparser (const uint parser_status
)
5544 switch (parser_status
)
5546 case PARSER_OK
: return ((char *) PA_000
); break;
5547 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5548 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5549 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5550 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5551 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5552 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5553 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5554 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5555 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5556 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5557 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5558 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5559 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5560 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5561 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5562 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5565 return ((char *) PA_255
);
5568 char *strhashtype (const uint hash_mode
)
5572 case 0: return ((char *) HT_00000
); break;
5573 case 10: return ((char *) HT_00010
); break;
5574 case 11: return ((char *) HT_00011
); break;
5575 case 12: return ((char *) HT_00012
); break;
5576 case 20: return ((char *) HT_00020
); break;
5577 case 21: return ((char *) HT_00021
); break;
5578 case 22: return ((char *) HT_00022
); break;
5579 case 23: return ((char *) HT_00023
); break;
5580 case 30: return ((char *) HT_00030
); break;
5581 case 40: return ((char *) HT_00040
); break;
5582 case 50: return ((char *) HT_00050
); break;
5583 case 60: return ((char *) HT_00060
); break;
5584 case 100: return ((char *) HT_00100
); break;
5585 case 101: return ((char *) HT_00101
); break;
5586 case 110: return ((char *) HT_00110
); break;
5587 case 111: return ((char *) HT_00111
); break;
5588 case 112: return ((char *) HT_00112
); break;
5589 case 120: return ((char *) HT_00120
); break;
5590 case 121: return ((char *) HT_00121
); break;
5591 case 122: return ((char *) HT_00122
); break;
5592 case 124: return ((char *) HT_00124
); break;
5593 case 130: return ((char *) HT_00130
); break;
5594 case 131: return ((char *) HT_00131
); break;
5595 case 132: return ((char *) HT_00132
); break;
5596 case 133: return ((char *) HT_00133
); break;
5597 case 140: return ((char *) HT_00140
); break;
5598 case 141: return ((char *) HT_00141
); break;
5599 case 150: return ((char *) HT_00150
); break;
5600 case 160: return ((char *) HT_00160
); break;
5601 case 190: return ((char *) HT_00190
); break;
5602 case 200: return ((char *) HT_00200
); break;
5603 case 300: return ((char *) HT_00300
); break;
5604 case 400: return ((char *) HT_00400
); break;
5605 case 500: return ((char *) HT_00500
); break;
5606 case 501: return ((char *) HT_00501
); break;
5607 case 900: return ((char *) HT_00900
); break;
5608 case 910: return ((char *) HT_00910
); break;
5609 case 1000: return ((char *) HT_01000
); break;
5610 case 1100: return ((char *) HT_01100
); break;
5611 case 1400: return ((char *) HT_01400
); break;
5612 case 1410: return ((char *) HT_01410
); break;
5613 case 1420: return ((char *) HT_01420
); break;
5614 case 1421: return ((char *) HT_01421
); break;
5615 case 1430: return ((char *) HT_01430
); break;
5616 case 1440: return ((char *) HT_01440
); break;
5617 case 1441: return ((char *) HT_01441
); break;
5618 case 1450: return ((char *) HT_01450
); break;
5619 case 1460: return ((char *) HT_01460
); break;
5620 case 1500: return ((char *) HT_01500
); break;
5621 case 1600: return ((char *) HT_01600
); break;
5622 case 1700: return ((char *) HT_01700
); break;
5623 case 1710: return ((char *) HT_01710
); break;
5624 case 1711: return ((char *) HT_01711
); break;
5625 case 1720: return ((char *) HT_01720
); break;
5626 case 1722: return ((char *) HT_01722
); break;
5627 case 1730: return ((char *) HT_01730
); break;
5628 case 1731: return ((char *) HT_01731
); break;
5629 case 1740: return ((char *) HT_01740
); break;
5630 case 1750: return ((char *) HT_01750
); break;
5631 case 1760: return ((char *) HT_01760
); break;
5632 case 1800: return ((char *) HT_01800
); break;
5633 case 2100: return ((char *) HT_02100
); break;
5634 case 2400: return ((char *) HT_02400
); break;
5635 case 2410: return ((char *) HT_02410
); break;
5636 case 2500: return ((char *) HT_02500
); break;
5637 case 2600: return ((char *) HT_02600
); break;
5638 case 2611: return ((char *) HT_02611
); break;
5639 case 2612: return ((char *) HT_02612
); break;
5640 case 2711: return ((char *) HT_02711
); break;
5641 case 2811: return ((char *) HT_02811
); break;
5642 case 3000: return ((char *) HT_03000
); break;
5643 case 3100: return ((char *) HT_03100
); break;
5644 case 3200: return ((char *) HT_03200
); break;
5645 case 3710: return ((char *) HT_03710
); break;
5646 case 3711: return ((char *) HT_03711
); break;
5647 case 3800: return ((char *) HT_03800
); break;
5648 case 4300: return ((char *) HT_04300
); break;
5649 case 4400: return ((char *) HT_04400
); break;
5650 case 4500: return ((char *) HT_04500
); break;
5651 case 4700: return ((char *) HT_04700
); break;
5652 case 4800: return ((char *) HT_04800
); break;
5653 case 4900: return ((char *) HT_04900
); break;
5654 case 5000: return ((char *) HT_05000
); break;
5655 case 5100: return ((char *) HT_05100
); break;
5656 case 5200: return ((char *) HT_05200
); break;
5657 case 5300: return ((char *) HT_05300
); break;
5658 case 5400: return ((char *) HT_05400
); break;
5659 case 5500: return ((char *) HT_05500
); break;
5660 case 5600: return ((char *) HT_05600
); break;
5661 case 5700: return ((char *) HT_05700
); break;
5662 case 5800: return ((char *) HT_05800
); break;
5663 case 6000: return ((char *) HT_06000
); break;
5664 case 6100: return ((char *) HT_06100
); break;
5665 case 6211: return ((char *) HT_06211
); break;
5666 case 6212: return ((char *) HT_06212
); break;
5667 case 6213: return ((char *) HT_06213
); break;
5668 case 6221: return ((char *) HT_06221
); break;
5669 case 6222: return ((char *) HT_06222
); break;
5670 case 6223: return ((char *) HT_06223
); break;
5671 case 6231: return ((char *) HT_06231
); break;
5672 case 6232: return ((char *) HT_06232
); break;
5673 case 6233: return ((char *) HT_06233
); break;
5674 case 6241: return ((char *) HT_06241
); break;
5675 case 6242: return ((char *) HT_06242
); break;
5676 case 6243: return ((char *) HT_06243
); break;
5677 case 6300: return ((char *) HT_06300
); break;
5678 case 6400: return ((char *) HT_06400
); break;
5679 case 6500: return ((char *) HT_06500
); break;
5680 case 6600: return ((char *) HT_06600
); break;
5681 case 6700: return ((char *) HT_06700
); break;
5682 case 6800: return ((char *) HT_06800
); break;
5683 case 6900: return ((char *) HT_06900
); break;
5684 case 7100: return ((char *) HT_07100
); break;
5685 case 7200: return ((char *) HT_07200
); break;
5686 case 7300: return ((char *) HT_07300
); break;
5687 case 7400: return ((char *) HT_07400
); break;
5688 case 7500: return ((char *) HT_07500
); break;
5689 case 7600: return ((char *) HT_07600
); break;
5690 case 7700: return ((char *) HT_07700
); break;
5691 case 7800: return ((char *) HT_07800
); break;
5692 case 7900: return ((char *) HT_07900
); break;
5693 case 8000: return ((char *) HT_08000
); break;
5694 case 8100: return ((char *) HT_08100
); break;
5695 case 8200: return ((char *) HT_08200
); break;
5696 case 8300: return ((char *) HT_08300
); break;
5697 case 8400: return ((char *) HT_08400
); break;
5698 case 8500: return ((char *) HT_08500
); break;
5699 case 8600: return ((char *) HT_08600
); break;
5700 case 8700: return ((char *) HT_08700
); break;
5701 case 8800: return ((char *) HT_08800
); break;
5702 case 8900: return ((char *) HT_08900
); break;
5703 case 9000: return ((char *) HT_09000
); break;
5704 case 9100: return ((char *) HT_09100
); break;
5705 case 9200: return ((char *) HT_09200
); break;
5706 case 9300: return ((char *) HT_09300
); break;
5707 case 9400: return ((char *) HT_09400
); break;
5708 case 9500: return ((char *) HT_09500
); break;
5709 case 9600: return ((char *) HT_09600
); break;
5710 case 9700: return ((char *) HT_09700
); break;
5711 case 9710: return ((char *) HT_09710
); break;
5712 case 9720: return ((char *) HT_09720
); break;
5713 case 9800: return ((char *) HT_09800
); break;
5714 case 9810: return ((char *) HT_09810
); break;
5715 case 9820: return ((char *) HT_09820
); break;
5716 case 9900: return ((char *) HT_09900
); break;
5717 case 10000: return ((char *) HT_10000
); break;
5718 case 10100: return ((char *) HT_10100
); break;
5719 case 10200: return ((char *) HT_10200
); break;
5720 case 10300: return ((char *) HT_10300
); break;
5721 case 10400: return ((char *) HT_10400
); break;
5722 case 10410: return ((char *) HT_10410
); break;
5723 case 10420: return ((char *) HT_10420
); break;
5724 case 10500: return ((char *) HT_10500
); break;
5725 case 10600: return ((char *) HT_10600
); break;
5726 case 10700: return ((char *) HT_10700
); break;
5727 case 10800: return ((char *) HT_10800
); break;
5728 case 10900: return ((char *) HT_10900
); break;
5729 case 11000: return ((char *) HT_11000
); break;
5730 case 11100: return ((char *) HT_11100
); break;
5731 case 11200: return ((char *) HT_11200
); break;
5732 case 11300: return ((char *) HT_11300
); break;
5733 case 11400: return ((char *) HT_11400
); break;
5734 case 11500: return ((char *) HT_11500
); break;
5735 case 11600: return ((char *) HT_11600
); break;
5736 case 11700: return ((char *) HT_11700
); break;
5737 case 11800: return ((char *) HT_11800
); break;
5738 case 11900: return ((char *) HT_11900
); break;
5739 case 12000: return ((char *) HT_12000
); break;
5740 case 12100: return ((char *) HT_12100
); break;
5741 case 12200: return ((char *) HT_12200
); break;
5742 case 12300: return ((char *) HT_12300
); break;
5743 case 12400: return ((char *) HT_12400
); break;
5744 case 12500: return ((char *) HT_12500
); break;
5745 case 12600: return ((char *) HT_12600
); break;
5746 case 12700: return ((char *) HT_12700
); break;
5747 case 12800: return ((char *) HT_12800
); break;
5748 case 12900: return ((char *) HT_12900
); break;
5749 case 13000: return ((char *) HT_13000
); break;
5752 return ((char *) "Unknown");
5755 char *strstatus (const uint devices_status
)
5757 switch (devices_status
)
5759 case STATUS_INIT
: return ((char *) ST_0000
); break;
5760 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5761 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5762 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5763 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5764 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5765 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5766 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5767 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5768 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5771 return ((char *) "Unknown");
5774 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5776 uint hash_type
= data
.hash_type
;
5777 uint hash_mode
= data
.hash_mode
;
5778 uint salt_type
= data
.salt_type
;
5779 uint opts_type
= data
.opts_type
;
5780 uint opti_type
= data
.opti_type
;
5781 uint dgst_size
= data
.dgst_size
;
5783 char *hashfile
= data
.hashfile
;
5787 uint digest_buf
[64] = { 0 };
5789 u64
*digest_buf64
= (u64
*) digest_buf
;
5791 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5793 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5795 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5801 case HASH_TYPE_DESCRYPT
:
5802 FP (digest_buf
[1], digest_buf
[0], tt
);
5805 case HASH_TYPE_DESRACF
:
5806 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5807 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5809 FP (digest_buf
[1], digest_buf
[0], tt
);
5813 FP (digest_buf
[1], digest_buf
[0], tt
);
5816 case HASH_TYPE_NETNTLM
:
5817 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5818 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5819 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5820 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5822 FP (digest_buf
[1], digest_buf
[0], tt
);
5823 FP (digest_buf
[3], digest_buf
[2], tt
);
5826 case HASH_TYPE_BSDICRYPT
:
5827 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5828 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5830 FP (digest_buf
[1], digest_buf
[0], tt
);
5835 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5840 digest_buf
[0] += MD4M_A
;
5841 digest_buf
[1] += MD4M_B
;
5842 digest_buf
[2] += MD4M_C
;
5843 digest_buf
[3] += MD4M_D
;
5847 digest_buf
[0] += MD5M_A
;
5848 digest_buf
[1] += MD5M_B
;
5849 digest_buf
[2] += MD5M_C
;
5850 digest_buf
[3] += MD5M_D
;
5853 case HASH_TYPE_SHA1
:
5854 digest_buf
[0] += SHA1M_A
;
5855 digest_buf
[1] += SHA1M_B
;
5856 digest_buf
[2] += SHA1M_C
;
5857 digest_buf
[3] += SHA1M_D
;
5858 digest_buf
[4] += SHA1M_E
;
5861 case HASH_TYPE_SHA256
:
5862 digest_buf
[0] += SHA256M_A
;
5863 digest_buf
[1] += SHA256M_B
;
5864 digest_buf
[2] += SHA256M_C
;
5865 digest_buf
[3] += SHA256M_D
;
5866 digest_buf
[4] += SHA256M_E
;
5867 digest_buf
[5] += SHA256M_F
;
5868 digest_buf
[6] += SHA256M_G
;
5869 digest_buf
[7] += SHA256M_H
;
5872 case HASH_TYPE_SHA384
:
5873 digest_buf64
[0] += SHA384M_A
;
5874 digest_buf64
[1] += SHA384M_B
;
5875 digest_buf64
[2] += SHA384M_C
;
5876 digest_buf64
[3] += SHA384M_D
;
5877 digest_buf64
[4] += SHA384M_E
;
5878 digest_buf64
[5] += SHA384M_F
;
5879 digest_buf64
[6] += 0;
5880 digest_buf64
[7] += 0;
5883 case HASH_TYPE_SHA512
:
5884 digest_buf64
[0] += SHA512M_A
;
5885 digest_buf64
[1] += SHA512M_B
;
5886 digest_buf64
[2] += SHA512M_C
;
5887 digest_buf64
[3] += SHA512M_D
;
5888 digest_buf64
[4] += SHA512M_E
;
5889 digest_buf64
[5] += SHA512M_F
;
5890 digest_buf64
[6] += SHA512M_G
;
5891 digest_buf64
[7] += SHA512M_H
;
5896 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5898 if (dgst_size
== DGST_SIZE_4_2
)
5900 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5902 else if (dgst_size
== DGST_SIZE_4_4
)
5904 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5906 else if (dgst_size
== DGST_SIZE_4_5
)
5908 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5910 else if (dgst_size
== DGST_SIZE_4_6
)
5912 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5914 else if (dgst_size
== DGST_SIZE_4_8
)
5916 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5918 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5920 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5922 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5924 else if (hash_type
== HASH_TYPE_SHA384
)
5926 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5928 else if (hash_type
== HASH_TYPE_SHA512
)
5930 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5932 else if (hash_type
== HASH_TYPE_GOST
)
5934 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5937 else if (dgst_size
== DGST_SIZE_4_64
)
5939 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5941 else if (dgst_size
== DGST_SIZE_8_25
)
5943 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5947 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5948 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5949 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5955 memset (&salt
, 0, sizeof (salt_t
));
5957 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5959 char *ptr
= (char *) salt
.salt_buf
;
5961 uint len
= salt
.salt_len
;
5963 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5969 case HASH_TYPE_NETNTLM
:
5971 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
5972 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
5974 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5980 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5982 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5990 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
5992 uint max
= salt
.salt_len
/ 4;
5996 for (uint i
= 0; i
< max
; i
++)
5998 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6002 if (opts_type
& OPTS_TYPE_ST_HEX
)
6004 char tmp
[64] = { 0 };
6006 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6008 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6013 memcpy (ptr
, tmp
, len
);
6016 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6018 memset (ptr
+ len
, 0, memset_size
);
6020 salt
.salt_len
= len
;
6024 // some modes require special encoding
6027 uint out_buf_plain
[256] = { 0 };
6028 uint out_buf_salt
[256] = { 0 };
6030 char tmp_buf
[1024] = { 0 };
6032 char *ptr_plain
= (char *) out_buf_plain
;
6033 char *ptr_salt
= (char *) out_buf_salt
;
6035 if (hash_mode
== 22)
6037 char username
[30] = { 0 };
6039 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6041 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6043 u16
*ptr
= (u16
*) digest_buf
;
6045 tmp_buf
[ 0] = sig
[0];
6046 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6047 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6048 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6049 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6050 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6051 tmp_buf
[ 6] = sig
[1];
6052 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6053 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6054 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6055 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6056 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6057 tmp_buf
[12] = sig
[2];
6058 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6059 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6060 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6061 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6062 tmp_buf
[17] = sig
[3];
6063 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6064 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6065 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6066 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6067 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6068 tmp_buf
[23] = sig
[4];
6069 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6070 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6071 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6072 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6073 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6074 tmp_buf
[29] = sig
[5];
6076 snprintf (out_buf
, len
-1, "%s:%s",
6080 else if (hash_mode
== 23)
6082 // do not show the \nskyper\n part in output
6084 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6086 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6088 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6095 else if (hash_mode
== 101)
6097 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6099 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6100 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6101 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6102 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6103 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6105 memcpy (tmp_buf
, digest_buf
, 20);
6107 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6109 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6111 else if (hash_mode
== 111)
6113 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6115 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6116 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6117 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6118 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6119 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6121 memcpy (tmp_buf
, digest_buf
, 20);
6122 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6124 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6126 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6128 else if (hash_mode
== 122)
6130 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6131 (char *) salt
.salt_buf
,
6138 else if (hash_mode
== 124)
6140 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6141 (char *) salt
.salt_buf
,
6148 else if (hash_mode
== 131)
6150 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6151 (char *) salt
.salt_buf
,
6159 else if (hash_mode
== 132)
6161 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6162 (char *) salt
.salt_buf
,
6169 else if (hash_mode
== 133)
6171 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6173 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6174 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6175 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6176 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6177 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6179 memcpy (tmp_buf
, digest_buf
, 20);
6181 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6183 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6185 else if (hash_mode
== 141)
6187 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6189 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6191 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6193 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6195 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6196 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6197 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6198 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6199 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6201 memcpy (tmp_buf
, digest_buf
, 20);
6203 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6207 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6209 else if (hash_mode
== 400)
6211 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6213 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6214 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6215 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6216 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6218 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6220 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6222 else if (hash_mode
== 500)
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 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6233 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6235 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6239 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6242 else if (hash_mode
== 501)
6244 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6246 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6247 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6249 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6251 else if (hash_mode
== 1421)
6253 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6255 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6271 else if (hash_mode
== 1441)
6273 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6275 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6277 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6279 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6281 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6282 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6283 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6284 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6285 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6286 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6287 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6288 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6290 memcpy (tmp_buf
, digest_buf
, 32);
6292 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6296 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6298 else if (hash_mode
== 1500)
6300 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6301 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6302 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6303 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6304 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6306 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6308 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6310 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6311 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6313 memcpy (tmp_buf
, digest_buf
, 8);
6315 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6317 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6321 else if (hash_mode
== 1600)
6323 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6325 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6326 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6327 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6328 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6330 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6332 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6334 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6338 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6341 else if (hash_mode
== 1711)
6343 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6345 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6346 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6347 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6348 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6349 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6350 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6351 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6352 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6354 memcpy (tmp_buf
, digest_buf
, 64);
6355 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6357 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6359 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6361 else if (hash_mode
== 1722)
6363 uint
*ptr
= digest_buf
;
6365 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6366 (unsigned char *) salt
.salt_buf
,
6376 else if (hash_mode
== 1731)
6378 uint
*ptr
= digest_buf
;
6380 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6381 (unsigned char *) salt
.salt_buf
,
6391 else if (hash_mode
== 1800)
6395 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6396 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6397 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6398 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6399 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6400 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6401 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6402 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6404 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6406 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6408 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6412 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6415 else if (hash_mode
== 2100)
6419 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6421 salt
.salt_iter
+ 1);
6423 uint signature_len
= strlen (out_buf
);
6425 pos
+= signature_len
;
6426 len
-= signature_len
;
6428 char *salt_ptr
= (char *) salt
.salt_buf
;
6430 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6432 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6433 byte_swap_32 (digest_buf
[0]),
6434 byte_swap_32 (digest_buf
[1]),
6435 byte_swap_32 (digest_buf
[2]),
6436 byte_swap_32 (digest_buf
[3]));
6438 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6440 memcpy (tmp_buf
, digest_buf
, 16);
6442 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6444 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6445 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6446 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6447 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6449 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6450 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6451 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6452 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6454 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6455 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6456 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6457 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6459 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6460 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6461 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6462 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6464 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6465 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6466 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6467 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6471 else if (hash_mode
== 2500)
6473 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6475 wpa_t
*wpa
= &wpas
[salt_pos
];
6477 uint pke
[25] = { 0 };
6479 char *pke_ptr
= (char *) pke
;
6481 for (uint i
= 0; i
< 25; i
++)
6483 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6486 unsigned char mac1
[6] = { 0 };
6487 unsigned char mac2
[6] = { 0 };
6489 memcpy (mac1
, pke_ptr
+ 23, 6);
6490 memcpy (mac2
, pke_ptr
+ 29, 6);
6492 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6493 (char *) salt
.salt_buf
,
6507 else if (hash_mode
== 4400)
6509 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6510 byte_swap_32 (digest_buf
[0]),
6511 byte_swap_32 (digest_buf
[1]),
6512 byte_swap_32 (digest_buf
[2]),
6513 byte_swap_32 (digest_buf
[3]));
6515 else if (hash_mode
== 4700)
6517 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6518 byte_swap_32 (digest_buf
[0]),
6519 byte_swap_32 (digest_buf
[1]),
6520 byte_swap_32 (digest_buf
[2]),
6521 byte_swap_32 (digest_buf
[3]),
6522 byte_swap_32 (digest_buf
[4]));
6524 else if (hash_mode
== 4800)
6526 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6528 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6533 byte_swap_32 (salt
.salt_buf
[0]),
6534 byte_swap_32 (salt
.salt_buf
[1]),
6535 byte_swap_32 (salt
.salt_buf
[2]),
6536 byte_swap_32 (salt
.salt_buf
[3]),
6539 else if (hash_mode
== 4900)
6541 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6542 byte_swap_32 (digest_buf
[0]),
6543 byte_swap_32 (digest_buf
[1]),
6544 byte_swap_32 (digest_buf
[2]),
6545 byte_swap_32 (digest_buf
[3]),
6546 byte_swap_32 (digest_buf
[4]));
6548 else if (hash_mode
== 5100)
6550 snprintf (out_buf
, len
-1, "%08x%08x",
6554 else if (hash_mode
== 5200)
6556 snprintf (out_buf
, len
-1, "%s", hashfile
);
6558 else if (hash_mode
== 5300)
6560 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6562 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6564 int buf_len
= len
-1;
6568 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6570 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6572 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6574 snprintf (out_buf
, buf_len
, ":");
6580 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6588 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6590 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6592 if ((i
== 0) || (i
== 5))
6594 snprintf (out_buf
, buf_len
, ":");
6600 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6608 for (uint i
= 0; i
< 4; i
++)
6612 snprintf (out_buf
, buf_len
, ":");
6618 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6624 else if (hash_mode
== 5400)
6626 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6628 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6630 int buf_len
= len
-1;
6634 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6636 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6638 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6640 snprintf (out_buf
, buf_len
, ":");
6646 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6654 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6656 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6658 if ((i
== 0) || (i
== 5))
6660 snprintf (out_buf
, buf_len
, ":");
6666 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6674 for (uint i
= 0; i
< 5; i
++)
6678 snprintf (out_buf
, buf_len
, ":");
6684 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6690 else if (hash_mode
== 5500)
6692 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6694 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6696 char user_buf
[64] = { 0 };
6697 char domain_buf
[64] = { 0 };
6698 char srvchall_buf
[1024] = { 0 };
6699 char clichall_buf
[1024] = { 0 };
6701 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6703 char *ptr
= (char *) netntlm
->userdomain_buf
;
6705 user_buf
[i
] = ptr
[j
];
6708 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6710 char *ptr
= (char *) netntlm
->userdomain_buf
;
6712 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6715 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6717 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6719 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6722 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6724 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6726 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6729 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6737 byte_swap_32 (salt
.salt_buf_pc
[0]),
6738 byte_swap_32 (salt
.salt_buf_pc
[1]),
6741 else if (hash_mode
== 5600)
6743 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6745 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6747 char user_buf
[64] = { 0 };
6748 char domain_buf
[64] = { 0 };
6749 char srvchall_buf
[1024] = { 0 };
6750 char clichall_buf
[1024] = { 0 };
6752 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6754 char *ptr
= (char *) netntlm
->userdomain_buf
;
6756 user_buf
[i
] = ptr
[j
];
6759 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6761 char *ptr
= (char *) netntlm
->userdomain_buf
;
6763 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6766 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6768 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6770 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6773 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6775 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6777 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6780 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6790 else if (hash_mode
== 5700)
6792 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6794 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6795 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6796 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6797 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6798 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6799 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6800 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6801 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6803 memcpy (tmp_buf
, digest_buf
, 32);
6805 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6809 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6811 else if (hash_mode
== 5800)
6813 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6814 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6815 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6816 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6817 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6819 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6826 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6828 snprintf (out_buf
, len
-1, "%s", hashfile
);
6830 else if (hash_mode
== 6300)
6832 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6834 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6835 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6836 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6837 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6839 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6841 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6843 else if (hash_mode
== 6400)
6845 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6847 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6849 else if (hash_mode
== 6500)
6851 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6853 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6855 else if (hash_mode
== 6600)
6857 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6859 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6861 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6862 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6864 uint buf_len
= len
- 1;
6866 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6869 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6871 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6876 else if (hash_mode
== 6700)
6878 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6880 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6882 else if (hash_mode
== 6800)
6884 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6886 else if (hash_mode
== 7100)
6888 uint
*ptr
= digest_buf
;
6890 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6892 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6894 uint esalt
[8] = { 0 };
6896 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6897 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6898 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6899 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6900 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6901 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6902 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6903 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6905 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",
6906 SIGNATURE_SHA512OSX
,
6908 esalt
[ 0], esalt
[ 1],
6909 esalt
[ 2], esalt
[ 3],
6910 esalt
[ 4], esalt
[ 5],
6911 esalt
[ 6], esalt
[ 7],
6919 ptr
[15], ptr
[14]);
6921 else if (hash_mode
== 7200)
6923 uint
*ptr
= digest_buf
;
6925 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6927 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6931 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6933 len_used
= strlen (out_buf
);
6935 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6937 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6939 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6942 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",
6950 ptr
[15], ptr
[14]);
6952 else if (hash_mode
== 7300)
6954 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6956 rakp_t
*rakp
= &rakps
[salt_pos
];
6958 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6960 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6963 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6970 else if (hash_mode
== 7400)
6972 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6974 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6975 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6976 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6977 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6978 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6979 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6980 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6981 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6983 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6985 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
6987 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6991 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6994 else if (hash_mode
== 7500)
6996 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
6998 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7000 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7001 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7003 char data
[128] = { 0 };
7005 char *ptr_data
= data
;
7007 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7009 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7012 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7014 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7019 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7021 (char *) krb5pa
->user
,
7022 (char *) krb5pa
->realm
,
7023 (char *) krb5pa
->salt
,
7026 else if (hash_mode
== 7700)
7028 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7029 (char *) salt
.salt_buf
,
7033 else if (hash_mode
== 7800)
7035 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7036 (char *) salt
.salt_buf
,
7043 else if (hash_mode
== 7900)
7045 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7049 char *tmp
= (char *) salt
.salt_buf_pc
;
7051 ptr_plain
[42] = tmp
[0];
7057 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7059 else if (hash_mode
== 8000)
7061 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7062 (unsigned char *) salt
.salt_buf
,
7072 else if (hash_mode
== 8100)
7074 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7075 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7077 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7078 (unsigned char *) salt
.salt_buf
,
7085 else if (hash_mode
== 8200)
7087 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7089 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7091 char data_buf
[4096] = { 0 };
7093 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7095 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7098 data_buf
[cloudkey
->data_len
* 2] = 0;
7100 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7101 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7102 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7103 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7104 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7105 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7106 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7107 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7109 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7110 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7111 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7112 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7114 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7130 else if (hash_mode
== 8300)
7132 char digest_buf_c
[34] = { 0 };
7134 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7136 digest_buf_c
[32] = 0;
7140 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7142 char domain_buf_c
[33] = { 0 };
7144 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7146 for (uint i
= 0; i
< salt_pc_len
; i
++)
7148 const char next
= domain_buf_c
[i
];
7150 domain_buf_c
[i
] = '.';
7155 domain_buf_c
[salt_pc_len
] = 0;
7159 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7161 else if (hash_mode
== 8500)
7163 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7165 else if (hash_mode
== 2612)
7167 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7169 (char *) salt
.salt_buf
,
7175 else if (hash_mode
== 3711)
7177 char *salt_ptr
= (char *) salt
.salt_buf
;
7179 salt_ptr
[salt
.salt_len
- 1] = 0;
7181 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7182 SIGNATURE_MEDIAWIKI_B
,
7189 else if (hash_mode
== 8800)
7191 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7193 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7195 char tmp
[3073] = { 0 };
7197 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7199 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7204 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7205 SIGNATURE_ANDROIDFDE
,
7206 byte_swap_32 (salt
.salt_buf
[0]),
7207 byte_swap_32 (salt
.salt_buf
[1]),
7208 byte_swap_32 (salt
.salt_buf
[2]),
7209 byte_swap_32 (salt
.salt_buf
[3]),
7210 byte_swap_32 (digest_buf
[0]),
7211 byte_swap_32 (digest_buf
[1]),
7212 byte_swap_32 (digest_buf
[2]),
7213 byte_swap_32 (digest_buf
[3]),
7216 else if (hash_mode
== 8900)
7218 uint N
= salt
.scrypt_N
;
7219 uint r
= salt
.scrypt_r
;
7220 uint p
= salt
.scrypt_p
;
7222 char base64_salt
[32] = { 0 };
7224 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7226 memset (tmp_buf
, 0, 46);
7228 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7229 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7230 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7231 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7232 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7233 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7234 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7235 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7236 digest_buf
[8] = 0; // needed for base64_encode ()
7238 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7240 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7248 else if (hash_mode
== 9000)
7250 snprintf (out_buf
, len
-1, "%s", hashfile
);
7252 else if (hash_mode
== 9200)
7256 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7258 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7260 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7264 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7265 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7266 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7267 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7268 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7269 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7270 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7271 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7272 digest_buf
[8] = 0; // needed for base64_encode ()
7274 char tmp_buf
[64] = { 0 };
7276 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7277 tmp_buf
[43] = 0; // cut it here
7281 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7283 else if (hash_mode
== 9300)
7285 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7286 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7287 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7288 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7289 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7290 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7291 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7292 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7293 digest_buf
[8] = 0; // needed for base64_encode ()
7295 char tmp_buf
[64] = { 0 };
7297 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7298 tmp_buf
[43] = 0; // cut it here
7300 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7302 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7304 else if (hash_mode
== 9400)
7306 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7308 office2007_t
*office2007
= &office2007s
[salt_pos
];
7310 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7311 SIGNATURE_OFFICE2007
,
7314 office2007
->keySize
,
7320 office2007
->encryptedVerifier
[0],
7321 office2007
->encryptedVerifier
[1],
7322 office2007
->encryptedVerifier
[2],
7323 office2007
->encryptedVerifier
[3],
7324 office2007
->encryptedVerifierHash
[0],
7325 office2007
->encryptedVerifierHash
[1],
7326 office2007
->encryptedVerifierHash
[2],
7327 office2007
->encryptedVerifierHash
[3],
7328 office2007
->encryptedVerifierHash
[4]);
7330 else if (hash_mode
== 9500)
7332 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7334 office2010_t
*office2010
= &office2010s
[salt_pos
];
7336 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,
7342 office2010
->encryptedVerifier
[0],
7343 office2010
->encryptedVerifier
[1],
7344 office2010
->encryptedVerifier
[2],
7345 office2010
->encryptedVerifier
[3],
7346 office2010
->encryptedVerifierHash
[0],
7347 office2010
->encryptedVerifierHash
[1],
7348 office2010
->encryptedVerifierHash
[2],
7349 office2010
->encryptedVerifierHash
[3],
7350 office2010
->encryptedVerifierHash
[4],
7351 office2010
->encryptedVerifierHash
[5],
7352 office2010
->encryptedVerifierHash
[6],
7353 office2010
->encryptedVerifierHash
[7]);
7355 else if (hash_mode
== 9600)
7357 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7359 office2013_t
*office2013
= &office2013s
[salt_pos
];
7361 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,
7367 office2013
->encryptedVerifier
[0],
7368 office2013
->encryptedVerifier
[1],
7369 office2013
->encryptedVerifier
[2],
7370 office2013
->encryptedVerifier
[3],
7371 office2013
->encryptedVerifierHash
[0],
7372 office2013
->encryptedVerifierHash
[1],
7373 office2013
->encryptedVerifierHash
[2],
7374 office2013
->encryptedVerifierHash
[3],
7375 office2013
->encryptedVerifierHash
[4],
7376 office2013
->encryptedVerifierHash
[5],
7377 office2013
->encryptedVerifierHash
[6],
7378 office2013
->encryptedVerifierHash
[7]);
7380 else if (hash_mode
== 9700)
7382 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7384 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7386 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7387 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7388 byte_swap_32 (salt
.salt_buf
[0]),
7389 byte_swap_32 (salt
.salt_buf
[1]),
7390 byte_swap_32 (salt
.salt_buf
[2]),
7391 byte_swap_32 (salt
.salt_buf
[3]),
7392 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7393 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7394 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7395 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7396 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7397 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7398 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7399 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7401 else if (hash_mode
== 9710)
7403 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7405 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7407 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7408 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7409 byte_swap_32 (salt
.salt_buf
[0]),
7410 byte_swap_32 (salt
.salt_buf
[1]),
7411 byte_swap_32 (salt
.salt_buf
[2]),
7412 byte_swap_32 (salt
.salt_buf
[3]),
7413 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7414 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7415 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7416 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7417 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7418 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7419 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7420 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7422 else if (hash_mode
== 9720)
7424 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7426 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7428 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7430 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7431 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7432 byte_swap_32 (salt
.salt_buf
[0]),
7433 byte_swap_32 (salt
.salt_buf
[1]),
7434 byte_swap_32 (salt
.salt_buf
[2]),
7435 byte_swap_32 (salt
.salt_buf
[3]),
7436 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7437 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7438 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7439 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7440 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7441 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7442 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7443 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7450 else if (hash_mode
== 9800)
7452 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7454 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7456 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7457 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7462 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7463 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7464 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7465 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7466 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7467 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7468 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7469 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7470 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7472 else if (hash_mode
== 9810)
7474 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7476 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7478 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7479 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7484 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7485 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7486 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7487 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7488 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7489 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7490 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7491 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7492 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7494 else if (hash_mode
== 9820)
7496 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7498 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7500 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7502 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7503 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7508 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7509 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7510 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7511 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7512 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7513 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7514 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7515 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7516 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7523 else if (hash_mode
== 10000)
7527 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7529 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7531 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7535 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7536 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7537 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7538 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7539 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7540 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7541 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7542 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7543 digest_buf
[8] = 0; // needed for base64_encode ()
7545 char tmp_buf
[64] = { 0 };
7547 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7551 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7553 else if (hash_mode
== 10100)
7555 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7560 byte_swap_32 (salt
.salt_buf
[0]),
7561 byte_swap_32 (salt
.salt_buf
[1]),
7562 byte_swap_32 (salt
.salt_buf
[2]),
7563 byte_swap_32 (salt
.salt_buf
[3]));
7565 else if (hash_mode
== 10200)
7567 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7569 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7573 char challenge
[100] = { 0 };
7575 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7579 char tmp_buf
[100] = { 0 };
7581 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7582 (char *) cram_md5
->user
,
7588 char response
[100] = { 0 };
7590 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7592 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7594 else if (hash_mode
== 10300)
7596 char tmp_buf
[100] = { 0 };
7598 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7599 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7601 uint tmp_len
= 20 + salt
.salt_len
;
7605 char base64_encoded
[100] = { 0 };
7607 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7609 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7611 else if (hash_mode
== 10400)
7613 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7615 pdf_t
*pdf
= &pdfs
[salt_pos
];
7617 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",
7625 byte_swap_32 (pdf
->id_buf
[0]),
7626 byte_swap_32 (pdf
->id_buf
[1]),
7627 byte_swap_32 (pdf
->id_buf
[2]),
7628 byte_swap_32 (pdf
->id_buf
[3]),
7630 byte_swap_32 (pdf
->u_buf
[0]),
7631 byte_swap_32 (pdf
->u_buf
[1]),
7632 byte_swap_32 (pdf
->u_buf
[2]),
7633 byte_swap_32 (pdf
->u_buf
[3]),
7634 byte_swap_32 (pdf
->u_buf
[4]),
7635 byte_swap_32 (pdf
->u_buf
[5]),
7636 byte_swap_32 (pdf
->u_buf
[6]),
7637 byte_swap_32 (pdf
->u_buf
[7]),
7639 byte_swap_32 (pdf
->o_buf
[0]),
7640 byte_swap_32 (pdf
->o_buf
[1]),
7641 byte_swap_32 (pdf
->o_buf
[2]),
7642 byte_swap_32 (pdf
->o_buf
[3]),
7643 byte_swap_32 (pdf
->o_buf
[4]),
7644 byte_swap_32 (pdf
->o_buf
[5]),
7645 byte_swap_32 (pdf
->o_buf
[6]),
7646 byte_swap_32 (pdf
->o_buf
[7])
7649 else if (hash_mode
== 10410)
7651 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7653 pdf_t
*pdf
= &pdfs
[salt_pos
];
7655 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",
7663 byte_swap_32 (pdf
->id_buf
[0]),
7664 byte_swap_32 (pdf
->id_buf
[1]),
7665 byte_swap_32 (pdf
->id_buf
[2]),
7666 byte_swap_32 (pdf
->id_buf
[3]),
7668 byte_swap_32 (pdf
->u_buf
[0]),
7669 byte_swap_32 (pdf
->u_buf
[1]),
7670 byte_swap_32 (pdf
->u_buf
[2]),
7671 byte_swap_32 (pdf
->u_buf
[3]),
7672 byte_swap_32 (pdf
->u_buf
[4]),
7673 byte_swap_32 (pdf
->u_buf
[5]),
7674 byte_swap_32 (pdf
->u_buf
[6]),
7675 byte_swap_32 (pdf
->u_buf
[7]),
7677 byte_swap_32 (pdf
->o_buf
[0]),
7678 byte_swap_32 (pdf
->o_buf
[1]),
7679 byte_swap_32 (pdf
->o_buf
[2]),
7680 byte_swap_32 (pdf
->o_buf
[3]),
7681 byte_swap_32 (pdf
->o_buf
[4]),
7682 byte_swap_32 (pdf
->o_buf
[5]),
7683 byte_swap_32 (pdf
->o_buf
[6]),
7684 byte_swap_32 (pdf
->o_buf
[7])
7687 else if (hash_mode
== 10420)
7689 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7691 pdf_t
*pdf
= &pdfs
[salt_pos
];
7693 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7695 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",
7703 byte_swap_32 (pdf
->id_buf
[0]),
7704 byte_swap_32 (pdf
->id_buf
[1]),
7705 byte_swap_32 (pdf
->id_buf
[2]),
7706 byte_swap_32 (pdf
->id_buf
[3]),
7708 byte_swap_32 (pdf
->u_buf
[0]),
7709 byte_swap_32 (pdf
->u_buf
[1]),
7710 byte_swap_32 (pdf
->u_buf
[2]),
7711 byte_swap_32 (pdf
->u_buf
[3]),
7712 byte_swap_32 (pdf
->u_buf
[4]),
7713 byte_swap_32 (pdf
->u_buf
[5]),
7714 byte_swap_32 (pdf
->u_buf
[6]),
7715 byte_swap_32 (pdf
->u_buf
[7]),
7717 byte_swap_32 (pdf
->o_buf
[0]),
7718 byte_swap_32 (pdf
->o_buf
[1]),
7719 byte_swap_32 (pdf
->o_buf
[2]),
7720 byte_swap_32 (pdf
->o_buf
[3]),
7721 byte_swap_32 (pdf
->o_buf
[4]),
7722 byte_swap_32 (pdf
->o_buf
[5]),
7723 byte_swap_32 (pdf
->o_buf
[6]),
7724 byte_swap_32 (pdf
->o_buf
[7]),
7732 else if (hash_mode
== 10500)
7734 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7736 pdf_t
*pdf
= &pdfs
[salt_pos
];
7738 if (pdf
->id_len
== 32)
7740 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",
7748 byte_swap_32 (pdf
->id_buf
[0]),
7749 byte_swap_32 (pdf
->id_buf
[1]),
7750 byte_swap_32 (pdf
->id_buf
[2]),
7751 byte_swap_32 (pdf
->id_buf
[3]),
7752 byte_swap_32 (pdf
->id_buf
[4]),
7753 byte_swap_32 (pdf
->id_buf
[5]),
7754 byte_swap_32 (pdf
->id_buf
[6]),
7755 byte_swap_32 (pdf
->id_buf
[7]),
7757 byte_swap_32 (pdf
->u_buf
[0]),
7758 byte_swap_32 (pdf
->u_buf
[1]),
7759 byte_swap_32 (pdf
->u_buf
[2]),
7760 byte_swap_32 (pdf
->u_buf
[3]),
7761 byte_swap_32 (pdf
->u_buf
[4]),
7762 byte_swap_32 (pdf
->u_buf
[5]),
7763 byte_swap_32 (pdf
->u_buf
[6]),
7764 byte_swap_32 (pdf
->u_buf
[7]),
7766 byte_swap_32 (pdf
->o_buf
[0]),
7767 byte_swap_32 (pdf
->o_buf
[1]),
7768 byte_swap_32 (pdf
->o_buf
[2]),
7769 byte_swap_32 (pdf
->o_buf
[3]),
7770 byte_swap_32 (pdf
->o_buf
[4]),
7771 byte_swap_32 (pdf
->o_buf
[5]),
7772 byte_swap_32 (pdf
->o_buf
[6]),
7773 byte_swap_32 (pdf
->o_buf
[7])
7778 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",
7786 byte_swap_32 (pdf
->id_buf
[0]),
7787 byte_swap_32 (pdf
->id_buf
[1]),
7788 byte_swap_32 (pdf
->id_buf
[2]),
7789 byte_swap_32 (pdf
->id_buf
[3]),
7791 byte_swap_32 (pdf
->u_buf
[0]),
7792 byte_swap_32 (pdf
->u_buf
[1]),
7793 byte_swap_32 (pdf
->u_buf
[2]),
7794 byte_swap_32 (pdf
->u_buf
[3]),
7795 byte_swap_32 (pdf
->u_buf
[4]),
7796 byte_swap_32 (pdf
->u_buf
[5]),
7797 byte_swap_32 (pdf
->u_buf
[6]),
7798 byte_swap_32 (pdf
->u_buf
[7]),
7800 byte_swap_32 (pdf
->o_buf
[0]),
7801 byte_swap_32 (pdf
->o_buf
[1]),
7802 byte_swap_32 (pdf
->o_buf
[2]),
7803 byte_swap_32 (pdf
->o_buf
[3]),
7804 byte_swap_32 (pdf
->o_buf
[4]),
7805 byte_swap_32 (pdf
->o_buf
[5]),
7806 byte_swap_32 (pdf
->o_buf
[6]),
7807 byte_swap_32 (pdf
->o_buf
[7])
7811 else if (hash_mode
== 10600)
7813 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7815 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7816 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7818 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7820 else if (hash_mode
== 10700)
7822 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7824 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7825 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7827 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7829 else if (hash_mode
== 10900)
7831 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7833 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7834 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7836 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7838 else if (hash_mode
== 11100)
7840 u32 salt_challenge
= salt
.salt_buf
[0];
7842 salt_challenge
= byte_swap_32 (salt_challenge
);
7844 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7846 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7847 SIGNATURE_POSTGRESQL_AUTH
,
7855 else if (hash_mode
== 11200)
7857 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7858 SIGNATURE_MYSQL_AUTH
,
7859 (unsigned char *) salt
.salt_buf
,
7866 else if (hash_mode
== 11300)
7868 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7870 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7872 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7873 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7874 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7876 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7877 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7878 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7880 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7882 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7884 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7887 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7889 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7891 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7894 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7896 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7898 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7901 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7902 SIGNATURE_BITCOIN_WALLET
,
7906 (unsigned char *) salt
.salt_buf
,
7914 free (cry_master_buf
);
7916 free (public_key_buf
);
7918 else if (hash_mode
== 11400)
7920 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7922 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7923 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7925 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7927 else if (hash_mode
== 11600)
7929 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7931 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7933 const uint data_len
= seven_zip
->data_len
;
7935 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7937 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7939 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
7941 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7944 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7945 SIGNATURE_SEVEN_ZIP
,
7949 (char *) seven_zip
->salt_buf
,
7951 seven_zip
->iv_buf
[0],
7952 seven_zip
->iv_buf
[1],
7953 seven_zip
->iv_buf
[2],
7954 seven_zip
->iv_buf
[3],
7956 seven_zip
->data_len
,
7957 seven_zip
->unpack_size
,
7962 else if (hash_mode
== 11700)
7964 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7974 else if (hash_mode
== 11800)
7976 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7994 else if (hash_mode
== 11900)
7996 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7998 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7999 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8001 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8003 else if (hash_mode
== 12000)
8005 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8007 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8008 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8010 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8012 else if (hash_mode
== 12100)
8014 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8016 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8017 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8019 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8021 else if (hash_mode
== 12200)
8023 uint
*ptr_digest
= digest_buf
;
8024 uint
*ptr_salt
= salt
.salt_buf
;
8026 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8033 else if (hash_mode
== 12300)
8035 uint
*ptr_digest
= digest_buf
;
8036 uint
*ptr_salt
= salt
.salt_buf
;
8038 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",
8039 ptr_digest
[ 0], ptr_digest
[ 1],
8040 ptr_digest
[ 2], ptr_digest
[ 3],
8041 ptr_digest
[ 4], ptr_digest
[ 5],
8042 ptr_digest
[ 6], ptr_digest
[ 7],
8043 ptr_digest
[ 8], ptr_digest
[ 9],
8044 ptr_digest
[10], ptr_digest
[11],
8045 ptr_digest
[12], ptr_digest
[13],
8046 ptr_digest
[14], ptr_digest
[15],
8052 else if (hash_mode
== 12400)
8054 // encode iteration count
8056 char salt_iter
[5] = { 0 };
8058 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8059 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8060 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8061 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8066 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8067 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8068 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8069 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8074 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8076 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8077 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8079 memcpy (tmp_buf
, digest_buf
, 8);
8081 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8085 // fill the resulting buffer
8087 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8089 else if (hash_mode
== 12500)
8091 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8093 byte_swap_32 (salt
.salt_buf
[0]),
8094 byte_swap_32 (salt
.salt_buf
[1]),
8100 else if (hash_mode
== 12600)
8102 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8103 digest_buf
[0] + salt
.salt_buf_pc
[0],
8104 digest_buf
[1] + salt
.salt_buf_pc
[1],
8105 digest_buf
[2] + salt
.salt_buf_pc
[2],
8106 digest_buf
[3] + salt
.salt_buf_pc
[3],
8107 digest_buf
[4] + salt
.salt_buf_pc
[4],
8108 digest_buf
[5] + salt
.salt_buf_pc
[5],
8109 digest_buf
[6] + salt
.salt_buf_pc
[6],
8110 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8112 else if (hash_mode
== 12700)
8114 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8116 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8117 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8119 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8121 else if (hash_mode
== 12800)
8123 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8125 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",
8138 byte_swap_32 (digest_buf
[0]),
8139 byte_swap_32 (digest_buf
[1]),
8140 byte_swap_32 (digest_buf
[2]),
8141 byte_swap_32 (digest_buf
[3]),
8142 byte_swap_32 (digest_buf
[4]),
8143 byte_swap_32 (digest_buf
[5]),
8144 byte_swap_32 (digest_buf
[6]),
8145 byte_swap_32 (digest_buf
[7])
8148 else if (hash_mode
== 12900)
8150 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",
8159 byte_swap_32 (digest_buf
[0]),
8160 byte_swap_32 (digest_buf
[1]),
8161 byte_swap_32 (digest_buf
[2]),
8162 byte_swap_32 (digest_buf
[3]),
8163 byte_swap_32 (digest_buf
[4]),
8164 byte_swap_32 (digest_buf
[5]),
8165 byte_swap_32 (digest_buf
[6]),
8166 byte_swap_32 (digest_buf
[7]),
8173 else if (hash_mode
== 13000)
8175 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8177 rar5_t
*rar5
= &rar5s
[salt_pos
];
8179 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8189 byte_swap_32 (digest_buf
[0]),
8190 byte_swap_32 (digest_buf
[1])
8195 if (hash_type
== HASH_TYPE_MD4
)
8197 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8203 else if (hash_type
== HASH_TYPE_MD5
)
8205 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8211 else if (hash_type
== HASH_TYPE_SHA1
)
8213 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8220 else if (hash_type
== HASH_TYPE_SHA256
)
8222 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8232 else if (hash_type
== HASH_TYPE_SHA384
)
8234 uint
*ptr
= digest_buf
;
8236 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8244 else if (hash_type
== HASH_TYPE_SHA512
)
8246 uint
*ptr
= digest_buf
;
8248 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8258 else if (hash_type
== HASH_TYPE_LM
)
8260 snprintf (out_buf
, len
-1, "%08x%08x",
8264 else if (hash_type
== HASH_TYPE_ORACLEH
)
8266 snprintf (out_buf
, len
-1, "%08X%08X",
8270 else if (hash_type
== HASH_TYPE_BCRYPT
)
8272 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8273 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8275 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8277 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8279 else if (hash_type
== HASH_TYPE_KECCAK
)
8281 uint
*ptr
= digest_buf
;
8283 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",
8311 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8313 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8315 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8322 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8324 digest_buf
[ 0] = digest_buf
[ 0];
8325 digest_buf
[ 1] = digest_buf
[ 1];
8326 digest_buf
[ 2] = digest_buf
[ 2];
8327 digest_buf
[ 3] = digest_buf
[ 3];
8328 digest_buf
[ 4] = digest_buf
[ 4];
8329 digest_buf
[ 5] = digest_buf
[ 5];
8330 digest_buf
[ 6] = digest_buf
[ 6];
8331 digest_buf
[ 7] = digest_buf
[ 7];
8332 digest_buf
[ 8] = digest_buf
[ 8];
8333 digest_buf
[ 9] = digest_buf
[ 9];
8334 digest_buf
[10] = digest_buf
[10];
8335 digest_buf
[11] = digest_buf
[11];
8336 digest_buf
[12] = digest_buf
[12];
8337 digest_buf
[13] = digest_buf
[13];
8338 digest_buf
[14] = digest_buf
[14];
8339 digest_buf
[15] = digest_buf
[15];
8341 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8359 else if (hash_type
== HASH_TYPE_GOST
)
8361 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8371 else if (hash_type
== HASH_TYPE_MYSQL
)
8373 snprintf (out_buf
, len
-1, "%08x%08x",
8377 else if (hash_type
== HASH_TYPE_LOTUS5
)
8379 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8385 else if (hash_type
== HASH_TYPE_LOTUS6
)
8387 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8388 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8389 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8390 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8392 char buf
[16] = { 0 };
8394 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8395 memcpy (buf
+ 5, digest_buf
, 9);
8399 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8401 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8404 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8406 else if (hash_type
== HASH_TYPE_LOTUS8
)
8408 char buf
[52] = { 0 };
8412 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8418 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8422 buf
[26] = salt
.salt_buf_pc
[0];
8423 buf
[27] = salt
.salt_buf_pc
[1];
8427 memcpy (buf
+ 28, digest_buf
, 8);
8429 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8433 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8435 else if (hash_type
== HASH_TYPE_CRC32
)
8437 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8441 if (salt_type
== SALT_TYPE_INTERN
)
8443 size_t pos
= strlen (out_buf
);
8445 out_buf
[pos
] = data
.separator
;
8447 char *ptr
= (char *) salt
.salt_buf
;
8449 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8451 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8455 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8457 memset (hccap
, 0, sizeof (hccap_t
));
8459 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8461 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8463 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8464 wpa_t
*wpa
= &wpas
[salt_pos
];
8466 hccap
->keyver
= wpa
->keyver
;
8468 hccap
->eapol_size
= wpa
->eapol_size
;
8470 if (wpa
->keyver
!= 1)
8472 uint eapol_tmp
[64] = { 0 };
8474 for (uint i
= 0; i
< 64; i
++)
8476 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8479 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8483 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8486 uint pke_tmp
[25] = { 0 };
8488 for (int i
= 5; i
< 25; i
++)
8490 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8493 char *pke_ptr
= (char *) pke_tmp
;
8495 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8496 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8497 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8498 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8500 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8502 uint dgst_size
= data
.dgst_size
;
8504 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8506 if (wpa
->keyver
!= 1)
8508 uint digest_tmp
[4] = { 0 };
8510 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8511 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8512 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8513 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8515 memcpy (hccap
->keymic
, digest_tmp
, 16);
8519 memcpy (hccap
->keymic
, digest_ptr
, 16);
8523 void SuspendThreads ()
8525 if (data
.devices_status
== STATUS_RUNNING
)
8527 hc_timer_set (&data
.timer_paused
);
8529 data
.devices_status
= STATUS_PAUSED
;
8531 log_info ("Paused");
8535 void ResumeThreads ()
8537 if (data
.devices_status
== STATUS_PAUSED
)
8541 hc_timer_get (data
.timer_paused
, ms_paused
);
8543 data
.ms_paused
+= ms_paused
;
8545 data
.devices_status
= STATUS_RUNNING
;
8547 log_info ("Resumed");
8553 if (data
.devices_status
!= STATUS_RUNNING
) return;
8555 data
.devices_status
= STATUS_BYPASS
;
8557 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8560 void stop_at_checkpoint ()
8562 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8564 if (data
.devices_status
!= STATUS_RUNNING
) return;
8567 // this feature only makes sense if --restore-disable was not specified
8569 if (data
.restore_disable
== 1)
8571 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8576 // check if monitoring of Restore Point updates should be enabled or disabled
8578 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8580 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8582 // save the current restore point value
8584 data
.checkpoint_cur_words
= get_lowest_words_done ();
8586 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8590 data
.devices_status
= STATUS_RUNNING
;
8592 // reset the global value for checkpoint checks
8594 data
.checkpoint_cur_words
= 0;
8596 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8602 if (data
.devices_status
== STATUS_INIT
) return;
8603 if (data
.devices_status
== STATUS_STARTING
) return;
8605 data
.devices_status
= STATUS_ABORTED
;
8610 if (data
.devices_status
== STATUS_INIT
) return;
8611 if (data
.devices_status
== STATUS_STARTING
) return;
8613 data
.devices_status
= STATUS_QUIT
;
8616 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8618 FILE *fp
= fopen (kernel_file
, "rb");
8624 memset (&st
, 0, sizeof (st
));
8626 stat (kernel_file
, &st
);
8628 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8630 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8632 if (num_read
!= (size_t) st
.st_size
)
8634 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8641 buf
[st
.st_size
] = 0;
8643 for (int i
= 0; i
< num_devices
; i
++)
8645 kernel_lengths
[i
] = (size_t) st
.st_size
;
8647 kernel_sources
[i
] = buf
;
8652 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8660 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8662 if (binary_size
> 0)
8664 FILE *fp
= fopen (dst
, "wb");
8667 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8678 restore_data_t
*init_restore (int argc
, char **argv
)
8680 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8682 if (data
.restore_disable
== 0)
8684 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8688 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8692 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8701 char pidbin
[BUFSIZ
] = { 0 };
8703 int pidbin_len
= -1;
8706 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8708 FILE *fd
= fopen (pidbin
, "rb");
8712 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8714 pidbin
[pidbin_len
] = 0;
8718 char *argv0_r
= strrchr (argv
[0], '/');
8720 char *pidbin_r
= strrchr (pidbin
, '/');
8722 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8724 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8726 if (strcmp (argv0_r
, pidbin_r
) == 0)
8728 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8735 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8737 char pidbin2
[BUFSIZ
] = { 0 };
8739 int pidbin2_len
= -1;
8741 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8742 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8744 pidbin
[pidbin_len
] = 0;
8745 pidbin2
[pidbin2_len
] = 0;
8749 if (strcmp (pidbin
, pidbin2
) == 0)
8751 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8759 if (rd
->version_bin
< RESTORE_MIN
)
8761 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8768 memset (rd
, 0, sizeof (restore_data_t
));
8770 rd
->version_bin
= VERSION_BIN
;
8773 rd
->pid
= getpid ();
8775 rd
->pid
= GetCurrentProcessId ();
8778 if (getcwd (rd
->cwd
, 255) == NULL
)
8791 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8793 FILE *fp
= fopen (eff_restore_file
, "rb");
8797 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8802 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8804 log_error ("ERROR: cannot read %s", eff_restore_file
);
8809 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8811 for (uint i
= 0; i
< rd
->argc
; i
++)
8813 char buf
[BUFSIZ
] = { 0 };
8815 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8817 log_error ("ERROR: cannot read %s", eff_restore_file
);
8822 size_t len
= strlen (buf
);
8824 if (len
) buf
[len
- 1] = 0;
8826 rd
->argv
[i
] = mystrdup (buf
);
8831 char new_cwd
[1024] = { 0 };
8833 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8837 log_error ("Restore file is corrupted");
8840 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8842 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8844 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8849 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8852 if (chdir (rd
->cwd
))
8854 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8860 u64
get_lowest_words_done ()
8864 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8866 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8868 if (device_param
->skipped
) continue;
8870 const u64 words_done
= device_param
->words_done
;
8872 if (words_done
< words_cur
) words_cur
= words_done
;
8875 // It's possible that a device's workload isn't finished right after a restore-case.
8876 // In that case, this function would return 0 and overwrite the real restore point
8877 // There's also data.words_cur which is set to rd->words_cur but it changes while
8878 // the attack is running therefore we should stick to rd->words_cur.
8879 // Note that -s influences rd->words_cur we should keep a close look on that.
8881 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8886 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8888 u64 words_cur
= get_lowest_words_done ();
8890 rd
->words_cur
= words_cur
;
8892 FILE *fp
= fopen (new_restore_file
, "wb");
8896 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8901 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8903 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8908 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8910 for (uint i
= 0; i
< rd
->argc
; i
++)
8912 fprintf (fp
, "%s", rd
->argv
[i
]);
8918 fsync (fileno (fp
));
8923 void cycle_restore ()
8925 const char *eff_restore_file
= data
.eff_restore_file
;
8926 const char *new_restore_file
= data
.new_restore_file
;
8928 restore_data_t
*rd
= data
.rd
;
8930 write_restore (new_restore_file
, rd
);
8934 memset (&st
, 0, sizeof(st
));
8936 if (stat (eff_restore_file
, &st
) == 0)
8938 if (unlink (eff_restore_file
))
8940 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8944 if (rename (new_restore_file
, eff_restore_file
))
8946 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8950 void check_checkpoint ()
8952 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8954 u64 words_cur
= get_lowest_words_done ();
8956 if (words_cur
!= data
.checkpoint_cur_words
)
8966 uint
set_kernel_accel (uint hash_mode
)
8970 case 0: return GET_ACCEL (0);
8971 case 10: return GET_ACCEL (10);
8972 case 11: return GET_ACCEL (11);
8973 case 12: return GET_ACCEL (12);
8974 case 20: return GET_ACCEL (20);
8975 case 21: return GET_ACCEL (21);
8976 case 22: return GET_ACCEL (22);
8977 case 23: return GET_ACCEL (23);
8978 case 30: return GET_ACCEL (30);
8979 case 40: return GET_ACCEL (40);
8980 case 50: return GET_ACCEL (50);
8981 case 60: return GET_ACCEL (60);
8982 case 100: return GET_ACCEL (100);
8983 case 101: return GET_ACCEL (101);
8984 case 110: return GET_ACCEL (110);
8985 case 111: return GET_ACCEL (111);
8986 case 112: return GET_ACCEL (112);
8987 case 120: return GET_ACCEL (120);
8988 case 121: return GET_ACCEL (121);
8989 case 122: return GET_ACCEL (122);
8990 case 124: return GET_ACCEL (124);
8991 case 130: return GET_ACCEL (130);
8992 case 131: return GET_ACCEL (131);
8993 case 132: return GET_ACCEL (132);
8994 case 133: return GET_ACCEL (133);
8995 case 140: return GET_ACCEL (140);
8996 case 141: return GET_ACCEL (141);
8997 case 150: return GET_ACCEL (150);
8998 case 160: return GET_ACCEL (160);
8999 case 190: return GET_ACCEL (190);
9000 case 200: return GET_ACCEL (200);
9001 case 300: return GET_ACCEL (300);
9002 case 400: return GET_ACCEL (400);
9003 case 500: return GET_ACCEL (500);
9004 case 501: return GET_ACCEL (501);
9005 case 900: return GET_ACCEL (900);
9006 case 910: return GET_ACCEL (910);
9007 case 1000: return GET_ACCEL (1000);
9008 case 1100: return GET_ACCEL (1100);
9009 case 1400: return GET_ACCEL (1400);
9010 case 1410: return GET_ACCEL (1410);
9011 case 1420: return GET_ACCEL (1420);
9012 case 1421: return GET_ACCEL (1421);
9013 case 1430: return GET_ACCEL (1430);
9014 case 1440: return GET_ACCEL (1440);
9015 case 1441: return GET_ACCEL (1441);
9016 case 1450: return GET_ACCEL (1450);
9017 case 1460: return GET_ACCEL (1460);
9018 case 1500: return GET_ACCEL (1500);
9019 case 1600: return GET_ACCEL (1600);
9020 case 1700: return GET_ACCEL (1700);
9021 case 1710: return GET_ACCEL (1710);
9022 case 1711: return GET_ACCEL (1711);
9023 case 1720: return GET_ACCEL (1720);
9024 case 1722: return GET_ACCEL (1722);
9025 case 1730: return GET_ACCEL (1730);
9026 case 1731: return GET_ACCEL (1731);
9027 case 1740: return GET_ACCEL (1740);
9028 case 1750: return GET_ACCEL (1750);
9029 case 1760: return GET_ACCEL (1760);
9030 case 1800: return GET_ACCEL (1800);
9031 case 2100: return GET_ACCEL (2100);
9032 case 2400: return GET_ACCEL (2400);
9033 case 2410: return GET_ACCEL (2410);
9034 case 2500: return GET_ACCEL (2500);
9035 case 2600: return GET_ACCEL (2600);
9036 case 2611: return GET_ACCEL (2611);
9037 case 2612: return GET_ACCEL (2612);
9038 case 2711: return GET_ACCEL (2711);
9039 case 2811: return GET_ACCEL (2811);
9040 case 3000: return GET_ACCEL (3000);
9041 case 3100: return GET_ACCEL (3100);
9042 case 3200: return GET_ACCEL (3200);
9043 case 3710: return GET_ACCEL (3710);
9044 case 3711: return GET_ACCEL (3711);
9045 case 3800: return GET_ACCEL (3800);
9046 case 4300: return GET_ACCEL (4300);
9047 case 4400: return GET_ACCEL (4400);
9048 case 4500: return GET_ACCEL (4500);
9049 case 4700: return GET_ACCEL (4700);
9050 case 4800: return GET_ACCEL (4800);
9051 case 4900: return GET_ACCEL (4900);
9052 case 5000: return GET_ACCEL (5000);
9053 case 5100: return GET_ACCEL (5100);
9054 case 5200: return GET_ACCEL (5200);
9055 case 5300: return GET_ACCEL (5300);
9056 case 5400: return GET_ACCEL (5400);
9057 case 5500: return GET_ACCEL (5500);
9058 case 5600: return GET_ACCEL (5600);
9059 case 5700: return GET_ACCEL (5700);
9060 case 5800: return GET_ACCEL (5800);
9061 case 6000: return GET_ACCEL (6000);
9062 case 6100: return GET_ACCEL (6100);
9063 case 6211: return GET_ACCEL (6211);
9064 case 6212: return GET_ACCEL (6212);
9065 case 6213: return GET_ACCEL (6213);
9066 case 6221: return GET_ACCEL (6221);
9067 case 6222: return GET_ACCEL (6222);
9068 case 6223: return GET_ACCEL (6223);
9069 case 6231: return GET_ACCEL (6231);
9070 case 6232: return GET_ACCEL (6232);
9071 case 6233: return GET_ACCEL (6233);
9072 case 6241: return GET_ACCEL (6241);
9073 case 6242: return GET_ACCEL (6242);
9074 case 6243: return GET_ACCEL (6243);
9075 case 6300: return GET_ACCEL (6300);
9076 case 6400: return GET_ACCEL (6400);
9077 case 6500: return GET_ACCEL (6500);
9078 case 6600: return GET_ACCEL (6600);
9079 case 6700: return GET_ACCEL (6700);
9080 case 6800: return GET_ACCEL (6800);
9081 case 6900: return GET_ACCEL (6900);
9082 case 7100: return GET_ACCEL (7100);
9083 case 7200: return GET_ACCEL (7200);
9084 case 7300: return GET_ACCEL (7300);
9085 case 7400: return GET_ACCEL (7400);
9086 case 7500: return GET_ACCEL (7500);
9087 case 7600: return GET_ACCEL (7600);
9088 case 7700: return GET_ACCEL (7700);
9089 case 7800: return GET_ACCEL (7800);
9090 case 7900: return GET_ACCEL (7900);
9091 case 8000: return GET_ACCEL (8000);
9092 case 8100: return GET_ACCEL (8100);
9093 case 8200: return GET_ACCEL (8200);
9094 case 8300: return GET_ACCEL (8300);
9095 case 8400: return GET_ACCEL (8400);
9096 case 8500: return GET_ACCEL (8500);
9097 case 8600: return GET_ACCEL (8600);
9098 case 8700: return GET_ACCEL (8700);
9099 case 8800: return GET_ACCEL (8800);
9100 case 8900: return GET_ACCEL (8900);
9101 case 9000: return GET_ACCEL (9000);
9102 case 9100: return GET_ACCEL (9100);
9103 case 9200: return GET_ACCEL (9200);
9104 case 9300: return GET_ACCEL (9300);
9105 case 9400: return GET_ACCEL (9400);
9106 case 9500: return GET_ACCEL (9500);
9107 case 9600: return GET_ACCEL (9600);
9108 case 9700: return GET_ACCEL (9700);
9109 case 9710: return GET_ACCEL (9710);
9110 case 9720: return GET_ACCEL (9720);
9111 case 9800: return GET_ACCEL (9800);
9112 case 9810: return GET_ACCEL (9810);
9113 case 9820: return GET_ACCEL (9820);
9114 case 9900: return GET_ACCEL (9900);
9115 case 10000: return GET_ACCEL (10000);
9116 case 10100: return GET_ACCEL (10100);
9117 case 10200: return GET_ACCEL (10200);
9118 case 10300: return GET_ACCEL (10300);
9119 case 10400: return GET_ACCEL (10400);
9120 case 10410: return GET_ACCEL (10410);
9121 case 10420: return GET_ACCEL (10420);
9122 case 10500: return GET_ACCEL (10500);
9123 case 10600: return GET_ACCEL (10600);
9124 case 10700: return GET_ACCEL (10700);
9125 case 10800: return GET_ACCEL (10800);
9126 case 10900: return GET_ACCEL (10900);
9127 case 11000: return GET_ACCEL (11000);
9128 case 11100: return GET_ACCEL (11100);
9129 case 11200: return GET_ACCEL (11200);
9130 case 11300: return GET_ACCEL (11300);
9131 case 11400: return GET_ACCEL (11400);
9132 case 11500: return GET_ACCEL (11500);
9133 case 11600: return GET_ACCEL (11600);
9134 case 11700: return GET_ACCEL (11700);
9135 case 11800: return GET_ACCEL (11800);
9136 case 11900: return GET_ACCEL (11900);
9137 case 12000: return GET_ACCEL (12000);
9138 case 12100: return GET_ACCEL (12100);
9139 case 12200: return GET_ACCEL (12200);
9140 case 12300: return GET_ACCEL (12300);
9141 case 12400: return GET_ACCEL (12400);
9142 case 12500: return GET_ACCEL (12500);
9143 case 12600: return GET_ACCEL (12600);
9144 case 12700: return GET_ACCEL (12700);
9145 case 12800: return GET_ACCEL (12800);
9146 case 12900: return GET_ACCEL (12900);
9147 case 13000: return GET_ACCEL (13000);
9153 uint
set_kernel_loops (uint hash_mode
)
9157 case 0: return GET_LOOPS (0);
9158 case 10: return GET_LOOPS (10);
9159 case 11: return GET_LOOPS (11);
9160 case 12: return GET_LOOPS (12);
9161 case 20: return GET_LOOPS (20);
9162 case 21: return GET_LOOPS (21);
9163 case 22: return GET_LOOPS (22);
9164 case 23: return GET_LOOPS (23);
9165 case 30: return GET_LOOPS (30);
9166 case 40: return GET_LOOPS (40);
9167 case 50: return GET_LOOPS (50);
9168 case 60: return GET_LOOPS (60);
9169 case 100: return GET_LOOPS (100);
9170 case 101: return GET_LOOPS (101);
9171 case 110: return GET_LOOPS (110);
9172 case 111: return GET_LOOPS (111);
9173 case 112: return GET_LOOPS (112);
9174 case 120: return GET_LOOPS (120);
9175 case 121: return GET_LOOPS (121);
9176 case 122: return GET_LOOPS (122);
9177 case 124: return GET_LOOPS (124);
9178 case 130: return GET_LOOPS (130);
9179 case 131: return GET_LOOPS (131);
9180 case 132: return GET_LOOPS (132);
9181 case 133: return GET_LOOPS (133);
9182 case 140: return GET_LOOPS (140);
9183 case 141: return GET_LOOPS (141);
9184 case 150: return GET_LOOPS (150);
9185 case 160: return GET_LOOPS (160);
9186 case 190: return GET_LOOPS (190);
9187 case 200: return GET_LOOPS (200);
9188 case 300: return GET_LOOPS (300);
9189 case 400: return GET_LOOPS (400);
9190 case 500: return GET_LOOPS (500);
9191 case 501: return GET_LOOPS (501);
9192 case 900: return GET_LOOPS (900);
9193 case 910: return GET_LOOPS (910);
9194 case 1000: return GET_LOOPS (1000);
9195 case 1100: return GET_LOOPS (1100);
9196 case 1400: return GET_LOOPS (1400);
9197 case 1410: return GET_LOOPS (1410);
9198 case 1420: return GET_LOOPS (1420);
9199 case 1421: return GET_LOOPS (1421);
9200 case 1430: return GET_LOOPS (1430);
9201 case 1440: return GET_LOOPS (1440);
9202 case 1441: return GET_LOOPS (1441);
9203 case 1450: return GET_LOOPS (1450);
9204 case 1460: return GET_LOOPS (1460);
9205 case 1500: return GET_LOOPS (1500);
9206 case 1600: return GET_LOOPS (1600);
9207 case 1700: return GET_LOOPS (1700);
9208 case 1710: return GET_LOOPS (1710);
9209 case 1711: return GET_LOOPS (1711);
9210 case 1720: return GET_LOOPS (1720);
9211 case 1722: return GET_LOOPS (1722);
9212 case 1730: return GET_LOOPS (1730);
9213 case 1731: return GET_LOOPS (1731);
9214 case 1740: return GET_LOOPS (1740);
9215 case 1750: return GET_LOOPS (1750);
9216 case 1760: return GET_LOOPS (1760);
9217 case 1800: return GET_LOOPS (1800);
9218 case 2100: return GET_LOOPS (2100);
9219 case 2400: return GET_LOOPS (2400);
9220 case 2410: return GET_LOOPS (2410);
9221 case 2500: return GET_LOOPS (2500);
9222 case 2600: return GET_LOOPS (2600);
9223 case 2611: return GET_LOOPS (2611);
9224 case 2612: return GET_LOOPS (2612);
9225 case 2711: return GET_LOOPS (2711);
9226 case 2811: return GET_LOOPS (2811);
9227 case 3000: return GET_LOOPS (3000);
9228 case 3100: return GET_LOOPS (3100);
9229 case 3200: return GET_LOOPS (3200);
9230 case 3710: return GET_LOOPS (3710);
9231 case 3711: return GET_LOOPS (3711);
9232 case 3800: return GET_LOOPS (3800);
9233 case 4300: return GET_LOOPS (4300);
9234 case 4400: return GET_LOOPS (4400);
9235 case 4500: return GET_LOOPS (4500);
9236 case 4700: return GET_LOOPS (4700);
9237 case 4800: return GET_LOOPS (4800);
9238 case 4900: return GET_LOOPS (4900);
9239 case 5000: return GET_LOOPS (5000);
9240 case 5100: return GET_LOOPS (5100);
9241 case 5200: return GET_LOOPS (5200);
9242 case 5300: return GET_LOOPS (5300);
9243 case 5400: return GET_LOOPS (5400);
9244 case 5500: return GET_LOOPS (5500);
9245 case 5600: return GET_LOOPS (5600);
9246 case 5700: return GET_LOOPS (5700);
9247 case 5800: return GET_LOOPS (5800);
9248 case 6000: return GET_LOOPS (6000);
9249 case 6100: return GET_LOOPS (6100);
9250 case 6211: return GET_LOOPS (6211);
9251 case 6212: return GET_LOOPS (6212);
9252 case 6213: return GET_LOOPS (6213);
9253 case 6221: return GET_LOOPS (6221);
9254 case 6222: return GET_LOOPS (6222);
9255 case 6223: return GET_LOOPS (6223);
9256 case 6231: return GET_LOOPS (6231);
9257 case 6232: return GET_LOOPS (6232);
9258 case 6233: return GET_LOOPS (6233);
9259 case 6241: return GET_LOOPS (6241);
9260 case 6242: return GET_LOOPS (6242);
9261 case 6243: return GET_LOOPS (6243);
9262 case 6300: return GET_LOOPS (6300);
9263 case 6400: return GET_LOOPS (6400);
9264 case 6500: return GET_LOOPS (6500);
9265 case 6600: return GET_LOOPS (6600);
9266 case 6700: return GET_LOOPS (6700);
9267 case 6800: return GET_LOOPS (6800);
9268 case 6900: return GET_LOOPS (6900);
9269 case 7100: return GET_LOOPS (7100);
9270 case 7200: return GET_LOOPS (7200);
9271 case 7300: return GET_LOOPS (7300);
9272 case 7400: return GET_LOOPS (7400);
9273 case 7500: return GET_LOOPS (7500);
9274 case 7600: return GET_LOOPS (7600);
9275 case 7700: return GET_LOOPS (7700);
9276 case 7800: return GET_LOOPS (7800);
9277 case 7900: return GET_LOOPS (7900);
9278 case 8000: return GET_LOOPS (8000);
9279 case 8100: return GET_LOOPS (8100);
9280 case 8200: return GET_LOOPS (8200);
9281 case 8300: return GET_LOOPS (8300);
9282 case 8400: return GET_LOOPS (8400);
9283 case 8500: return GET_LOOPS (8500);
9284 case 8600: return GET_LOOPS (8600);
9285 case 8700: return GET_LOOPS (8700);
9286 case 8800: return GET_LOOPS (8800);
9287 case 8900: return GET_LOOPS (8900);
9288 case 9000: return GET_LOOPS (9000);
9289 case 9100: return GET_LOOPS (9100);
9290 case 9200: return GET_LOOPS (9200);
9291 case 9300: return GET_LOOPS (9300);
9292 case 9400: return GET_LOOPS (9400);
9293 case 9500: return GET_LOOPS (9500);
9294 case 9600: return GET_LOOPS (9600);
9295 case 9700: return GET_LOOPS (9700);
9296 case 9710: return GET_LOOPS (9710);
9297 case 9720: return GET_LOOPS (9720);
9298 case 9800: return GET_LOOPS (9800);
9299 case 9810: return GET_LOOPS (9810);
9300 case 9820: return GET_LOOPS (9820);
9301 case 9900: return GET_LOOPS (9900);
9302 case 10000: return GET_LOOPS (10000);
9303 case 10100: return GET_LOOPS (10100);
9304 case 10200: return GET_LOOPS (10200);
9305 case 10300: return GET_LOOPS (10300);
9306 case 10400: return GET_LOOPS (10400);
9307 case 10410: return GET_LOOPS (10410);
9308 case 10420: return GET_LOOPS (10420);
9309 case 10500: return GET_LOOPS (10500);
9310 case 10600: return GET_LOOPS (10600);
9311 case 10700: return GET_LOOPS (10700);
9312 case 10800: return GET_LOOPS (10800);
9313 case 10900: return GET_LOOPS (10900);
9314 case 11000: return GET_LOOPS (11000);
9315 case 11100: return GET_LOOPS (11100);
9316 case 11200: return GET_LOOPS (11200);
9317 case 11300: return GET_LOOPS (11300);
9318 case 11400: return GET_LOOPS (11400);
9319 case 11500: return GET_LOOPS (11500);
9320 case 11600: return GET_LOOPS (11600);
9321 case 11700: return GET_LOOPS (11700);
9322 case 11800: return GET_LOOPS (11800);
9323 case 11900: return GET_LOOPS (11900);
9324 case 12000: return GET_LOOPS (12000);
9325 case 12100: return GET_LOOPS (12100);
9326 case 12200: return GET_LOOPS (12200);
9327 case 12300: return GET_LOOPS (12300);
9328 case 12400: return GET_LOOPS (12400);
9329 case 12500: return GET_LOOPS (12500);
9330 case 12600: return GET_LOOPS (12600);
9331 case 12700: return GET_LOOPS (12700);
9332 case 12800: return GET_LOOPS (12800);
9333 case 12900: return GET_LOOPS (12900);
9334 case 13000: return GET_LOOPS (13000);
9344 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9346 u8 tmp
[256] = { 0 };
9348 if (salt_len
> sizeof (tmp
))
9353 memcpy (tmp
, in
, salt_len
);
9355 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9357 if ((salt_len
% 2) == 0)
9359 u32 new_salt_len
= salt_len
/ 2;
9361 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9366 tmp
[i
] = hex_convert (p1
) << 0;
9367 tmp
[i
] |= hex_convert (p0
) << 4;
9370 salt_len
= new_salt_len
;
9377 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9379 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9382 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9384 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9388 u32
*tmp_uint
= (u32
*) tmp
;
9390 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9391 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9392 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9393 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9394 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9395 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9396 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9397 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9398 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9399 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9401 salt_len
= salt_len
* 2;
9409 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9411 lowercase (tmp
, salt_len
);
9414 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9416 uppercase (tmp
, salt_len
);
9421 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9426 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9431 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9433 u32
*tmp_uint
= (uint
*) tmp
;
9439 for (u32 i
= 0; i
< max
; i
++)
9441 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9444 // Important: we may need to increase the length of memcpy since
9445 // we don't want to "loose" some swapped bytes (could happen if
9446 // they do not perfectly fit in the 4-byte blocks)
9447 // Memcpy does always copy the bytes in the BE order, but since
9448 // we swapped them, some important bytes could be in positions
9449 // we normally skip with the original len
9451 if (len
% 4) len
+= 4 - (len
% 4);
9454 memcpy (out
, tmp
, len
);
9459 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9461 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9463 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9465 u32
*digest
= (u32
*) hash_buf
->digest
;
9467 salt_t
*salt
= hash_buf
->salt
;
9469 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9471 char *iter_pos
= input_buf
+ 4;
9473 salt
->salt_iter
= 1 << atoi (iter_pos
);
9475 char *salt_pos
= strchr (iter_pos
, '$');
9477 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9483 salt
->salt_len
= salt_len
;
9485 u8 tmp_buf
[100] = { 0 };
9487 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9489 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9491 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9493 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9494 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9495 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9496 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9498 char *hash_pos
= salt_pos
+ 22;
9500 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9502 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9504 memcpy (digest
, tmp_buf
, 24);
9506 digest
[0] = byte_swap_32 (digest
[0]);
9507 digest
[1] = byte_swap_32 (digest
[1]);
9508 digest
[2] = byte_swap_32 (digest
[2]);
9509 digest
[3] = byte_swap_32 (digest
[3]);
9510 digest
[4] = byte_swap_32 (digest
[4]);
9511 digest
[5] = byte_swap_32 (digest
[5]);
9513 digest
[5] &= ~0xff; // its just 23 not 24 !
9518 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9520 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9522 u32
*digest
= (u32
*) hash_buf
->digest
;
9524 u8 tmp_buf
[100] = { 0 };
9526 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9528 memcpy (digest
, tmp_buf
, 32);
9530 digest
[0] = byte_swap_32 (digest
[0]);
9531 digest
[1] = byte_swap_32 (digest
[1]);
9532 digest
[2] = byte_swap_32 (digest
[2]);
9533 digest
[3] = byte_swap_32 (digest
[3]);
9534 digest
[4] = byte_swap_32 (digest
[4]);
9535 digest
[5] = byte_swap_32 (digest
[5]);
9536 digest
[6] = byte_swap_32 (digest
[6]);
9537 digest
[7] = byte_swap_32 (digest
[7]);
9539 digest
[0] -= SHA256M_A
;
9540 digest
[1] -= SHA256M_B
;
9541 digest
[2] -= SHA256M_C
;
9542 digest
[3] -= SHA256M_D
;
9543 digest
[4] -= SHA256M_E
;
9544 digest
[5] -= SHA256M_F
;
9545 digest
[6] -= SHA256M_G
;
9546 digest
[7] -= SHA256M_H
;
9551 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9553 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9555 u32
*digest
= (u32
*) hash_buf
->digest
;
9557 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9558 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9560 digest
[0] = byte_swap_32 (digest
[0]);
9561 digest
[1] = byte_swap_32 (digest
[1]);
9565 IP (digest
[0], digest
[1], tt
);
9567 digest
[0] = digest
[0];
9568 digest
[1] = digest
[1];
9575 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9577 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9579 u32
*digest
= (u32
*) hash_buf
->digest
;
9581 salt_t
*salt
= hash_buf
->salt
;
9583 char *hash_pos
= input_buf
+ 8;
9585 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9586 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9587 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9588 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9589 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9591 digest
[0] -= SHA1M_A
;
9592 digest
[1] -= SHA1M_B
;
9593 digest
[2] -= SHA1M_C
;
9594 digest
[3] -= SHA1M_D
;
9595 digest
[4] -= SHA1M_E
;
9599 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9601 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9603 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9605 salt
->salt_len
= salt_len
;
9610 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9612 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9614 u64
*digest
= (u64
*) hash_buf
->digest
;
9616 salt_t
*salt
= hash_buf
->salt
;
9618 char *hash_pos
= input_buf
+ 8;
9620 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9621 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9622 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9623 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9624 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9625 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9626 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9627 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9629 digest
[0] -= SHA512M_A
;
9630 digest
[1] -= SHA512M_B
;
9631 digest
[2] -= SHA512M_C
;
9632 digest
[3] -= SHA512M_D
;
9633 digest
[4] -= SHA512M_E
;
9634 digest
[5] -= SHA512M_F
;
9635 digest
[6] -= SHA512M_G
;
9636 digest
[7] -= SHA512M_H
;
9640 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9642 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9644 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9646 salt
->salt_len
= salt_len
;
9651 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9653 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9655 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9659 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9662 u32
*digest
= (u32
*) hash_buf
->digest
;
9664 salt_t
*salt
= hash_buf
->salt
;
9666 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9667 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9668 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9669 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9671 digest
[0] = byte_swap_32 (digest
[0]);
9672 digest
[1] = byte_swap_32 (digest
[1]);
9673 digest
[2] = byte_swap_32 (digest
[2]);
9674 digest
[3] = byte_swap_32 (digest
[3]);
9676 digest
[0] -= MD5M_A
;
9677 digest
[1] -= MD5M_B
;
9678 digest
[2] -= MD5M_C
;
9679 digest
[3] -= MD5M_D
;
9681 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9683 uint salt_len
= input_len
- 32 - 1;
9685 char *salt_buf
= input_buf
+ 32 + 1;
9687 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9689 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9691 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9693 salt
->salt_len
= salt_len
;
9698 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9700 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9702 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9706 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9711 char clean_input_buf
[32] = { 0 };
9713 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9714 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9716 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9720 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9726 clean_input_buf
[k
] = input_buf
[i
];
9734 u32
*digest
= (u32
*) hash_buf
->digest
;
9736 salt_t
*salt
= hash_buf
->salt
;
9738 u32 a
, b
, c
, d
, e
, f
;
9740 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9741 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9742 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9743 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9744 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9745 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9747 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9748 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9750 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9751 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9752 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9753 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9754 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9755 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9757 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9758 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9760 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9761 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9762 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9763 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9764 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9765 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9767 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9768 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9770 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9771 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9772 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9773 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9774 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9775 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9777 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9778 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9780 digest
[0] = byte_swap_32 (digest
[0]);
9781 digest
[1] = byte_swap_32 (digest
[1]);
9782 digest
[2] = byte_swap_32 (digest
[2]);
9783 digest
[3] = byte_swap_32 (digest
[3]);
9785 digest
[0] -= MD5M_A
;
9786 digest
[1] -= MD5M_B
;
9787 digest
[2] -= MD5M_C
;
9788 digest
[3] -= MD5M_D
;
9790 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9792 uint salt_len
= input_len
- 30 - 1;
9794 char *salt_buf
= input_buf
+ 30 + 1;
9796 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9798 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9800 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9801 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9803 salt
->salt_len
= salt_len
;
9805 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9807 salt
->salt_len
+= 22;
9812 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9814 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9816 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9820 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9823 u32
*digest
= (u32
*) hash_buf
->digest
;
9825 salt_t
*salt
= hash_buf
->salt
;
9827 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9828 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9829 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9830 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9831 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9833 digest
[0] -= SHA1M_A
;
9834 digest
[1] -= SHA1M_B
;
9835 digest
[2] -= SHA1M_C
;
9836 digest
[3] -= SHA1M_D
;
9837 digest
[4] -= SHA1M_E
;
9839 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9841 uint salt_len
= input_len
- 40 - 1;
9843 char *salt_buf
= input_buf
+ 40 + 1;
9845 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9847 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9849 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9851 salt
->salt_len
= salt_len
;
9856 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9858 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9860 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9864 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9867 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9869 char *iter_pos
= input_buf
+ 6;
9871 salt_t
*salt
= hash_buf
->salt
;
9873 uint iter
= atoi (iter_pos
);
9880 salt
->salt_iter
= iter
- 1;
9882 char *salt_pos
= strchr (iter_pos
, '#');
9884 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9888 char *digest_pos
= strchr (salt_pos
, '#');
9890 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9894 uint salt_len
= digest_pos
- salt_pos
- 1;
9896 u32
*digest
= (u32
*) hash_buf
->digest
;
9898 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9899 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9900 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9901 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9903 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9905 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9907 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9909 salt
->salt_len
= salt_len
;
9914 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9916 u32
*digest
= (u32
*) hash_buf
->digest
;
9918 salt_t
*salt
= hash_buf
->salt
;
9920 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9924 memcpy (&in
, input_buf
, input_len
);
9926 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9928 memcpy (digest
, in
.keymic
, 16);
9931 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9932 The phrase "Pairwise key expansion"
9933 Access Point Address (referred to as Authenticator Address AA)
9934 Supplicant Address (referred to as Supplicant Address SA)
9935 Access Point Nonce (referred to as Authenticator Anonce)
9936 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9939 uint salt_len
= strlen (in
.essid
);
9941 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9943 salt
->salt_len
= salt_len
;
9945 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9947 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9949 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9951 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9953 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9954 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9958 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9959 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9962 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9964 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9965 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9969 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9970 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9973 for (int i
= 0; i
< 25; i
++)
9975 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9978 wpa
->keyver
= in
.keyver
;
9980 if (wpa
->keyver
> 255)
9982 log_info ("ATTENTION!");
9983 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9984 log_info (" This could be due to a recent aircrack-ng bug.");
9985 log_info (" The key version was automatically reset to a reasonable value.");
9988 wpa
->keyver
&= 0xff;
9991 wpa
->eapol_size
= in
.eapol_size
;
9993 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
9995 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
9997 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
9999 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10001 if (wpa
->keyver
== 1)
10007 digest
[0] = byte_swap_32 (digest
[0]);
10008 digest
[1] = byte_swap_32 (digest
[1]);
10009 digest
[2] = byte_swap_32 (digest
[2]);
10010 digest
[3] = byte_swap_32 (digest
[3]);
10012 for (int i
= 0; i
< 64; i
++)
10014 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10018 salt
->salt_buf
[10] = digest
[1];
10019 salt
->salt_buf
[11] = digest
[2];
10021 return (PARSER_OK
);
10024 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10026 u32
*digest
= (u32
*) hash_buf
->digest
;
10028 salt_t
*salt
= hash_buf
->salt
;
10030 if (input_len
== 0)
10032 log_error ("Password Safe v2 container not specified");
10037 FILE *fp
= fopen (input_buf
, "rb");
10041 log_error ("%s: %s", input_buf
, strerror (errno
));
10048 memset (&buf
, 0, sizeof (psafe2_hdr
));
10050 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10054 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10056 salt
->salt_buf
[0] = buf
.random
[0];
10057 salt
->salt_buf
[1] = buf
.random
[1];
10059 salt
->salt_len
= 8;
10060 salt
->salt_iter
= 1000;
10062 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10063 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10064 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10065 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10066 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10068 return (PARSER_OK
);
10071 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10073 u32
*digest
= (u32
*) hash_buf
->digest
;
10075 salt_t
*salt
= hash_buf
->salt
;
10077 if (input_len
== 0)
10079 log_error (".psafe3 not specified");
10084 FILE *fp
= fopen (input_buf
, "rb");
10088 log_error ("%s: %s", input_buf
, strerror (errno
));
10095 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10099 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10101 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10103 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10105 salt
->salt_iter
= in
.iterations
+ 1;
10107 salt
->salt_buf
[0] = in
.salt_buf
[0];
10108 salt
->salt_buf
[1] = in
.salt_buf
[1];
10109 salt
->salt_buf
[2] = in
.salt_buf
[2];
10110 salt
->salt_buf
[3] = in
.salt_buf
[3];
10111 salt
->salt_buf
[4] = in
.salt_buf
[4];
10112 salt
->salt_buf
[5] = in
.salt_buf
[5];
10113 salt
->salt_buf
[6] = in
.salt_buf
[6];
10114 salt
->salt_buf
[7] = in
.salt_buf
[7];
10116 salt
->salt_len
= 32;
10118 digest
[0] = in
.hash_buf
[0];
10119 digest
[1] = in
.hash_buf
[1];
10120 digest
[2] = in
.hash_buf
[2];
10121 digest
[3] = in
.hash_buf
[3];
10122 digest
[4] = in
.hash_buf
[4];
10123 digest
[5] = in
.hash_buf
[5];
10124 digest
[6] = in
.hash_buf
[6];
10125 digest
[7] = in
.hash_buf
[7];
10127 digest
[0] = byte_swap_32 (digest
[0]);
10128 digest
[1] = byte_swap_32 (digest
[1]);
10129 digest
[2] = byte_swap_32 (digest
[2]);
10130 digest
[3] = byte_swap_32 (digest
[3]);
10131 digest
[4] = byte_swap_32 (digest
[4]);
10132 digest
[5] = byte_swap_32 (digest
[5]);
10133 digest
[6] = byte_swap_32 (digest
[6]);
10134 digest
[7] = byte_swap_32 (digest
[7]);
10136 return (PARSER_OK
);
10139 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10141 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10143 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10145 u32
*digest
= (u32
*) hash_buf
->digest
;
10147 salt_t
*salt
= hash_buf
->salt
;
10149 char *iter_pos
= input_buf
+ 3;
10151 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10153 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10155 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10157 salt
->salt_iter
= salt_iter
;
10159 char *salt_pos
= iter_pos
+ 1;
10163 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10165 salt
->salt_len
= salt_len
;
10167 char *hash_pos
= salt_pos
+ salt_len
;
10169 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10171 return (PARSER_OK
);
10174 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10176 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10178 u32
*digest
= (u32
*) hash_buf
->digest
;
10180 salt_t
*salt
= hash_buf
->salt
;
10182 char *salt_pos
= input_buf
+ 3;
10184 uint iterations_len
= 0;
10186 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10190 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10192 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10193 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10197 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10201 iterations_len
+= 8;
10205 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10208 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10210 char *hash_pos
= strchr (salt_pos
, '$');
10212 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10214 uint salt_len
= hash_pos
- salt_pos
;
10216 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10218 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10220 salt
->salt_len
= salt_len
;
10224 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10226 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10228 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10230 return (PARSER_OK
);
10233 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10235 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10237 u32
*digest
= (u32
*) hash_buf
->digest
;
10239 salt_t
*salt
= hash_buf
->salt
;
10241 char *salt_pos
= input_buf
+ 6;
10243 uint iterations_len
= 0;
10245 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10249 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10251 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10252 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10256 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10260 iterations_len
+= 8;
10264 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10267 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10269 char *hash_pos
= strchr (salt_pos
, '$');
10271 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10273 uint salt_len
= hash_pos
- salt_pos
;
10275 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10277 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10279 salt
->salt_len
= salt_len
;
10283 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10285 return (PARSER_OK
);
10288 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10290 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10292 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10294 u32
*digest
= (u32
*) hash_buf
->digest
;
10296 salt_t
*salt
= hash_buf
->salt
;
10298 char *salt_pos
= input_buf
+ 14;
10300 char *hash_pos
= strchr (salt_pos
, '*');
10302 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10306 uint salt_len
= hash_pos
- salt_pos
- 1;
10308 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10310 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10312 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10314 salt
->salt_len
= salt_len
;
10316 u8 tmp_buf
[100] = { 0 };
10318 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10320 memcpy (digest
, tmp_buf
, 20);
10322 digest
[0] = byte_swap_32 (digest
[0]);
10323 digest
[1] = byte_swap_32 (digest
[1]);
10324 digest
[2] = byte_swap_32 (digest
[2]);
10325 digest
[3] = byte_swap_32 (digest
[3]);
10326 digest
[4] = byte_swap_32 (digest
[4]);
10328 digest
[0] -= SHA1M_A
;
10329 digest
[1] -= SHA1M_B
;
10330 digest
[2] -= SHA1M_C
;
10331 digest
[3] -= SHA1M_D
;
10332 digest
[4] -= SHA1M_E
;
10334 return (PARSER_OK
);
10337 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10339 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10341 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10343 if (c12
& 3) return (PARSER_HASH_VALUE
);
10345 u32
*digest
= (u32
*) hash_buf
->digest
;
10347 salt_t
*salt
= hash_buf
->salt
;
10349 // for ascii_digest
10350 salt
->salt_sign
[0] = input_buf
[0];
10351 salt
->salt_sign
[1] = input_buf
[1];
10353 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10354 | itoa64_to_int (input_buf
[1]) << 6;
10356 salt
->salt_len
= 2;
10358 u8 tmp_buf
[100] = { 0 };
10360 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10362 memcpy (digest
, tmp_buf
, 8);
10366 IP (digest
[0], digest
[1], tt
);
10371 return (PARSER_OK
);
10374 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10376 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10378 u32
*digest
= (u32
*) hash_buf
->digest
;
10380 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10381 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10382 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10383 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10385 digest
[0] = byte_swap_32 (digest
[0]);
10386 digest
[1] = byte_swap_32 (digest
[1]);
10387 digest
[2] = byte_swap_32 (digest
[2]);
10388 digest
[3] = byte_swap_32 (digest
[3]);
10390 digest
[0] -= MD4M_A
;
10391 digest
[1] -= MD4M_B
;
10392 digest
[2] -= MD4M_C
;
10393 digest
[3] -= MD4M_D
;
10395 return (PARSER_OK
);
10398 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10400 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10402 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10406 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10409 u32
*digest
= (u32
*) hash_buf
->digest
;
10411 salt_t
*salt
= hash_buf
->salt
;
10413 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10414 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10415 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10416 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10418 digest
[0] = byte_swap_32 (digest
[0]);
10419 digest
[1] = byte_swap_32 (digest
[1]);
10420 digest
[2] = byte_swap_32 (digest
[2]);
10421 digest
[3] = byte_swap_32 (digest
[3]);
10423 digest
[0] -= MD4M_A
;
10424 digest
[1] -= MD4M_B
;
10425 digest
[2] -= MD4M_C
;
10426 digest
[3] -= MD4M_D
;
10428 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10430 uint salt_len
= input_len
- 32 - 1;
10432 char *salt_buf
= input_buf
+ 32 + 1;
10434 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10436 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10438 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10440 salt
->salt_len
= salt_len
;
10442 return (PARSER_OK
);
10445 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10447 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10449 u32
*digest
= (u32
*) hash_buf
->digest
;
10451 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10452 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10453 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10454 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10456 digest
[0] = byte_swap_32 (digest
[0]);
10457 digest
[1] = byte_swap_32 (digest
[1]);
10458 digest
[2] = byte_swap_32 (digest
[2]);
10459 digest
[3] = byte_swap_32 (digest
[3]);
10461 digest
[0] -= MD5M_A
;
10462 digest
[1] -= MD5M_B
;
10463 digest
[2] -= MD5M_C
;
10464 digest
[3] -= MD5M_D
;
10466 return (PARSER_OK
);
10469 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10471 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10473 u32
*digest
= (u32
*) hash_buf
->digest
;
10475 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10476 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10480 digest
[0] = byte_swap_32 (digest
[0]);
10481 digest
[1] = byte_swap_32 (digest
[1]);
10483 return (PARSER_OK
);
10486 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10488 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10490 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10494 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10497 u32
*digest
= (u32
*) hash_buf
->digest
;
10499 salt_t
*salt
= hash_buf
->salt
;
10501 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10502 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10503 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10504 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10506 digest
[0] = byte_swap_32 (digest
[0]);
10507 digest
[1] = byte_swap_32 (digest
[1]);
10508 digest
[2] = byte_swap_32 (digest
[2]);
10509 digest
[3] = byte_swap_32 (digest
[3]);
10511 digest
[0] -= MD5M_A
;
10512 digest
[1] -= MD5M_B
;
10513 digest
[2] -= MD5M_C
;
10514 digest
[3] -= MD5M_D
;
10516 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10518 uint salt_len
= input_len
- 32 - 1;
10520 char *salt_buf
= input_buf
+ 32 + 1;
10522 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10524 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10526 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10528 salt
->salt_len
= salt_len
;
10530 return (PARSER_OK
);
10533 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10535 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10537 u32
*digest
= (u32
*) hash_buf
->digest
;
10539 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10540 | itoa64_to_int (input_buf
[ 1]) << 6
10541 | itoa64_to_int (input_buf
[ 2]) << 12
10542 | itoa64_to_int (input_buf
[ 3]) << 18;
10543 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10544 | itoa64_to_int (input_buf
[ 5]) << 6
10545 | itoa64_to_int (input_buf
[ 6]) << 12
10546 | itoa64_to_int (input_buf
[ 7]) << 18;
10547 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10548 | itoa64_to_int (input_buf
[ 9]) << 6
10549 | itoa64_to_int (input_buf
[10]) << 12
10550 | itoa64_to_int (input_buf
[11]) << 18;
10551 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10552 | itoa64_to_int (input_buf
[13]) << 6
10553 | itoa64_to_int (input_buf
[14]) << 12
10554 | itoa64_to_int (input_buf
[15]) << 18;
10556 digest
[0] -= MD5M_A
;
10557 digest
[1] -= MD5M_B
;
10558 digest
[2] -= MD5M_C
;
10559 digest
[3] -= MD5M_D
;
10561 digest
[0] &= 0x00ffffff;
10562 digest
[1] &= 0x00ffffff;
10563 digest
[2] &= 0x00ffffff;
10564 digest
[3] &= 0x00ffffff;
10566 return (PARSER_OK
);
10569 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10571 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10573 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10577 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10580 u32
*digest
= (u32
*) hash_buf
->digest
;
10582 salt_t
*salt
= hash_buf
->salt
;
10584 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10585 | itoa64_to_int (input_buf
[ 1]) << 6
10586 | itoa64_to_int (input_buf
[ 2]) << 12
10587 | itoa64_to_int (input_buf
[ 3]) << 18;
10588 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10589 | itoa64_to_int (input_buf
[ 5]) << 6
10590 | itoa64_to_int (input_buf
[ 6]) << 12
10591 | itoa64_to_int (input_buf
[ 7]) << 18;
10592 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10593 | itoa64_to_int (input_buf
[ 9]) << 6
10594 | itoa64_to_int (input_buf
[10]) << 12
10595 | itoa64_to_int (input_buf
[11]) << 18;
10596 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10597 | itoa64_to_int (input_buf
[13]) << 6
10598 | itoa64_to_int (input_buf
[14]) << 12
10599 | itoa64_to_int (input_buf
[15]) << 18;
10601 digest
[0] -= MD5M_A
;
10602 digest
[1] -= MD5M_B
;
10603 digest
[2] -= MD5M_C
;
10604 digest
[3] -= MD5M_D
;
10606 digest
[0] &= 0x00ffffff;
10607 digest
[1] &= 0x00ffffff;
10608 digest
[2] &= 0x00ffffff;
10609 digest
[3] &= 0x00ffffff;
10611 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10613 uint salt_len
= input_len
- 16 - 1;
10615 char *salt_buf
= input_buf
+ 16 + 1;
10617 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10619 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10621 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10623 salt
->salt_len
= salt_len
;
10625 return (PARSER_OK
);
10628 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10630 key
[0] = (nthash
[0] >> 0);
10631 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10632 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10633 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10634 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10635 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10636 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10637 key
[7] = (nthash
[6] << 1);
10649 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10651 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10653 u32
*digest
= (u32
*) hash_buf
->digest
;
10655 salt_t
*salt
= hash_buf
->salt
;
10657 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10663 char *user_pos
= input_buf
;
10665 char *unused_pos
= strchr (user_pos
, ':');
10667 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10669 uint user_len
= unused_pos
- user_pos
;
10671 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10675 char *domain_pos
= strchr (unused_pos
, ':');
10677 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10679 uint unused_len
= domain_pos
- unused_pos
;
10681 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10685 char *srvchall_pos
= strchr (domain_pos
, ':');
10687 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10689 uint domain_len
= srvchall_pos
- domain_pos
;
10691 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10695 char *hash_pos
= strchr (srvchall_pos
, ':');
10697 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10699 uint srvchall_len
= hash_pos
- srvchall_pos
;
10701 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10705 char *clichall_pos
= strchr (hash_pos
, ':');
10707 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10709 uint hash_len
= clichall_pos
- hash_pos
;
10711 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10715 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10717 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10720 * store some data for later use
10723 netntlm
->user_len
= user_len
* 2;
10724 netntlm
->domain_len
= domain_len
* 2;
10725 netntlm
->srvchall_len
= srvchall_len
/ 2;
10726 netntlm
->clichall_len
= clichall_len
/ 2;
10728 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10729 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10732 * handle username and domainname
10735 for (uint i
= 0; i
< user_len
; i
++)
10737 *userdomain_ptr
++ = user_pos
[i
];
10738 *userdomain_ptr
++ = 0;
10741 for (uint i
= 0; i
< domain_len
; i
++)
10743 *userdomain_ptr
++ = domain_pos
[i
];
10744 *userdomain_ptr
++ = 0;
10748 * handle server challenge encoding
10751 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10753 const char p0
= srvchall_pos
[i
+ 0];
10754 const char p1
= srvchall_pos
[i
+ 1];
10756 *chall_ptr
++ = hex_convert (p1
) << 0
10757 | hex_convert (p0
) << 4;
10761 * handle client challenge encoding
10764 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10766 const char p0
= clichall_pos
[i
+ 0];
10767 const char p1
= clichall_pos
[i
+ 1];
10769 *chall_ptr
++ = hex_convert (p1
) << 0
10770 | hex_convert (p0
) << 4;
10777 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10779 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10781 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10783 salt
->salt_len
= salt_len
;
10785 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10786 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10787 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10788 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10790 digest
[0] = byte_swap_32 (digest
[0]);
10791 digest
[1] = byte_swap_32 (digest
[1]);
10792 digest
[2] = byte_swap_32 (digest
[2]);
10793 digest
[3] = byte_swap_32 (digest
[3]);
10795 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10797 uint digest_tmp
[2] = { 0 };
10799 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10800 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10802 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10803 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10805 /* special case 2: ESS */
10807 if (srvchall_len
== 48)
10809 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10811 uint w
[16] = { 0 };
10813 w
[ 0] = netntlm
->chall_buf
[6];
10814 w
[ 1] = netntlm
->chall_buf
[7];
10815 w
[ 2] = netntlm
->chall_buf
[0];
10816 w
[ 3] = netntlm
->chall_buf
[1];
10820 uint dgst
[4] = { 0 };
10829 salt
->salt_buf
[0] = dgst
[0];
10830 salt
->salt_buf
[1] = dgst
[1];
10834 /* precompute netntlmv1 exploit start */
10836 for (uint i
= 0; i
< 0x10000; i
++)
10838 uint key_md4
[2] = { i
, 0 };
10839 uint key_des
[2] = { 0, 0 };
10841 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10843 uint Kc
[16] = { 0 };
10844 uint Kd
[16] = { 0 };
10846 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10848 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10850 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10852 if (data3
[0] != digest_tmp
[0]) continue;
10853 if (data3
[1] != digest_tmp
[1]) continue;
10855 salt
->salt_buf
[2] = i
;
10857 salt
->salt_len
= 24;
10862 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10863 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10865 /* precompute netntlmv1 exploit stop */
10869 IP (digest
[0], digest
[1], tt
);
10870 IP (digest
[2], digest
[3], tt
);
10872 digest
[0] = rotr32 (digest
[0], 29);
10873 digest
[1] = rotr32 (digest
[1], 29);
10874 digest
[2] = rotr32 (digest
[2], 29);
10875 digest
[3] = rotr32 (digest
[3], 29);
10877 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10879 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10880 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10882 return (PARSER_OK
);
10885 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10887 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10889 u32
*digest
= (u32
*) hash_buf
->digest
;
10891 salt_t
*salt
= hash_buf
->salt
;
10893 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10899 char *user_pos
= input_buf
;
10901 char *unused_pos
= strchr (user_pos
, ':');
10903 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10905 uint user_len
= unused_pos
- user_pos
;
10907 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10911 char *domain_pos
= strchr (unused_pos
, ':');
10913 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10915 uint unused_len
= domain_pos
- unused_pos
;
10917 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10921 char *srvchall_pos
= strchr (domain_pos
, ':');
10923 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10925 uint domain_len
= srvchall_pos
- domain_pos
;
10927 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10931 char *hash_pos
= strchr (srvchall_pos
, ':');
10933 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10935 uint srvchall_len
= hash_pos
- srvchall_pos
;
10937 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10941 char *clichall_pos
= strchr (hash_pos
, ':');
10943 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10945 uint hash_len
= clichall_pos
- hash_pos
;
10947 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10951 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10953 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10955 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10958 * store some data for later use
10961 netntlm
->user_len
= user_len
* 2;
10962 netntlm
->domain_len
= domain_len
* 2;
10963 netntlm
->srvchall_len
= srvchall_len
/ 2;
10964 netntlm
->clichall_len
= clichall_len
/ 2;
10966 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10967 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10970 * handle username and domainname
10973 for (uint i
= 0; i
< user_len
; i
++)
10975 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10976 *userdomain_ptr
++ = 0;
10979 for (uint i
= 0; i
< domain_len
; i
++)
10981 *userdomain_ptr
++ = domain_pos
[i
];
10982 *userdomain_ptr
++ = 0;
10985 *userdomain_ptr
++ = 0x80;
10988 * handle server challenge encoding
10991 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10993 const char p0
= srvchall_pos
[i
+ 0];
10994 const char p1
= srvchall_pos
[i
+ 1];
10996 *chall_ptr
++ = hex_convert (p1
) << 0
10997 | hex_convert (p0
) << 4;
11001 * handle client challenge encoding
11004 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11006 const char p0
= clichall_pos
[i
+ 0];
11007 const char p1
= clichall_pos
[i
+ 1];
11009 *chall_ptr
++ = hex_convert (p1
) << 0
11010 | hex_convert (p0
) << 4;
11013 *chall_ptr
++ = 0x80;
11016 * handle hash itself
11019 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11020 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11021 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11022 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11024 digest
[0] = byte_swap_32 (digest
[0]);
11025 digest
[1] = byte_swap_32 (digest
[1]);
11026 digest
[2] = byte_swap_32 (digest
[2]);
11027 digest
[3] = byte_swap_32 (digest
[3]);
11030 * reuse challange data as salt_buf, its the buffer that is most likely unique
11033 salt
->salt_buf
[0] = 0;
11034 salt
->salt_buf
[1] = 0;
11035 salt
->salt_buf
[2] = 0;
11036 salt
->salt_buf
[3] = 0;
11037 salt
->salt_buf
[4] = 0;
11038 salt
->salt_buf
[5] = 0;
11039 salt
->salt_buf
[6] = 0;
11040 salt
->salt_buf
[7] = 0;
11044 uptr
= (uint
*) netntlm
->userdomain_buf
;
11046 for (uint i
= 0; i
< 16; i
+= 16)
11048 md5_64 (uptr
, salt
->salt_buf
);
11051 uptr
= (uint
*) netntlm
->chall_buf
;
11053 for (uint i
= 0; i
< 256; i
+= 16)
11055 md5_64 (uptr
, salt
->salt_buf
);
11058 salt
->salt_len
= 16;
11060 return (PARSER_OK
);
11063 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11065 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11067 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11071 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11074 u32
*digest
= (u32
*) hash_buf
->digest
;
11076 salt_t
*salt
= hash_buf
->salt
;
11078 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11079 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11080 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11081 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11083 digest
[0] = byte_swap_32 (digest
[0]);
11084 digest
[1] = byte_swap_32 (digest
[1]);
11085 digest
[2] = byte_swap_32 (digest
[2]);
11086 digest
[3] = byte_swap_32 (digest
[3]);
11088 digest
[0] -= MD5M_A
;
11089 digest
[1] -= MD5M_B
;
11090 digest
[2] -= MD5M_C
;
11091 digest
[3] -= MD5M_D
;
11093 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11095 uint salt_len
= input_len
- 32 - 1;
11097 char *salt_buf
= input_buf
+ 32 + 1;
11099 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11101 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11103 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11105 salt
->salt_len
= salt_len
;
11107 return (PARSER_OK
);
11110 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11112 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11114 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11118 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11121 u32
*digest
= (u32
*) hash_buf
->digest
;
11123 salt_t
*salt
= hash_buf
->salt
;
11125 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11126 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11127 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11128 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11130 digest
[0] = byte_swap_32 (digest
[0]);
11131 digest
[1] = byte_swap_32 (digest
[1]);
11132 digest
[2] = byte_swap_32 (digest
[2]);
11133 digest
[3] = byte_swap_32 (digest
[3]);
11135 digest
[0] -= MD5M_A
;
11136 digest
[1] -= MD5M_B
;
11137 digest
[2] -= MD5M_C
;
11138 digest
[3] -= MD5M_D
;
11140 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11142 uint salt_len
= input_len
- 32 - 1;
11144 char *salt_buf
= input_buf
+ 32 + 1;
11146 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11148 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11150 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11152 salt
->salt_len
= salt_len
;
11154 return (PARSER_OK
);
11157 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11159 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11161 u32
*digest
= (u32
*) hash_buf
->digest
;
11163 salt_t
*salt
= hash_buf
->salt
;
11165 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11166 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11167 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11168 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11170 digest
[0] = byte_swap_32 (digest
[0]);
11171 digest
[1] = byte_swap_32 (digest
[1]);
11172 digest
[2] = byte_swap_32 (digest
[2]);
11173 digest
[3] = byte_swap_32 (digest
[3]);
11175 digest
[0] -= MD5M_A
;
11176 digest
[1] -= MD5M_B
;
11177 digest
[2] -= MD5M_C
;
11178 digest
[3] -= MD5M_D
;
11181 * This is a virtual salt. While the algorithm is basically not salted
11182 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11183 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11186 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11188 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11190 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11192 salt
->salt_len
= salt_len
;
11194 return (PARSER_OK
);
11197 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11199 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11201 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11205 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11208 u32
*digest
= (u32
*) hash_buf
->digest
;
11210 salt_t
*salt
= hash_buf
->salt
;
11212 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11213 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11214 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11215 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11217 digest
[0] = byte_swap_32 (digest
[0]);
11218 digest
[1] = byte_swap_32 (digest
[1]);
11219 digest
[2] = byte_swap_32 (digest
[2]);
11220 digest
[3] = byte_swap_32 (digest
[3]);
11222 digest
[0] -= MD5M_A
;
11223 digest
[1] -= MD5M_B
;
11224 digest
[2] -= MD5M_C
;
11225 digest
[3] -= MD5M_D
;
11227 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11229 uint salt_len
= input_len
- 32 - 1;
11231 char *salt_buf
= input_buf
+ 32 + 1;
11233 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11235 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11237 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11239 salt
->salt_len
= salt_len
;
11241 return (PARSER_OK
);
11244 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11246 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11248 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11252 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11255 u32
*digest
= (u32
*) hash_buf
->digest
;
11257 salt_t
*salt
= hash_buf
->salt
;
11259 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11260 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11261 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11262 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11264 digest
[0] = byte_swap_32 (digest
[0]);
11265 digest
[1] = byte_swap_32 (digest
[1]);
11266 digest
[2] = byte_swap_32 (digest
[2]);
11267 digest
[3] = byte_swap_32 (digest
[3]);
11269 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11271 uint salt_len
= input_len
- 32 - 1;
11273 char *salt_buf
= input_buf
+ 32 + 1;
11275 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11277 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11279 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11281 salt
->salt_len
= salt_len
;
11283 return (PARSER_OK
);
11286 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11288 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11290 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11294 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11297 u32
*digest
= (u32
*) hash_buf
->digest
;
11299 salt_t
*salt
= hash_buf
->salt
;
11301 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11302 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11303 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11304 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11306 digest
[0] = byte_swap_32 (digest
[0]);
11307 digest
[1] = byte_swap_32 (digest
[1]);
11308 digest
[2] = byte_swap_32 (digest
[2]);
11309 digest
[3] = byte_swap_32 (digest
[3]);
11311 digest
[0] -= MD4M_A
;
11312 digest
[1] -= MD4M_B
;
11313 digest
[2] -= MD4M_C
;
11314 digest
[3] -= MD4M_D
;
11316 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11318 uint salt_len
= input_len
- 32 - 1;
11320 char *salt_buf
= input_buf
+ 32 + 1;
11322 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11324 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11326 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11328 salt
->salt_len
= salt_len
;
11330 return (PARSER_OK
);
11333 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11335 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11337 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11341 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11344 u32
*digest
= (u32
*) hash_buf
->digest
;
11346 salt_t
*salt
= hash_buf
->salt
;
11348 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11349 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11350 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11351 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11353 digest
[0] = byte_swap_32 (digest
[0]);
11354 digest
[1] = byte_swap_32 (digest
[1]);
11355 digest
[2] = byte_swap_32 (digest
[2]);
11356 digest
[3] = byte_swap_32 (digest
[3]);
11358 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11360 uint salt_len
= input_len
- 32 - 1;
11362 char *salt_buf
= input_buf
+ 32 + 1;
11364 uint salt_pc_block
[16] = { 0 };
11366 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11368 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11370 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11372 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11374 salt_pc_block
[14] = salt_len
* 8;
11376 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11378 md5_64 (salt_pc_block
, salt_pc_digest
);
11380 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11381 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11382 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11383 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11385 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11387 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11389 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11391 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11392 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11393 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11394 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11396 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11398 return (PARSER_OK
);
11401 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11403 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11405 u32
*digest
= (u32
*) hash_buf
->digest
;
11407 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11408 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11409 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11410 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11411 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11413 digest
[0] -= SHA1M_A
;
11414 digest
[1] -= SHA1M_B
;
11415 digest
[2] -= SHA1M_C
;
11416 digest
[3] -= SHA1M_D
;
11417 digest
[4] -= SHA1M_E
;
11419 return (PARSER_OK
);
11422 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11424 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11426 u32
*digest
= (u32
*) hash_buf
->digest
;
11428 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11429 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11430 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11431 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11432 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11434 return (PARSER_OK
);
11437 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11439 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11441 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11445 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11448 u32
*digest
= (u32
*) hash_buf
->digest
;
11450 salt_t
*salt
= hash_buf
->salt
;
11452 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11453 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11454 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11455 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11456 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11458 digest
[0] -= SHA1M_A
;
11459 digest
[1] -= SHA1M_B
;
11460 digest
[2] -= SHA1M_C
;
11461 digest
[3] -= SHA1M_D
;
11462 digest
[4] -= SHA1M_E
;
11464 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11466 uint salt_len
= input_len
- 40 - 1;
11468 char *salt_buf
= input_buf
+ 40 + 1;
11470 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11472 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11474 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11476 salt
->salt_len
= salt_len
;
11478 return (PARSER_OK
);
11481 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11483 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11485 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11487 u32
*digest
= (u32
*) hash_buf
->digest
;
11489 u8 tmp_buf
[100] = { 0 };
11491 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11493 memcpy (digest
, tmp_buf
, 20);
11495 digest
[0] = byte_swap_32 (digest
[0]);
11496 digest
[1] = byte_swap_32 (digest
[1]);
11497 digest
[2] = byte_swap_32 (digest
[2]);
11498 digest
[3] = byte_swap_32 (digest
[3]);
11499 digest
[4] = byte_swap_32 (digest
[4]);
11501 digest
[0] -= SHA1M_A
;
11502 digest
[1] -= SHA1M_B
;
11503 digest
[2] -= SHA1M_C
;
11504 digest
[3] -= SHA1M_D
;
11505 digest
[4] -= SHA1M_E
;
11507 return (PARSER_OK
);
11510 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11512 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11514 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11516 u32
*digest
= (u32
*) hash_buf
->digest
;
11518 salt_t
*salt
= hash_buf
->salt
;
11520 u8 tmp_buf
[100] = { 0 };
11522 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11524 memcpy (digest
, tmp_buf
, 20);
11526 salt
->salt_len
= tmp_len
- 20;
11528 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11530 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11532 char *ptr
= (char *) salt
->salt_buf
;
11534 ptr
[salt
->salt_len
] = 0x80;
11537 digest
[0] = byte_swap_32 (digest
[0]);
11538 digest
[1] = byte_swap_32 (digest
[1]);
11539 digest
[2] = byte_swap_32 (digest
[2]);
11540 digest
[3] = byte_swap_32 (digest
[3]);
11541 digest
[4] = byte_swap_32 (digest
[4]);
11543 digest
[0] -= SHA1M_A
;
11544 digest
[1] -= SHA1M_B
;
11545 digest
[2] -= SHA1M_C
;
11546 digest
[3] -= SHA1M_D
;
11547 digest
[4] -= SHA1M_E
;
11549 return (PARSER_OK
);
11552 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11554 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11556 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11558 u32
*digest
= (u32
*) hash_buf
->digest
;
11560 salt_t
*salt
= hash_buf
->salt
;
11562 char *salt_buf
= input_buf
+ 6;
11566 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11568 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11570 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11572 salt
->salt_len
= salt_len
;
11574 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11576 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11577 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11578 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11579 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11580 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11582 digest
[0] -= SHA1M_A
;
11583 digest
[1] -= SHA1M_B
;
11584 digest
[2] -= SHA1M_C
;
11585 digest
[3] -= SHA1M_D
;
11586 digest
[4] -= SHA1M_E
;
11588 return (PARSER_OK
);
11591 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11593 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11595 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11597 u32
*digest
= (u32
*) hash_buf
->digest
;
11599 salt_t
*salt
= hash_buf
->salt
;
11601 char *salt_buf
= input_buf
+ 6;
11605 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11607 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11609 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11611 salt
->salt_len
= salt_len
;
11613 char *hash_pos
= input_buf
+ 6 + 8;
11615 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11616 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11617 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11618 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11619 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11621 digest
[0] -= SHA1M_A
;
11622 digest
[1] -= SHA1M_B
;
11623 digest
[2] -= SHA1M_C
;
11624 digest
[3] -= SHA1M_D
;
11625 digest
[4] -= SHA1M_E
;
11627 return (PARSER_OK
);
11630 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11632 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11634 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11636 u64
*digest
= (u64
*) hash_buf
->digest
;
11638 salt_t
*salt
= hash_buf
->salt
;
11640 char *salt_buf
= input_buf
+ 6;
11644 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11646 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11648 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11650 salt
->salt_len
= salt_len
;
11652 char *hash_pos
= input_buf
+ 6 + 8;
11654 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11655 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11656 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11657 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11658 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11659 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11660 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11661 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11663 digest
[0] -= SHA512M_A
;
11664 digest
[1] -= SHA512M_B
;
11665 digest
[2] -= SHA512M_C
;
11666 digest
[3] -= SHA512M_D
;
11667 digest
[4] -= SHA512M_E
;
11668 digest
[5] -= SHA512M_F
;
11669 digest
[6] -= SHA512M_G
;
11670 digest
[7] -= SHA512M_H
;
11672 return (PARSER_OK
);
11675 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11677 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11679 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11683 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11686 u32
*digest
= (u32
*) hash_buf
->digest
;
11688 salt_t
*salt
= hash_buf
->salt
;
11690 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11691 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11695 digest
[0] = byte_swap_32 (digest
[0]);
11696 digest
[1] = byte_swap_32 (digest
[1]);
11698 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11700 uint salt_len
= input_len
- 16 - 1;
11702 char *salt_buf
= input_buf
+ 16 + 1;
11704 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11706 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11708 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11710 salt
->salt_len
= salt_len
;
11712 return (PARSER_OK
);
11715 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11717 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11719 u32
*digest
= (u32
*) hash_buf
->digest
;
11721 salt_t
*salt
= hash_buf
->salt
;
11723 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11724 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11725 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11726 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11727 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11729 digest
[0] -= SHA1M_A
;
11730 digest
[1] -= SHA1M_B
;
11731 digest
[2] -= SHA1M_C
;
11732 digest
[3] -= SHA1M_D
;
11733 digest
[4] -= SHA1M_E
;
11735 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11737 uint salt_len
= input_len
- 40 - 1;
11739 char *salt_buf
= input_buf
+ 40 + 1;
11741 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11743 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11745 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11747 salt
->salt_len
= salt_len
;
11749 return (PARSER_OK
);
11752 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11754 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11756 u32
*digest
= (u32
*) hash_buf
->digest
;
11758 salt_t
*salt
= hash_buf
->salt
;
11760 char *hash_pos
= input_buf
;
11762 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11763 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11764 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11765 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11766 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11767 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11768 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11769 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11770 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11771 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11772 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11773 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11774 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11775 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11776 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11777 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11779 char *salt_pos
= input_buf
+ 128;
11781 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11782 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11783 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11784 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11786 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11787 salt
->salt_len
= 16;
11789 return (PARSER_OK
);
11792 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11794 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11796 u32
*digest
= (u32
*) hash_buf
->digest
;
11798 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11799 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11800 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11801 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11802 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11803 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11804 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11805 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11807 digest
[0] -= SHA256M_A
;
11808 digest
[1] -= SHA256M_B
;
11809 digest
[2] -= SHA256M_C
;
11810 digest
[3] -= SHA256M_D
;
11811 digest
[4] -= SHA256M_E
;
11812 digest
[5] -= SHA256M_F
;
11813 digest
[6] -= SHA256M_G
;
11814 digest
[7] -= SHA256M_H
;
11816 return (PARSER_OK
);
11819 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11821 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11823 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11827 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11830 u32
*digest
= (u32
*) hash_buf
->digest
;
11832 salt_t
*salt
= hash_buf
->salt
;
11834 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11835 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11836 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11837 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11838 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11839 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11840 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11841 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11843 digest
[0] -= SHA256M_A
;
11844 digest
[1] -= SHA256M_B
;
11845 digest
[2] -= SHA256M_C
;
11846 digest
[3] -= SHA256M_D
;
11847 digest
[4] -= SHA256M_E
;
11848 digest
[5] -= SHA256M_F
;
11849 digest
[6] -= SHA256M_G
;
11850 digest
[7] -= SHA256M_H
;
11852 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11854 uint salt_len
= input_len
- 64 - 1;
11856 char *salt_buf
= input_buf
+ 64 + 1;
11858 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11860 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11862 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11864 salt
->salt_len
= salt_len
;
11866 return (PARSER_OK
);
11869 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11871 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11873 u64
*digest
= (u64
*) hash_buf
->digest
;
11875 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11876 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11877 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11878 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11879 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11880 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11884 digest
[0] -= SHA384M_A
;
11885 digest
[1] -= SHA384M_B
;
11886 digest
[2] -= SHA384M_C
;
11887 digest
[3] -= SHA384M_D
;
11888 digest
[4] -= SHA384M_E
;
11889 digest
[5] -= SHA384M_F
;
11893 return (PARSER_OK
);
11896 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11898 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11900 u64
*digest
= (u64
*) hash_buf
->digest
;
11902 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11903 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11904 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11905 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11906 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11907 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11908 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11909 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11911 digest
[0] -= SHA512M_A
;
11912 digest
[1] -= SHA512M_B
;
11913 digest
[2] -= SHA512M_C
;
11914 digest
[3] -= SHA512M_D
;
11915 digest
[4] -= SHA512M_E
;
11916 digest
[5] -= SHA512M_F
;
11917 digest
[6] -= SHA512M_G
;
11918 digest
[7] -= SHA512M_H
;
11920 return (PARSER_OK
);
11923 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11925 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11927 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11931 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11934 u64
*digest
= (u64
*) hash_buf
->digest
;
11936 salt_t
*salt
= hash_buf
->salt
;
11938 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11939 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11940 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11941 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11942 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11943 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11944 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11945 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11947 digest
[0] -= SHA512M_A
;
11948 digest
[1] -= SHA512M_B
;
11949 digest
[2] -= SHA512M_C
;
11950 digest
[3] -= SHA512M_D
;
11951 digest
[4] -= SHA512M_E
;
11952 digest
[5] -= SHA512M_F
;
11953 digest
[6] -= SHA512M_G
;
11954 digest
[7] -= SHA512M_H
;
11956 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11958 uint salt_len
= input_len
- 128 - 1;
11960 char *salt_buf
= input_buf
+ 128 + 1;
11962 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11964 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11966 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11968 salt
->salt_len
= salt_len
;
11970 return (PARSER_OK
);
11973 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11975 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11977 u64
*digest
= (u64
*) hash_buf
->digest
;
11979 salt_t
*salt
= hash_buf
->salt
;
11981 char *salt_pos
= input_buf
+ 3;
11983 uint iterations_len
= 0;
11985 if (memcmp (salt_pos
, "rounds=", 7) == 0)
11989 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
11991 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
11992 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
11996 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12000 iterations_len
+= 8;
12004 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12007 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12009 char *hash_pos
= strchr (salt_pos
, '$');
12011 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12013 uint salt_len
= hash_pos
- salt_pos
;
12015 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12017 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12019 salt
->salt_len
= salt_len
;
12023 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12025 return (PARSER_OK
);
12028 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12030 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12032 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12034 u64
*digest
= (u64
*) hash_buf
->digest
;
12036 salt_t
*salt
= hash_buf
->salt
;
12038 uint keccak_mdlen
= input_len
/ 2;
12040 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12042 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12044 digest
[i
] = byte_swap_64 (digest
[i
]);
12047 salt
->keccak_mdlen
= keccak_mdlen
;
12049 return (PARSER_OK
);
12052 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12054 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12056 u32
*digest
= (u32
*) hash_buf
->digest
;
12058 salt_t
*salt
= hash_buf
->salt
;
12060 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12063 * Parse that strange long line
12068 size_t in_len
[9] = { 0 };
12070 in_off
[0] = strtok (input_buf
, ":");
12072 in_len
[0] = strlen (in_off
[0]);
12076 for (i
= 1; i
< 9; i
++)
12078 in_off
[i
] = strtok (NULL
, ":");
12080 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12082 in_len
[i
] = strlen (in_off
[i
]);
12085 char *ptr
= (char *) ikepsk
->msg_buf
;
12087 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12088 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12089 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12090 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12091 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12092 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12096 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12098 ptr
= (char *) ikepsk
->nr_buf
;
12100 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12101 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12105 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12108 * Store to database
12113 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12114 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12115 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12116 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12118 digest
[0] = byte_swap_32 (digest
[0]);
12119 digest
[1] = byte_swap_32 (digest
[1]);
12120 digest
[2] = byte_swap_32 (digest
[2]);
12121 digest
[3] = byte_swap_32 (digest
[3]);
12123 salt
->salt_len
= 32;
12125 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12126 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12127 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12128 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12129 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12130 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12131 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12132 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12134 return (PARSER_OK
);
12137 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12139 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12141 u32
*digest
= (u32
*) hash_buf
->digest
;
12143 salt_t
*salt
= hash_buf
->salt
;
12145 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12148 * Parse that strange long line
12153 size_t in_len
[9] = { 0 };
12155 in_off
[0] = strtok (input_buf
, ":");
12157 in_len
[0] = strlen (in_off
[0]);
12161 for (i
= 1; i
< 9; i
++)
12163 in_off
[i
] = strtok (NULL
, ":");
12165 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12167 in_len
[i
] = strlen (in_off
[i
]);
12170 char *ptr
= (char *) ikepsk
->msg_buf
;
12172 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12173 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12174 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12175 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12176 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12177 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12181 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12183 ptr
= (char *) ikepsk
->nr_buf
;
12185 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12186 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12190 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12193 * Store to database
12198 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12199 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12200 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12201 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12202 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12204 salt
->salt_len
= 32;
12206 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12207 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12208 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12209 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12210 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12211 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12212 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12213 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12215 return (PARSER_OK
);
12218 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12220 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12222 u32
*digest
= (u32
*) hash_buf
->digest
;
12224 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12225 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12226 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12227 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12228 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12230 digest
[0] = byte_swap_32 (digest
[0]);
12231 digest
[1] = byte_swap_32 (digest
[1]);
12232 digest
[2] = byte_swap_32 (digest
[2]);
12233 digest
[3] = byte_swap_32 (digest
[3]);
12234 digest
[4] = byte_swap_32 (digest
[4]);
12236 return (PARSER_OK
);
12239 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12241 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12243 u32
*digest
= (u32
*) hash_buf
->digest
;
12245 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12246 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12247 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12248 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12249 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12250 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12251 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12252 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12253 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12254 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12255 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12256 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12257 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12258 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12259 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12260 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12262 return (PARSER_OK
);
12265 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12267 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12269 u32
*digest
= (u32
*) hash_buf
->digest
;
12271 salt_t
*salt
= hash_buf
->salt
;
12273 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12274 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12275 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12276 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12277 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12279 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12281 uint salt_len
= input_len
- 40 - 1;
12283 char *salt_buf
= input_buf
+ 40 + 1;
12285 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12287 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12289 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12291 salt
->salt_len
= salt_len
;
12293 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12295 return (PARSER_OK
);
12298 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12300 u32
*digest
= (u32
*) hash_buf
->digest
;
12302 salt_t
*salt
= hash_buf
->salt
;
12304 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12306 if (input_len
== 0)
12308 log_error ("TrueCrypt container not specified");
12313 FILE *fp
= fopen (input_buf
, "rb");
12317 log_error ("%s: %s", input_buf
, strerror (errno
));
12322 char buf
[512] = { 0 };
12324 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12328 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12330 memcpy (tc
->salt_buf
, buf
, 64);
12332 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12334 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12336 salt
->salt_len
= 4;
12338 salt
->salt_iter
= 1000 - 1;
12340 digest
[0] = tc
->data_buf
[0];
12342 return (PARSER_OK
);
12345 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12347 u32
*digest
= (u32
*) hash_buf
->digest
;
12349 salt_t
*salt
= hash_buf
->salt
;
12351 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12353 if (input_len
== 0)
12355 log_error ("TrueCrypt container not specified");
12360 FILE *fp
= fopen (input_buf
, "rb");
12364 log_error ("%s: %s", input_buf
, strerror (errno
));
12369 char buf
[512] = { 0 };
12371 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12375 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12377 memcpy (tc
->salt_buf
, buf
, 64);
12379 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12381 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12383 salt
->salt_len
= 4;
12385 salt
->salt_iter
= 2000 - 1;
12387 digest
[0] = tc
->data_buf
[0];
12389 return (PARSER_OK
);
12392 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12394 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12396 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12398 u32
*digest
= (u32
*) hash_buf
->digest
;
12400 salt_t
*salt
= hash_buf
->salt
;
12402 char *salt_pos
= input_buf
+ 6;
12404 char *hash_pos
= strchr (salt_pos
, '$');
12406 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12408 uint salt_len
= hash_pos
- salt_pos
;
12410 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12412 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12414 salt
->salt_len
= salt_len
;
12416 salt
->salt_iter
= 1000;
12420 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12422 return (PARSER_OK
);
12425 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12427 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12429 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12431 u32
*digest
= (u32
*) hash_buf
->digest
;
12433 salt_t
*salt
= hash_buf
->salt
;
12435 char *iter_pos
= input_buf
+ 7;
12437 char *salt_pos
= strchr (iter_pos
, '$');
12439 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12443 char *hash_pos
= strchr (salt_pos
, '$');
12445 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12447 uint salt_len
= hash_pos
- salt_pos
;
12449 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12451 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12453 salt
->salt_len
= salt_len
;
12455 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12457 salt
->salt_sign
[0] = atoi (salt_iter
);
12459 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12463 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12465 digest
[0] = byte_swap_32 (digest
[0]);
12466 digest
[1] = byte_swap_32 (digest
[1]);
12467 digest
[2] = byte_swap_32 (digest
[2]);
12468 digest
[3] = byte_swap_32 (digest
[3]);
12469 digest
[4] = byte_swap_32 (digest
[4]);
12471 return (PARSER_OK
);
12474 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12476 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12478 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12480 u32
*digest
= (u32
*) hash_buf
->digest
;
12482 salt_t
*salt
= hash_buf
->salt
;
12484 char *iter_pos
= input_buf
+ 9;
12486 char *salt_pos
= strchr (iter_pos
, '$');
12488 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12492 char *hash_pos
= strchr (salt_pos
, '$');
12494 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12496 uint salt_len
= hash_pos
- salt_pos
;
12498 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12500 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12502 salt
->salt_len
= salt_len
;
12504 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12506 salt
->salt_sign
[0] = atoi (salt_iter
);
12508 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12512 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12514 digest
[0] = byte_swap_32 (digest
[0]);
12515 digest
[1] = byte_swap_32 (digest
[1]);
12516 digest
[2] = byte_swap_32 (digest
[2]);
12517 digest
[3] = byte_swap_32 (digest
[3]);
12518 digest
[4] = byte_swap_32 (digest
[4]);
12519 digest
[5] = byte_swap_32 (digest
[5]);
12520 digest
[6] = byte_swap_32 (digest
[6]);
12521 digest
[7] = byte_swap_32 (digest
[7]);
12523 return (PARSER_OK
);
12526 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12528 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12530 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12532 u64
*digest
= (u64
*) hash_buf
->digest
;
12534 salt_t
*salt
= hash_buf
->salt
;
12536 char *iter_pos
= input_buf
+ 9;
12538 char *salt_pos
= strchr (iter_pos
, '$');
12540 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12544 char *hash_pos
= strchr (salt_pos
, '$');
12546 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12548 uint salt_len
= hash_pos
- salt_pos
;
12550 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12552 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12554 salt
->salt_len
= salt_len
;
12556 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12558 salt
->salt_sign
[0] = atoi (salt_iter
);
12560 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12564 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12566 digest
[0] = byte_swap_64 (digest
[0]);
12567 digest
[1] = byte_swap_64 (digest
[1]);
12568 digest
[2] = byte_swap_64 (digest
[2]);
12569 digest
[3] = byte_swap_64 (digest
[3]);
12570 digest
[4] = byte_swap_64 (digest
[4]);
12571 digest
[5] = byte_swap_64 (digest
[5]);
12572 digest
[6] = byte_swap_64 (digest
[6]);
12573 digest
[7] = byte_swap_64 (digest
[7]);
12575 return (PARSER_OK
);
12578 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12580 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12582 u32
*digest
= (u32
*) hash_buf
->digest
;
12584 salt_t
*salt
= hash_buf
->salt
;
12586 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12592 char *iterations_pos
= input_buf
;
12594 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12596 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12598 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12600 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12604 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12606 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12608 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12610 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12612 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12614 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12619 * pbkdf2 iterations
12622 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12625 * handle salt encoding
12628 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12630 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12632 const char p0
= saltbuf_pos
[i
+ 0];
12633 const char p1
= saltbuf_pos
[i
+ 1];
12635 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12636 | hex_convert (p0
) << 4;
12639 salt
->salt_len
= saltbuf_len
/ 2;
12642 * handle cipher encoding
12645 uint
*tmp
= (uint
*) mymalloc (32);
12647 char *cipherbuf_ptr
= (char *) tmp
;
12649 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12651 const char p0
= cipherbuf_pos
[i
+ 0];
12652 const char p1
= cipherbuf_pos
[i
+ 1];
12654 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12655 | hex_convert (p0
) << 4;
12658 // iv is stored at salt_buf 4 (length 16)
12659 // data is stored at salt_buf 8 (length 16)
12661 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12662 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12663 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12664 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12666 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12667 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12668 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12669 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12673 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12675 const char p0
= cipherbuf_pos
[j
+ 0];
12676 const char p1
= cipherbuf_pos
[j
+ 1];
12678 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12679 | hex_convert (p0
) << 4;
12686 digest
[0] = 0x10101010;
12687 digest
[1] = 0x10101010;
12688 digest
[2] = 0x10101010;
12689 digest
[3] = 0x10101010;
12691 return (PARSER_OK
);
12694 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12696 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12698 u32
*digest
= (u32
*) hash_buf
->digest
;
12700 salt_t
*salt
= hash_buf
->salt
;
12702 char *hashbuf_pos
= input_buf
;
12704 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12706 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12708 uint hash_len
= iterations_pos
- hashbuf_pos
;
12710 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12714 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12716 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12718 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12722 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12724 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12726 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12728 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12730 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12732 salt
->salt_len
= salt_len
;
12734 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12736 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12737 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12738 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12739 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12741 return (PARSER_OK
);
12744 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12746 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12748 u32
*digest
= (u32
*) hash_buf
->digest
;
12750 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12751 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12752 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12753 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12754 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12755 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12756 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12757 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12759 digest
[0] = byte_swap_32 (digest
[0]);
12760 digest
[1] = byte_swap_32 (digest
[1]);
12761 digest
[2] = byte_swap_32 (digest
[2]);
12762 digest
[3] = byte_swap_32 (digest
[3]);
12763 digest
[4] = byte_swap_32 (digest
[4]);
12764 digest
[5] = byte_swap_32 (digest
[5]);
12765 digest
[6] = byte_swap_32 (digest
[6]);
12766 digest
[7] = byte_swap_32 (digest
[7]);
12768 return (PARSER_OK
);
12771 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12773 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12775 u32
*digest
= (u32
*) hash_buf
->digest
;
12777 salt_t
*salt
= hash_buf
->salt
;
12779 char *salt_pos
= input_buf
+ 3;
12781 uint iterations_len
= 0;
12783 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12787 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12789 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12790 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12794 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12798 iterations_len
+= 8;
12802 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12805 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12807 char *hash_pos
= strchr (salt_pos
, '$');
12809 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12811 uint salt_len
= hash_pos
- salt_pos
;
12813 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12815 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12817 salt
->salt_len
= salt_len
;
12821 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12823 return (PARSER_OK
);
12826 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12828 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12830 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12832 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12834 u64
*digest
= (u64
*) hash_buf
->digest
;
12836 salt_t
*salt
= hash_buf
->salt
;
12838 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12840 char *iter_pos
= input_buf
+ 4;
12842 char *salt_pos
= strchr (iter_pos
, '$');
12844 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12848 char *hash_pos
= strchr (salt_pos
, '$');
12850 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12852 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12856 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12857 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12858 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12859 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12860 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12861 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12862 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12863 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12865 uint salt_len
= hash_pos
- salt_pos
- 1;
12867 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12869 salt
->salt_len
= salt_len
/ 2;
12871 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12872 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12873 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12874 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12875 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12876 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12877 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12878 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12880 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12881 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12882 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12883 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12884 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12885 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12886 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12887 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12888 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12889 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12891 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12893 salt
->salt_iter
= atoi (iter_pos
) - 1;
12895 return (PARSER_OK
);
12898 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12900 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12902 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12904 u32
*digest
= (u32
*) hash_buf
->digest
;
12906 salt_t
*salt
= hash_buf
->salt
;
12908 char *salt_pos
= input_buf
+ 14;
12910 char *hash_pos
= strchr (salt_pos
, '*');
12912 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12916 uint salt_len
= hash_pos
- salt_pos
- 1;
12918 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12920 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12922 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12924 salt
->salt_len
= salt_len
;
12926 u8 tmp_buf
[100] = { 0 };
12928 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
12930 memcpy (digest
, tmp_buf
, 32);
12932 digest
[0] = byte_swap_32 (digest
[0]);
12933 digest
[1] = byte_swap_32 (digest
[1]);
12934 digest
[2] = byte_swap_32 (digest
[2]);
12935 digest
[3] = byte_swap_32 (digest
[3]);
12936 digest
[4] = byte_swap_32 (digest
[4]);
12937 digest
[5] = byte_swap_32 (digest
[5]);
12938 digest
[6] = byte_swap_32 (digest
[6]);
12939 digest
[7] = byte_swap_32 (digest
[7]);
12941 digest
[0] -= SHA256M_A
;
12942 digest
[1] -= SHA256M_B
;
12943 digest
[2] -= SHA256M_C
;
12944 digest
[3] -= SHA256M_D
;
12945 digest
[4] -= SHA256M_E
;
12946 digest
[5] -= SHA256M_F
;
12947 digest
[6] -= SHA256M_G
;
12948 digest
[7] -= SHA256M_H
;
12950 return (PARSER_OK
);
12953 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12955 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12957 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12959 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12961 u64
*digest
= (u64
*) hash_buf
->digest
;
12963 salt_t
*salt
= hash_buf
->salt
;
12965 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12967 char *iter_pos
= input_buf
+ 19;
12969 char *salt_pos
= strchr (iter_pos
, '.');
12971 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12975 char *hash_pos
= strchr (salt_pos
, '.');
12977 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12979 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12983 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12984 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12985 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12986 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12987 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12988 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12989 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12990 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12992 uint salt_len
= hash_pos
- salt_pos
- 1;
12996 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13000 for (i
= 0; i
< salt_len
; i
++)
13002 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13005 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13006 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13008 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13010 salt
->salt_len
= salt_len
;
13012 salt
->salt_iter
= atoi (iter_pos
) - 1;
13014 return (PARSER_OK
);
13017 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13019 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13021 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13023 u64
*digest
= (u64
*) hash_buf
->digest
;
13025 salt_t
*salt
= hash_buf
->salt
;
13027 u8 tmp_buf
[120] = { 0 };
13029 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13031 memcpy (digest
, tmp_buf
, 64);
13033 digest
[0] = byte_swap_64 (digest
[0]);
13034 digest
[1] = byte_swap_64 (digest
[1]);
13035 digest
[2] = byte_swap_64 (digest
[2]);
13036 digest
[3] = byte_swap_64 (digest
[3]);
13037 digest
[4] = byte_swap_64 (digest
[4]);
13038 digest
[5] = byte_swap_64 (digest
[5]);
13039 digest
[6] = byte_swap_64 (digest
[6]);
13040 digest
[7] = byte_swap_64 (digest
[7]);
13042 digest
[0] -= SHA512M_A
;
13043 digest
[1] -= SHA512M_B
;
13044 digest
[2] -= SHA512M_C
;
13045 digest
[3] -= SHA512M_D
;
13046 digest
[4] -= SHA512M_E
;
13047 digest
[5] -= SHA512M_F
;
13048 digest
[6] -= SHA512M_G
;
13049 digest
[7] -= SHA512M_H
;
13051 salt
->salt_len
= tmp_len
- 64;
13053 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13055 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13057 char *ptr
= (char *) salt
->salt_buf
;
13059 ptr
[salt
->salt_len
] = 0x80;
13062 return (PARSER_OK
);
13065 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13067 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13069 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13073 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13076 u32
*digest
= (u32
*) hash_buf
->digest
;
13078 salt_t
*salt
= hash_buf
->salt
;
13080 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13081 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13082 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13083 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13085 digest
[0] = byte_swap_32 (digest
[0]);
13086 digest
[1] = byte_swap_32 (digest
[1]);
13087 digest
[2] = byte_swap_32 (digest
[2]);
13088 digest
[3] = byte_swap_32 (digest
[3]);
13090 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13092 uint salt_len
= input_len
- 32 - 1;
13094 char *salt_buf
= input_buf
+ 32 + 1;
13096 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13098 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13100 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13102 salt
->salt_len
= salt_len
;
13104 return (PARSER_OK
);
13107 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13109 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13111 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13115 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13118 u32
*digest
= (u32
*) hash_buf
->digest
;
13120 salt_t
*salt
= hash_buf
->salt
;
13122 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13123 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13124 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13125 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13126 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13128 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13130 uint salt_len
= input_len
- 40 - 1;
13132 char *salt_buf
= input_buf
+ 40 + 1;
13134 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13136 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13138 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13140 salt
->salt_len
= salt_len
;
13142 return (PARSER_OK
);
13145 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13147 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13149 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13153 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13156 u32
*digest
= (u32
*) hash_buf
->digest
;
13158 salt_t
*salt
= hash_buf
->salt
;
13160 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13161 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13162 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13163 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13164 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13165 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13166 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13167 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13169 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13171 uint salt_len
= input_len
- 64 - 1;
13173 char *salt_buf
= input_buf
+ 64 + 1;
13175 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13177 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13179 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13181 salt
->salt_len
= salt_len
;
13183 return (PARSER_OK
);
13186 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13188 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13190 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13194 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13197 u64
*digest
= (u64
*) hash_buf
->digest
;
13199 salt_t
*salt
= hash_buf
->salt
;
13201 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13202 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13203 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13204 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13205 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13206 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13207 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13208 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13210 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13212 uint salt_len
= input_len
- 128 - 1;
13214 char *salt_buf
= input_buf
+ 128 + 1;
13216 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13218 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13220 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13222 salt
->salt_len
= salt_len
;
13224 return (PARSER_OK
);
13227 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13229 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13231 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13233 u32
*digest
= (u32
*) hash_buf
->digest
;
13235 salt_t
*salt
= hash_buf
->salt
;
13237 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13243 char *user_pos
= input_buf
+ 10 + 1;
13245 char *realm_pos
= strchr (user_pos
, '$');
13247 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13249 uint user_len
= realm_pos
- user_pos
;
13251 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13255 char *salt_pos
= strchr (realm_pos
, '$');
13257 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13259 uint realm_len
= salt_pos
- realm_pos
;
13261 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13265 char *data_pos
= strchr (salt_pos
, '$');
13267 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13269 uint salt_len
= data_pos
- salt_pos
;
13271 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13275 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13277 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13283 memcpy (krb5pa
->user
, user_pos
, user_len
);
13284 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13285 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13287 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13289 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13291 const char p0
= data_pos
[i
+ 0];
13292 const char p1
= data_pos
[i
+ 1];
13294 *timestamp_ptr
++ = hex_convert (p1
) << 0
13295 | hex_convert (p0
) << 4;
13298 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13300 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13302 const char p0
= data_pos
[i
+ 0];
13303 const char p1
= data_pos
[i
+ 1];
13305 *checksum_ptr
++ = hex_convert (p1
) << 0
13306 | hex_convert (p0
) << 4;
13310 * copy some data to generic buffers to make sorting happy
13313 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13314 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13315 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13316 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13317 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13318 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13319 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13320 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13321 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13323 salt
->salt_len
= 36;
13325 digest
[0] = krb5pa
->checksum
[0];
13326 digest
[1] = krb5pa
->checksum
[1];
13327 digest
[2] = krb5pa
->checksum
[2];
13328 digest
[3] = krb5pa
->checksum
[3];
13330 return (PARSER_OK
);
13333 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13335 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13337 u32
*digest
= (u32
*) hash_buf
->digest
;
13339 salt_t
*salt
= hash_buf
->salt
;
13345 char *salt_pos
= input_buf
;
13347 char *hash_pos
= strchr (salt_pos
, '$');
13349 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13351 uint salt_len
= hash_pos
- salt_pos
;
13353 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13357 uint hash_len
= input_len
- 1 - salt_len
;
13359 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13367 for (uint i
= 0; i
< salt_len
; i
++)
13369 if (salt_pos
[i
] == ' ') continue;
13374 // SAP user names cannot be longer than 12 characters
13375 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13377 // SAP user name cannot start with ! or ?
13378 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13384 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13386 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13388 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13390 salt
->salt_len
= salt_len
;
13392 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13393 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13397 digest
[0] = byte_swap_32 (digest
[0]);
13398 digest
[1] = byte_swap_32 (digest
[1]);
13400 return (PARSER_OK
);
13403 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13405 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13407 u32
*digest
= (u32
*) hash_buf
->digest
;
13409 salt_t
*salt
= hash_buf
->salt
;
13415 char *salt_pos
= input_buf
;
13417 char *hash_pos
= strchr (salt_pos
, '$');
13419 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13421 uint salt_len
= hash_pos
- salt_pos
;
13423 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13427 uint hash_len
= input_len
- 1 - salt_len
;
13429 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13437 for (uint i
= 0; i
< salt_len
; i
++)
13439 if (salt_pos
[i
] == ' ') continue;
13444 // SAP user names cannot be longer than 12 characters
13445 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13446 // so far nobody complained so we stay with this because it helps in optimization
13447 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13449 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13451 // SAP user name cannot start with ! or ?
13452 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13458 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13460 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13462 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13464 salt
->salt_len
= salt_len
;
13466 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13467 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13468 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13469 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13470 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13472 return (PARSER_OK
);
13475 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13477 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13479 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13481 u64
*digest
= (u64
*) hash_buf
->digest
;
13483 salt_t
*salt
= hash_buf
->salt
;
13485 char *iter_pos
= input_buf
+ 3;
13487 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13489 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13491 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13493 salt
->salt_iter
= salt_iter
;
13495 char *salt_pos
= iter_pos
+ 1;
13499 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13501 salt
->salt_len
= salt_len
;
13503 char *hash_pos
= salt_pos
+ salt_len
;
13505 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13509 char *tmp
= (char *) salt
->salt_buf_pc
;
13511 tmp
[0] = hash_pos
[42];
13515 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13516 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13517 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13518 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13524 return (PARSER_OK
);
13527 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13529 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13531 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13533 u32
*digest
= (u32
*) hash_buf
->digest
;
13535 salt_t
*salt
= hash_buf
->salt
;
13537 char *salt_buf
= input_buf
+ 6;
13539 uint salt_len
= 16;
13541 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13543 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13545 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13547 salt
->salt_len
= salt_len
;
13549 char *hash_pos
= input_buf
+ 6 + 16;
13551 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13552 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13553 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13554 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13555 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13556 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13557 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13558 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13560 return (PARSER_OK
);
13563 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13565 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13567 u32
*digest
= (u32
*) hash_buf
->digest
;
13569 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13570 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13574 return (PARSER_OK
);
13577 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13579 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13581 u32
*digest
= (u32
*) hash_buf
->digest
;
13583 salt_t
*salt
= hash_buf
->salt
;
13585 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13587 char *saltbuf_pos
= input_buf
;
13589 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13591 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13593 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13595 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13596 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13598 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13602 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13604 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13606 char *salt_ptr
= (char *) saltbuf_pos
;
13607 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13612 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13614 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13617 rakp_ptr
[j
] = 0x80;
13619 rakp
->salt_len
= j
;
13621 for (i
= 0; i
< 64; i
++)
13623 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13626 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13627 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13628 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13629 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13630 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13631 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13632 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13633 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13635 salt
->salt_len
= 32; // muss min. 32 haben
13637 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13638 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13639 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13640 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13641 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13643 return (PARSER_OK
);
13646 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13648 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13650 u32
*digest
= (u32
*) hash_buf
->digest
;
13652 salt_t
*salt
= hash_buf
->salt
;
13654 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13656 char *salt_pos
= input_buf
+ 1;
13658 memcpy (salt
->salt_buf
, salt_pos
, 8);
13660 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13661 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13663 salt
->salt_len
= 8;
13665 char *hash_pos
= salt_pos
+ 8;
13667 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13668 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13669 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13670 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13671 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13673 digest
[0] -= SHA1M_A
;
13674 digest
[1] -= SHA1M_B
;
13675 digest
[2] -= SHA1M_C
;
13676 digest
[3] -= SHA1M_D
;
13677 digest
[4] -= SHA1M_E
;
13679 return (PARSER_OK
);
13682 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13684 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13686 u32
*digest
= (u32
*) hash_buf
->digest
;
13688 salt_t
*salt
= hash_buf
->salt
;
13690 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13691 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13692 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13693 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13695 digest
[0] = byte_swap_32 (digest
[0]);
13696 digest
[1] = byte_swap_32 (digest
[1]);
13697 digest
[2] = byte_swap_32 (digest
[2]);
13698 digest
[3] = byte_swap_32 (digest
[3]);
13700 digest
[0] -= MD5M_A
;
13701 digest
[1] -= MD5M_B
;
13702 digest
[2] -= MD5M_C
;
13703 digest
[3] -= MD5M_D
;
13705 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13707 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13709 u32
*salt_buf
= salt
->salt_buf
;
13711 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13712 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13713 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13714 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13716 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13717 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13718 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13719 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13721 salt
->salt_len
= 16 + 1;
13723 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13725 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13727 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13729 return (PARSER_OK
);
13732 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13734 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13736 u32
*digest
= (u32
*) hash_buf
->digest
;
13738 salt_t
*salt
= hash_buf
->salt
;
13740 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13746 char *hashbuf_pos
= input_buf
;
13748 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13750 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13752 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13754 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13758 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13760 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13762 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13764 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13768 char *databuf_pos
= strchr (iteration_pos
, ':');
13770 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13772 const uint iteration_len
= databuf_pos
- iteration_pos
;
13774 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13775 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13777 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13779 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13780 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13786 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13787 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13788 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13789 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13790 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13791 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13792 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13793 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13797 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13799 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13801 const char p0
= saltbuf_pos
[i
+ 0];
13802 const char p1
= saltbuf_pos
[i
+ 1];
13804 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13805 | hex_convert (p0
) << 4;
13808 salt
->salt_buf
[4] = 0x01000000;
13809 salt
->salt_buf
[5] = 0x80;
13811 salt
->salt_len
= saltbuf_len
/ 2;
13815 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13819 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13821 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13823 const char p0
= databuf_pos
[i
+ 0];
13824 const char p1
= databuf_pos
[i
+ 1];
13826 *databuf_ptr
++ = hex_convert (p1
) << 0
13827 | hex_convert (p0
) << 4;
13830 *databuf_ptr
++ = 0x80;
13832 for (uint i
= 0; i
< 512; i
++)
13834 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13837 cloudkey
->data_len
= databuf_len
/ 2;
13839 return (PARSER_OK
);
13842 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13844 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13846 u32
*digest
= (u32
*) hash_buf
->digest
;
13848 salt_t
*salt
= hash_buf
->salt
;
13854 char *hashbuf_pos
= input_buf
;
13856 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13858 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13860 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13862 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13866 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13868 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13870 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13872 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13874 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13878 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13880 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13882 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13884 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13886 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13890 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13892 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13893 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13895 // ok, the plan for this algorithm is the following:
13896 // we have 2 salts here, the domain-name and a random salt
13897 // while both are used in the initial transformation,
13898 // only the random salt is used in the following iterations
13899 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13900 // and one that includes only the real salt (stored into salt_buf[]).
13901 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13903 u8 tmp_buf
[100] = { 0 };
13905 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
13907 memcpy (digest
, tmp_buf
, 20);
13909 digest
[0] = byte_swap_32 (digest
[0]);
13910 digest
[1] = byte_swap_32 (digest
[1]);
13911 digest
[2] = byte_swap_32 (digest
[2]);
13912 digest
[3] = byte_swap_32 (digest
[3]);
13913 digest
[4] = byte_swap_32 (digest
[4]);
13917 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13919 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13921 char *len_ptr
= NULL
;
13923 for (uint i
= 0; i
< domainbuf_len
; i
++)
13925 if (salt_buf_pc_ptr
[i
] == '.')
13927 len_ptr
= &salt_buf_pc_ptr
[i
];
13937 salt
->salt_buf_pc
[7] = domainbuf_len
;
13941 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13943 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13945 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13947 salt
->salt_len
= salt_len
;
13951 salt
->salt_iter
= atoi (iteration_pos
);
13953 return (PARSER_OK
);
13956 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13958 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13960 u32
*digest
= (u32
*) hash_buf
->digest
;
13962 salt_t
*salt
= hash_buf
->salt
;
13964 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13965 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13966 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13967 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13968 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13970 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13972 uint salt_len
= input_len
- 40 - 1;
13974 char *salt_buf
= input_buf
+ 40 + 1;
13976 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13978 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13980 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13982 salt
->salt_len
= salt_len
;
13984 return (PARSER_OK
);
13987 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13989 const u8 ascii_to_ebcdic
[] =
13991 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
13992 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
13993 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
13994 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
13995 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
13996 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
13997 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
13998 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
13999 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14000 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14001 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14002 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14003 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14004 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14005 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14006 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14009 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14011 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14013 u32
*digest
= (u32
*) hash_buf
->digest
;
14015 salt_t
*salt
= hash_buf
->salt
;
14017 char *salt_pos
= input_buf
+ 6 + 1;
14019 char *digest_pos
= strchr (salt_pos
, '*');
14021 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14023 uint salt_len
= digest_pos
- salt_pos
;
14025 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14027 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14029 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14033 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14034 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14036 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14038 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14040 salt
->salt_len
= salt_len
;
14042 for (uint i
= 0; i
< salt_len
; i
++)
14044 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14046 for (uint i
= salt_len
; i
< 8; i
++)
14048 salt_buf_pc_ptr
[i
] = 0x40;
14053 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14055 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14056 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14058 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14059 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14061 digest
[0] = byte_swap_32 (digest
[0]);
14062 digest
[1] = byte_swap_32 (digest
[1]);
14064 IP (digest
[0], digest
[1], tt
);
14066 digest
[0] = rotr32 (digest
[0], 29);
14067 digest
[1] = rotr32 (digest
[1], 29);
14071 return (PARSER_OK
);
14074 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14076 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14078 u32
*digest
= (u32
*) hash_buf
->digest
;
14080 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14081 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14082 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14083 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14085 digest
[0] = byte_swap_32 (digest
[0]);
14086 digest
[1] = byte_swap_32 (digest
[1]);
14087 digest
[2] = byte_swap_32 (digest
[2]);
14088 digest
[3] = byte_swap_32 (digest
[3]);
14090 return (PARSER_OK
);
14093 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14095 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14097 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14099 u32
*digest
= (u32
*) hash_buf
->digest
;
14101 salt_t
*salt
= hash_buf
->salt
;
14103 u8 tmp_buf
[120] = { 0 };
14105 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14107 tmp_buf
[3] += -4; // dont ask!
14109 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14111 salt
->salt_len
= 5;
14113 memcpy (digest
, tmp_buf
+ 5, 9);
14115 // yes, only 9 byte are needed to crack, but 10 to display
14117 salt
->salt_buf_pc
[7] = input_buf
[20];
14119 return (PARSER_OK
);
14122 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14124 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14126 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14128 u32
*digest
= (u32
*) hash_buf
->digest
;
14130 salt_t
*salt
= hash_buf
->salt
;
14132 u8 tmp_buf
[120] = { 0 };
14134 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14136 tmp_buf
[3] += -4; // dont ask!
14140 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14142 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)
14146 char tmp_iter_buf
[11] = { 0 };
14148 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14150 tmp_iter_buf
[10] = 0;
14152 salt
->salt_iter
= atoi (tmp_iter_buf
);
14154 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14156 return (PARSER_SALT_ITERATION
);
14159 salt
->salt_iter
--; // first round in init
14161 // 2 additional bytes for display only
14163 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14164 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14168 memcpy (digest
, tmp_buf
+ 28, 8);
14170 digest
[0] = byte_swap_32 (digest
[0]);
14171 digest
[1] = byte_swap_32 (digest
[1]);
14175 return (PARSER_OK
);
14178 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14180 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14182 u32
*digest
= (u32
*) hash_buf
->digest
;
14184 salt_t
*salt
= hash_buf
->salt
;
14186 char *salt_buf_pos
= input_buf
;
14188 char *hash_buf_pos
= salt_buf_pos
+ 6;
14190 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14191 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14192 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14193 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14194 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14195 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14196 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14197 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14199 digest
[0] -= SHA256M_A
;
14200 digest
[1] -= SHA256M_B
;
14201 digest
[2] -= SHA256M_C
;
14202 digest
[3] -= SHA256M_D
;
14203 digest
[4] -= SHA256M_E
;
14204 digest
[5] -= SHA256M_F
;
14205 digest
[6] -= SHA256M_G
;
14206 digest
[7] -= SHA256M_H
;
14208 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14210 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14212 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14214 salt
->salt_len
= salt_len
;
14216 return (PARSER_OK
);
14219 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14221 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14223 u32
*digest
= (u32
*) hash_buf
->digest
;
14225 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14227 salt_t
*salt
= hash_buf
->salt
;
14229 char *salt_buf
= input_buf
+ 6;
14231 char *digest_buf
= strchr (salt_buf
, '$');
14233 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14235 uint salt_len
= digest_buf
- salt_buf
;
14237 digest_buf
++; // skip the '$' symbol
14239 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14241 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14243 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14245 salt
->salt_len
= salt_len
;
14247 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14248 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14249 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14250 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14252 digest
[0] = byte_swap_32 (digest
[0]);
14253 digest
[1] = byte_swap_32 (digest
[1]);
14254 digest
[2] = byte_swap_32 (digest
[2]);
14255 digest
[3] = byte_swap_32 (digest
[3]);
14257 digest
[0] -= MD5M_A
;
14258 digest
[1] -= MD5M_B
;
14259 digest
[2] -= MD5M_C
;
14260 digest
[3] -= MD5M_D
;
14262 return (PARSER_OK
);
14265 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14267 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14269 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14271 u32
*digest
= (u32
*) hash_buf
->digest
;
14273 salt_t
*salt
= hash_buf
->salt
;
14275 char *salt_buf
= input_buf
+ 3;
14277 char *digest_buf
= strchr (salt_buf
, '$');
14279 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14281 uint salt_len
= digest_buf
- salt_buf
;
14283 digest_buf
++; // skip the '$' symbol
14285 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14287 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14289 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14291 salt_buf_ptr
[salt_len
] = 0x2d;
14293 salt
->salt_len
= salt_len
+ 1;
14295 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14296 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14297 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14298 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14300 digest
[0] = byte_swap_32 (digest
[0]);
14301 digest
[1] = byte_swap_32 (digest
[1]);
14302 digest
[2] = byte_swap_32 (digest
[2]);
14303 digest
[3] = byte_swap_32 (digest
[3]);
14305 digest
[0] -= MD5M_A
;
14306 digest
[1] -= MD5M_B
;
14307 digest
[2] -= MD5M_C
;
14308 digest
[3] -= MD5M_D
;
14310 return (PARSER_OK
);
14313 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14315 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14317 u32
*digest
= (u32
*) hash_buf
->digest
;
14319 u8 tmp_buf
[100] = { 0 };
14321 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14323 memcpy (digest
, tmp_buf
, 20);
14325 digest
[0] = byte_swap_32 (digest
[0]);
14326 digest
[1] = byte_swap_32 (digest
[1]);
14327 digest
[2] = byte_swap_32 (digest
[2]);
14328 digest
[3] = byte_swap_32 (digest
[3]);
14329 digest
[4] = byte_swap_32 (digest
[4]);
14331 digest
[0] -= SHA1M_A
;
14332 digest
[1] -= SHA1M_B
;
14333 digest
[2] -= SHA1M_C
;
14334 digest
[3] -= SHA1M_D
;
14335 digest
[4] -= SHA1M_E
;
14337 return (PARSER_OK
);
14340 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14342 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14344 u32
*digest
= (u32
*) hash_buf
->digest
;
14346 salt_t
*salt
= hash_buf
->salt
;
14348 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14349 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14350 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14351 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14353 digest
[0] = byte_swap_32 (digest
[0]);
14354 digest
[1] = byte_swap_32 (digest
[1]);
14355 digest
[2] = byte_swap_32 (digest
[2]);
14356 digest
[3] = byte_swap_32 (digest
[3]);
14358 digest
[0] -= MD5M_A
;
14359 digest
[1] -= MD5M_B
;
14360 digest
[2] -= MD5M_C
;
14361 digest
[3] -= MD5M_D
;
14363 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14365 uint salt_len
= input_len
- 32 - 1;
14367 char *salt_buf
= input_buf
+ 32 + 1;
14369 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14371 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14373 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14376 * add static "salt" part
14379 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14383 salt
->salt_len
= salt_len
;
14385 return (PARSER_OK
);
14388 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14390 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14392 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14394 u32
*digest
= (u32
*) hash_buf
->digest
;
14396 salt_t
*salt
= hash_buf
->salt
;
14398 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14404 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14406 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14408 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14410 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14412 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14416 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14418 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14420 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14422 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14426 char *keybuf_pos
= strchr (keylen_pos
, '$');
14428 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14430 uint keylen_len
= keybuf_pos
- keylen_pos
;
14432 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14436 char *databuf_pos
= strchr (keybuf_pos
, '$');
14438 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14440 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14442 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14446 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14448 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14454 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14455 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14456 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14457 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14459 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14460 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14461 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14462 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14464 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14465 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14466 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14467 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14469 salt
->salt_len
= 16;
14470 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14472 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14474 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14477 return (PARSER_OK
);
14480 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14482 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14484 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14486 u32
*digest
= (u32
*) hash_buf
->digest
;
14488 salt_t
*salt
= hash_buf
->salt
;
14494 // first is the N salt parameter
14496 char *N_pos
= input_buf
+ 6;
14498 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14502 salt
->scrypt_N
= atoi (N_pos
);
14506 char *r_pos
= strchr (N_pos
, ':');
14508 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14512 salt
->scrypt_r
= atoi (r_pos
);
14516 char *p_pos
= strchr (r_pos
, ':');
14518 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14522 salt
->scrypt_p
= atoi (p_pos
);
14526 char *saltbuf_pos
= strchr (p_pos
, ':');
14528 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14532 char *hash_pos
= strchr (saltbuf_pos
, ':');
14534 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14540 u8 tmp_buf
[33] = { 0 };
14542 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14544 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14546 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14548 salt
->salt_len
= tmp_len
;
14549 salt
->salt_iter
= 1;
14551 // digest - base64 decode
14553 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14555 tmp_len
= input_len
- (hash_pos
- input_buf
);
14557 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14559 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14561 memcpy (digest
, tmp_buf
, 32);
14563 return (PARSER_OK
);
14566 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14568 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14570 u32
*digest
= (u32
*) hash_buf
->digest
;
14572 salt_t
*salt
= hash_buf
->salt
;
14578 char decrypted
[76] = { 0 }; // iv + hash
14580 juniper_decrypt_hash (input_buf
, decrypted
);
14582 char *md5crypt_hash
= decrypted
+ 12;
14584 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14586 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14588 char *salt_pos
= md5crypt_hash
+ 3;
14590 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14592 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14594 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14598 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14600 return (PARSER_OK
);
14603 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14605 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14607 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14609 u32
*digest
= (u32
*) hash_buf
->digest
;
14611 salt_t
*salt
= hash_buf
->salt
;
14613 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14619 // first is *raw* salt
14621 char *salt_pos
= input_buf
+ 3;
14623 char *hash_pos
= strchr (salt_pos
, '$');
14625 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14627 uint salt_len
= hash_pos
- salt_pos
;
14629 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14633 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14635 memcpy (salt_buf_ptr
, salt_pos
, 14);
14637 salt_buf_ptr
[17] = 0x01;
14638 salt_buf_ptr
[18] = 0x80;
14640 // add some stuff to normal salt to make sorted happy
14642 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14643 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14644 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14645 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14647 salt
->salt_len
= salt_len
;
14648 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14650 // base64 decode hash
14652 u8 tmp_buf
[100] = { 0 };
14654 uint hash_len
= input_len
- 3 - salt_len
- 1;
14656 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14658 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14660 memcpy (digest
, tmp_buf
, 32);
14662 digest
[0] = byte_swap_32 (digest
[0]);
14663 digest
[1] = byte_swap_32 (digest
[1]);
14664 digest
[2] = byte_swap_32 (digest
[2]);
14665 digest
[3] = byte_swap_32 (digest
[3]);
14666 digest
[4] = byte_swap_32 (digest
[4]);
14667 digest
[5] = byte_swap_32 (digest
[5]);
14668 digest
[6] = byte_swap_32 (digest
[6]);
14669 digest
[7] = byte_swap_32 (digest
[7]);
14671 return (PARSER_OK
);
14674 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14676 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14678 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14680 u32
*digest
= (u32
*) hash_buf
->digest
;
14682 salt_t
*salt
= hash_buf
->salt
;
14688 // first is *raw* salt
14690 char *salt_pos
= input_buf
+ 3;
14692 char *hash_pos
= strchr (salt_pos
, '$');
14694 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14696 uint salt_len
= hash_pos
- salt_pos
;
14698 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14700 salt
->salt_len
= salt_len
;
14703 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14705 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14706 salt_buf_ptr
[salt_len
] = 0;
14708 // base64 decode hash
14710 u8 tmp_buf
[100] = { 0 };
14712 uint hash_len
= input_len
- 3 - salt_len
- 1;
14714 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14716 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14718 memcpy (digest
, tmp_buf
, 32);
14721 salt
->scrypt_N
= 16384;
14722 salt
->scrypt_r
= 1;
14723 salt
->scrypt_p
= 1;
14724 salt
->salt_iter
= 1;
14726 return (PARSER_OK
);
14729 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14731 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14733 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14735 u32
*digest
= (u32
*) hash_buf
->digest
;
14737 salt_t
*salt
= hash_buf
->salt
;
14739 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14745 char *version_pos
= input_buf
+ 8 + 1;
14747 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14749 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14751 u32 version_len
= verifierHashSize_pos
- version_pos
;
14753 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14755 verifierHashSize_pos
++;
14757 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14759 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14761 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14763 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14767 char *saltSize_pos
= strchr (keySize_pos
, '*');
14769 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14771 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14773 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14777 char *osalt_pos
= strchr (saltSize_pos
, '*');
14779 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14781 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14783 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14787 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14789 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14791 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14793 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14795 encryptedVerifier_pos
++;
14797 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14799 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14801 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14803 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14805 encryptedVerifierHash_pos
++;
14807 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;
14809 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14811 const uint version
= atoi (version_pos
);
14813 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14815 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14817 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14819 const uint keySize
= atoi (keySize_pos
);
14821 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14823 office2007
->keySize
= keySize
;
14825 const uint saltSize
= atoi (saltSize_pos
);
14827 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14833 salt
->salt_len
= 16;
14834 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14836 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14837 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14838 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14839 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14845 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14846 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14847 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14848 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14850 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14851 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14852 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14853 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14854 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14860 digest
[0] = office2007
->encryptedVerifierHash
[0];
14861 digest
[1] = office2007
->encryptedVerifierHash
[1];
14862 digest
[2] = office2007
->encryptedVerifierHash
[2];
14863 digest
[3] = office2007
->encryptedVerifierHash
[3];
14865 return (PARSER_OK
);
14868 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14870 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14872 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14874 u32
*digest
= (u32
*) hash_buf
->digest
;
14876 salt_t
*salt
= hash_buf
->salt
;
14878 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14884 char *version_pos
= input_buf
+ 8 + 1;
14886 char *spinCount_pos
= strchr (version_pos
, '*');
14888 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14890 u32 version_len
= spinCount_pos
- version_pos
;
14892 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14896 char *keySize_pos
= strchr (spinCount_pos
, '*');
14898 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14900 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
14902 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14906 char *saltSize_pos
= strchr (keySize_pos
, '*');
14908 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14910 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14912 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14916 char *osalt_pos
= strchr (saltSize_pos
, '*');
14918 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14920 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14922 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14926 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14928 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14930 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14932 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14934 encryptedVerifier_pos
++;
14936 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14938 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14940 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14942 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14944 encryptedVerifierHash_pos
++;
14946 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;
14948 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14950 const uint version
= atoi (version_pos
);
14952 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14954 const uint spinCount
= atoi (spinCount_pos
);
14956 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14958 const uint keySize
= atoi (keySize_pos
);
14960 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14962 const uint saltSize
= atoi (saltSize_pos
);
14964 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14970 salt
->salt_len
= 16;
14971 salt
->salt_iter
= spinCount
;
14973 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14974 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14975 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14976 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14982 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14983 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14984 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14985 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14987 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14988 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14989 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14990 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14991 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14992 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
14993 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
14994 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15000 digest
[0] = office2010
->encryptedVerifierHash
[0];
15001 digest
[1] = office2010
->encryptedVerifierHash
[1];
15002 digest
[2] = office2010
->encryptedVerifierHash
[2];
15003 digest
[3] = office2010
->encryptedVerifierHash
[3];
15005 return (PARSER_OK
);
15008 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15010 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15012 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15014 u32
*digest
= (u32
*) hash_buf
->digest
;
15016 salt_t
*salt
= hash_buf
->salt
;
15018 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15024 char *version_pos
= input_buf
+ 8 + 1;
15026 char *spinCount_pos
= strchr (version_pos
, '*');
15028 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15030 u32 version_len
= spinCount_pos
- version_pos
;
15032 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15036 char *keySize_pos
= strchr (spinCount_pos
, '*');
15038 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15040 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15042 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15046 char *saltSize_pos
= strchr (keySize_pos
, '*');
15048 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15050 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15052 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15056 char *osalt_pos
= strchr (saltSize_pos
, '*');
15058 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15060 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15062 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15066 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15068 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15070 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15072 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15074 encryptedVerifier_pos
++;
15076 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15078 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15080 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15082 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15084 encryptedVerifierHash_pos
++;
15086 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;
15088 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15090 const uint version
= atoi (version_pos
);
15092 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15094 const uint spinCount
= atoi (spinCount_pos
);
15096 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15098 const uint keySize
= atoi (keySize_pos
);
15100 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15102 const uint saltSize
= atoi (saltSize_pos
);
15104 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15110 salt
->salt_len
= 16;
15111 salt
->salt_iter
= spinCount
;
15113 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15114 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15115 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15116 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15122 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15123 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15124 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15125 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15127 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15128 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15129 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15130 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15131 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15132 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15133 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15134 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15140 digest
[0] = office2013
->encryptedVerifierHash
[0];
15141 digest
[1] = office2013
->encryptedVerifierHash
[1];
15142 digest
[2] = office2013
->encryptedVerifierHash
[2];
15143 digest
[3] = office2013
->encryptedVerifierHash
[3];
15145 return (PARSER_OK
);
15148 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15150 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15152 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15154 u32
*digest
= (u32
*) hash_buf
->digest
;
15156 salt_t
*salt
= hash_buf
->salt
;
15158 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15164 char *version_pos
= input_buf
+ 11;
15166 char *osalt_pos
= strchr (version_pos
, '*');
15168 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15170 u32 version_len
= osalt_pos
- version_pos
;
15172 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15176 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15178 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15180 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15182 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15184 encryptedVerifier_pos
++;
15186 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15188 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15190 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15192 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15194 encryptedVerifierHash_pos
++;
15196 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15198 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15200 const uint version
= *version_pos
- 0x30;
15202 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15208 oldoffice01
->version
= version
;
15210 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15211 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15212 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15213 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15215 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15216 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15217 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15218 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15220 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15221 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15222 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15223 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15225 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15226 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15227 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15228 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15234 salt
->salt_len
= 16;
15236 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15237 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15238 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15239 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15241 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15242 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15243 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15244 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15246 // this is a workaround as office produces multiple documents with the same salt
15248 salt
->salt_len
+= 32;
15250 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15251 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15252 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15253 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15254 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15255 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15256 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15257 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15263 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15264 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15265 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15266 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15268 return (PARSER_OK
);
15271 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15273 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15276 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15278 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15280 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15282 u32
*digest
= (u32
*) hash_buf
->digest
;
15284 salt_t
*salt
= hash_buf
->salt
;
15286 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15292 char *version_pos
= input_buf
+ 11;
15294 char *osalt_pos
= strchr (version_pos
, '*');
15296 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15298 u32 version_len
= osalt_pos
- version_pos
;
15300 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15304 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15306 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15308 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15310 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15312 encryptedVerifier_pos
++;
15314 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15316 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15318 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15320 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15322 encryptedVerifierHash_pos
++;
15324 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15326 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15328 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15330 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15334 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15336 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15338 const uint version
= *version_pos
- 0x30;
15340 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15346 oldoffice01
->version
= version
;
15348 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15349 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15350 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15351 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15353 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15354 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15355 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15356 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15358 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15359 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15360 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15361 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15363 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15364 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15365 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15366 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15368 oldoffice01
->rc4key
[1] = 0;
15369 oldoffice01
->rc4key
[0] = 0;
15371 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15372 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15373 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15374 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15375 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15376 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15377 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15378 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15379 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15380 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15382 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15383 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15389 salt
->salt_len
= 16;
15391 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15392 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15393 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15394 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15396 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15397 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15398 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15399 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15401 // this is a workaround as office produces multiple documents with the same salt
15403 salt
->salt_len
+= 32;
15405 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15406 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15407 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15408 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15409 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15410 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15411 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15412 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15418 digest
[0] = oldoffice01
->rc4key
[0];
15419 digest
[1] = oldoffice01
->rc4key
[1];
15423 return (PARSER_OK
);
15426 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15428 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15430 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15432 u32
*digest
= (u32
*) hash_buf
->digest
;
15434 salt_t
*salt
= hash_buf
->salt
;
15436 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15442 char *version_pos
= input_buf
+ 11;
15444 char *osalt_pos
= strchr (version_pos
, '*');
15446 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15448 u32 version_len
= osalt_pos
- version_pos
;
15450 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15454 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15456 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15458 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15460 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15462 encryptedVerifier_pos
++;
15464 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15466 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15468 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15470 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15472 encryptedVerifierHash_pos
++;
15474 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15476 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15478 const uint version
= *version_pos
- 0x30;
15480 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15486 oldoffice34
->version
= version
;
15488 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15489 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15490 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15491 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15493 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15494 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15495 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15496 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15498 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15499 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15500 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15501 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15502 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15504 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15505 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15506 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15507 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15508 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15514 salt
->salt_len
= 16;
15516 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15517 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15518 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15519 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15521 // this is a workaround as office produces multiple documents with the same salt
15523 salt
->salt_len
+= 32;
15525 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15526 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15527 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15528 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15529 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15530 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15531 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15532 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15538 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15539 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15540 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15541 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15543 return (PARSER_OK
);
15546 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15548 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15550 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15553 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15555 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15557 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15559 u32
*digest
= (u32
*) hash_buf
->digest
;
15561 salt_t
*salt
= hash_buf
->salt
;
15563 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15569 char *version_pos
= input_buf
+ 11;
15571 char *osalt_pos
= strchr (version_pos
, '*');
15573 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15575 u32 version_len
= osalt_pos
- version_pos
;
15577 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15581 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15583 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15585 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15587 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15589 encryptedVerifier_pos
++;
15591 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15593 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15595 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15597 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15599 encryptedVerifierHash_pos
++;
15601 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15603 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15605 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15607 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15611 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15613 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15615 const uint version
= *version_pos
- 0x30;
15617 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15623 oldoffice34
->version
= version
;
15625 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15626 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15627 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15628 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15630 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15631 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15632 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15633 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15635 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15636 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15637 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15638 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15639 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15641 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15642 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15643 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15644 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15645 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15647 oldoffice34
->rc4key
[1] = 0;
15648 oldoffice34
->rc4key
[0] = 0;
15650 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15651 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15652 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15653 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15654 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15655 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15656 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15657 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15658 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15659 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15661 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15662 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15668 salt
->salt_len
= 16;
15670 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15671 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15672 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15673 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15675 // this is a workaround as office produces multiple documents with the same salt
15677 salt
->salt_len
+= 32;
15679 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15680 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15681 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15682 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15683 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15684 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15685 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15686 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15692 digest
[0] = oldoffice34
->rc4key
[0];
15693 digest
[1] = oldoffice34
->rc4key
[1];
15697 return (PARSER_OK
);
15700 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15702 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15704 u32
*digest
= (u32
*) hash_buf
->digest
;
15706 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15707 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15708 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15709 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15711 digest
[0] = byte_swap_32 (digest
[0]);
15712 digest
[1] = byte_swap_32 (digest
[1]);
15713 digest
[2] = byte_swap_32 (digest
[2]);
15714 digest
[3] = byte_swap_32 (digest
[3]);
15716 return (PARSER_OK
);
15719 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15721 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15723 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15725 u32
*digest
= (u32
*) hash_buf
->digest
;
15727 salt_t
*salt
= hash_buf
->salt
;
15729 char *signature_pos
= input_buf
;
15731 char *salt_pos
= strchr (signature_pos
, '$');
15733 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15735 u32 signature_len
= salt_pos
- signature_pos
;
15737 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15741 char *hash_pos
= strchr (salt_pos
, '$');
15743 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15745 u32 salt_len
= hash_pos
- salt_pos
;
15747 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15751 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15753 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15755 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15756 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15757 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15758 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15759 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15761 digest
[0] -= SHA1M_A
;
15762 digest
[1] -= SHA1M_B
;
15763 digest
[2] -= SHA1M_C
;
15764 digest
[3] -= SHA1M_D
;
15765 digest
[4] -= SHA1M_E
;
15767 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15769 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15771 salt
->salt_len
= salt_len
;
15773 return (PARSER_OK
);
15776 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15778 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15780 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15782 u32
*digest
= (u32
*) hash_buf
->digest
;
15784 salt_t
*salt
= hash_buf
->salt
;
15786 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15792 char *iter_pos
= input_buf
+ 14;
15794 const int iter
= atoi (iter_pos
);
15796 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15798 salt
->salt_iter
= iter
- 1;
15800 char *salt_pos
= strchr (iter_pos
, '$');
15802 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15806 char *hash_pos
= strchr (salt_pos
, '$');
15808 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15810 const uint salt_len
= hash_pos
- salt_pos
;
15814 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15816 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15818 salt
->salt_len
= salt_len
;
15820 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15821 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15823 // add some stuff to normal salt to make sorted happy
15825 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15826 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15827 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15828 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15829 salt
->salt_buf
[4] = salt
->salt_iter
;
15831 // base64 decode hash
15833 u8 tmp_buf
[100] = { 0 };
15835 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15837 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15839 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15841 memcpy (digest
, tmp_buf
, 32);
15843 digest
[0] = byte_swap_32 (digest
[0]);
15844 digest
[1] = byte_swap_32 (digest
[1]);
15845 digest
[2] = byte_swap_32 (digest
[2]);
15846 digest
[3] = byte_swap_32 (digest
[3]);
15847 digest
[4] = byte_swap_32 (digest
[4]);
15848 digest
[5] = byte_swap_32 (digest
[5]);
15849 digest
[6] = byte_swap_32 (digest
[6]);
15850 digest
[7] = byte_swap_32 (digest
[7]);
15852 return (PARSER_OK
);
15855 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15857 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15859 u32
*digest
= (u32
*) hash_buf
->digest
;
15861 salt_t
*salt
= hash_buf
->salt
;
15863 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15864 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15868 digest
[0] = byte_swap_32 (digest
[0]);
15869 digest
[1] = byte_swap_32 (digest
[1]);
15871 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15872 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15873 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15875 char iter_c
= input_buf
[17];
15876 char iter_d
= input_buf
[19];
15878 // atm only defaults, let's see if there's more request
15879 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15880 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15882 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15884 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15885 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15886 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15887 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15889 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15890 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15891 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15892 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15894 salt
->salt_len
= 16;
15896 return (PARSER_OK
);
15899 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15901 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15903 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15905 u32
*digest
= (u32
*) hash_buf
->digest
;
15907 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15909 salt_t
*salt
= hash_buf
->salt
;
15911 char *salt_pos
= input_buf
+ 10;
15913 char *hash_pos
= strchr (salt_pos
, '$');
15915 uint salt_len
= hash_pos
- salt_pos
;
15917 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15921 uint hash_len
= input_len
- 10 - salt_len
- 1;
15923 // base64 decode salt
15925 u8 tmp_buf
[100] = { 0 };
15927 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
15929 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15931 tmp_buf
[salt_len
] = 0x80;
15933 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15935 salt
->salt_len
= salt_len
;
15937 // base64 decode salt
15939 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15941 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15943 uint user_len
= hash_len
- 32;
15945 const u8
*tmp_hash
= tmp_buf
+ user_len
;
15947 user_len
--; // skip the trailing space
15949 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
15950 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
15951 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
15952 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
15954 digest
[0] = byte_swap_32 (digest
[0]);
15955 digest
[1] = byte_swap_32 (digest
[1]);
15956 digest
[2] = byte_swap_32 (digest
[2]);
15957 digest
[3] = byte_swap_32 (digest
[3]);
15959 // store username for host only (output hash if cracked)
15961 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15962 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15964 return (PARSER_OK
);
15967 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15969 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15971 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15973 u32
*digest
= (u32
*) hash_buf
->digest
;
15975 salt_t
*salt
= hash_buf
->salt
;
15977 char *iter_pos
= input_buf
+ 10;
15979 u32 iter
= atoi (iter_pos
);
15983 return (PARSER_SALT_ITERATION
);
15986 iter
--; // first iteration is special
15988 salt
->salt_iter
= iter
;
15990 char *base64_pos
= strchr (iter_pos
, '}');
15992 if (base64_pos
== NULL
)
15994 return (PARSER_SIGNATURE_UNMATCHED
);
15999 // base64 decode salt
16001 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16003 u8 tmp_buf
[100] = { 0 };
16005 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16007 if (decoded_len
< 24)
16009 return (PARSER_SALT_LENGTH
);
16014 uint salt_len
= decoded_len
- 20;
16016 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16017 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16019 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16021 salt
->salt_len
= salt_len
;
16025 u32
*digest_ptr
= (u32
*) tmp_buf
;
16027 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16028 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16029 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16030 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16031 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16033 return (PARSER_OK
);
16036 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16038 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16040 u32
*digest
= (u32
*) hash_buf
->digest
;
16042 salt_t
*salt
= hash_buf
->salt
;
16044 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16045 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16046 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16047 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16048 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16050 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16052 uint salt_len
= input_len
- 40 - 1;
16054 char *salt_buf
= input_buf
+ 40 + 1;
16056 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16058 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16060 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16062 salt
->salt_len
= salt_len
;
16064 return (PARSER_OK
);
16067 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16069 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16071 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16073 u32
*digest
= (u32
*) hash_buf
->digest
;
16075 salt_t
*salt
= hash_buf
->salt
;
16077 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16083 char *V_pos
= input_buf
+ 5;
16085 char *R_pos
= strchr (V_pos
, '*');
16087 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16089 u32 V_len
= R_pos
- V_pos
;
16093 char *bits_pos
= strchr (R_pos
, '*');
16095 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16097 u32 R_len
= bits_pos
- R_pos
;
16101 char *P_pos
= strchr (bits_pos
, '*');
16103 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16105 u32 bits_len
= P_pos
- bits_pos
;
16109 char *enc_md_pos
= strchr (P_pos
, '*');
16111 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16113 u32 P_len
= enc_md_pos
- P_pos
;
16117 char *id_len_pos
= strchr (enc_md_pos
, '*');
16119 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16121 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16125 char *id_buf_pos
= strchr (id_len_pos
, '*');
16127 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16129 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16133 char *u_len_pos
= strchr (id_buf_pos
, '*');
16135 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16137 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16139 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16143 char *u_buf_pos
= strchr (u_len_pos
, '*');
16145 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16147 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16151 char *o_len_pos
= strchr (u_buf_pos
, '*');
16153 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16155 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16157 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16161 char *o_buf_pos
= strchr (o_len_pos
, '*');
16163 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16165 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16169 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;
16171 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16175 const int V
= atoi (V_pos
);
16176 const int R
= atoi (R_pos
);
16177 const int P
= atoi (P_pos
);
16179 if (V
!= 1) return (PARSER_SALT_VALUE
);
16180 if (R
!= 2) return (PARSER_SALT_VALUE
);
16182 const int enc_md
= atoi (enc_md_pos
);
16184 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16186 const int id_len
= atoi (id_len_pos
);
16187 const int u_len
= atoi (u_len_pos
);
16188 const int o_len
= atoi (o_len_pos
);
16190 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16191 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16192 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16194 const int bits
= atoi (bits_pos
);
16196 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16198 // copy data to esalt
16204 pdf
->enc_md
= enc_md
;
16206 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16207 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16208 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16209 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16210 pdf
->id_len
= id_len
;
16212 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16213 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16214 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16215 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16216 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16217 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16218 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16219 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16220 pdf
->u_len
= u_len
;
16222 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16223 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16224 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16225 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16226 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16227 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16228 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16229 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16230 pdf
->o_len
= o_len
;
16232 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16233 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16234 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16235 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16237 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16238 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16239 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16240 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16241 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16242 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16243 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16244 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16246 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16247 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16248 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16249 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16250 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16251 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16252 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16253 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16255 // we use ID for salt, maybe needs to change, we will see...
16257 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16258 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16259 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16260 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16261 salt
->salt_len
= pdf
->id_len
;
16263 digest
[0] = pdf
->u_buf
[0];
16264 digest
[1] = pdf
->u_buf
[1];
16265 digest
[2] = pdf
->u_buf
[2];
16266 digest
[3] = pdf
->u_buf
[3];
16268 return (PARSER_OK
);
16271 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16273 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16276 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16278 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16280 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16282 u32
*digest
= (u32
*) hash_buf
->digest
;
16284 salt_t
*salt
= hash_buf
->salt
;
16286 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16292 char *V_pos
= input_buf
+ 5;
16294 char *R_pos
= strchr (V_pos
, '*');
16296 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16298 u32 V_len
= R_pos
- V_pos
;
16302 char *bits_pos
= strchr (R_pos
, '*');
16304 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16306 u32 R_len
= bits_pos
- R_pos
;
16310 char *P_pos
= strchr (bits_pos
, '*');
16312 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16314 u32 bits_len
= P_pos
- bits_pos
;
16318 char *enc_md_pos
= strchr (P_pos
, '*');
16320 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16322 u32 P_len
= enc_md_pos
- P_pos
;
16326 char *id_len_pos
= strchr (enc_md_pos
, '*');
16328 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16330 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16334 char *id_buf_pos
= strchr (id_len_pos
, '*');
16336 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16338 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16342 char *u_len_pos
= strchr (id_buf_pos
, '*');
16344 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16346 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16348 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16352 char *u_buf_pos
= strchr (u_len_pos
, '*');
16354 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16356 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16360 char *o_len_pos
= strchr (u_buf_pos
, '*');
16362 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16364 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16366 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16370 char *o_buf_pos
= strchr (o_len_pos
, '*');
16372 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16374 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16378 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16380 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16382 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16384 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16388 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;
16390 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16394 const int V
= atoi (V_pos
);
16395 const int R
= atoi (R_pos
);
16396 const int P
= atoi (P_pos
);
16398 if (V
!= 1) return (PARSER_SALT_VALUE
);
16399 if (R
!= 2) return (PARSER_SALT_VALUE
);
16401 const int enc_md
= atoi (enc_md_pos
);
16403 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16405 const int id_len
= atoi (id_len_pos
);
16406 const int u_len
= atoi (u_len_pos
);
16407 const int o_len
= atoi (o_len_pos
);
16409 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16410 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16411 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16413 const int bits
= atoi (bits_pos
);
16415 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16417 // copy data to esalt
16423 pdf
->enc_md
= enc_md
;
16425 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16426 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16427 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16428 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16429 pdf
->id_len
= id_len
;
16431 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16432 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16433 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16434 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16435 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16436 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16437 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16438 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16439 pdf
->u_len
= u_len
;
16441 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16442 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16443 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16444 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16445 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16446 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16447 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16448 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16449 pdf
->o_len
= o_len
;
16451 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16452 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16453 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16454 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16456 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16457 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16458 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16459 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16460 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16461 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16462 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16463 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16465 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16466 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16467 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16468 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16469 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16470 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16471 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16472 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16474 pdf
->rc4key
[1] = 0;
16475 pdf
->rc4key
[0] = 0;
16477 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16478 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16479 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16480 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16481 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16482 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16483 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16484 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16485 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16486 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16488 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16489 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16491 // we use ID for salt, maybe needs to change, we will see...
16493 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16494 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16495 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16496 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16497 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16498 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16499 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16500 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16501 salt
->salt_len
= pdf
->id_len
+ 16;
16503 digest
[0] = pdf
->rc4key
[0];
16504 digest
[1] = pdf
->rc4key
[1];
16508 return (PARSER_OK
);
16511 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16513 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16515 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16517 u32
*digest
= (u32
*) hash_buf
->digest
;
16519 salt_t
*salt
= hash_buf
->salt
;
16521 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16527 char *V_pos
= input_buf
+ 5;
16529 char *R_pos
= strchr (V_pos
, '*');
16531 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16533 u32 V_len
= R_pos
- V_pos
;
16537 char *bits_pos
= strchr (R_pos
, '*');
16539 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16541 u32 R_len
= bits_pos
- R_pos
;
16545 char *P_pos
= strchr (bits_pos
, '*');
16547 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16549 u32 bits_len
= P_pos
- bits_pos
;
16553 char *enc_md_pos
= strchr (P_pos
, '*');
16555 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16557 u32 P_len
= enc_md_pos
- P_pos
;
16561 char *id_len_pos
= strchr (enc_md_pos
, '*');
16563 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16565 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16569 char *id_buf_pos
= strchr (id_len_pos
, '*');
16571 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16573 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16577 char *u_len_pos
= strchr (id_buf_pos
, '*');
16579 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16581 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16583 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16587 char *u_buf_pos
= strchr (u_len_pos
, '*');
16589 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16591 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16595 char *o_len_pos
= strchr (u_buf_pos
, '*');
16597 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16599 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16601 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16605 char *o_buf_pos
= strchr (o_len_pos
, '*');
16607 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16609 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16613 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;
16615 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16619 const int V
= atoi (V_pos
);
16620 const int R
= atoi (R_pos
);
16621 const int P
= atoi (P_pos
);
16625 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16626 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16628 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16630 const int id_len
= atoi (id_len_pos
);
16631 const int u_len
= atoi (u_len_pos
);
16632 const int o_len
= atoi (o_len_pos
);
16634 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16636 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16637 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16639 const int bits
= atoi (bits_pos
);
16641 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16647 enc_md
= atoi (enc_md_pos
);
16650 // copy data to esalt
16656 pdf
->enc_md
= enc_md
;
16658 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16659 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16660 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16661 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16665 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16666 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16667 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16668 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16671 pdf
->id_len
= id_len
;
16673 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16674 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16675 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16676 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16677 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16678 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16679 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16680 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16681 pdf
->u_len
= u_len
;
16683 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16684 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16685 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16686 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16687 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16688 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16689 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16690 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16691 pdf
->o_len
= o_len
;
16693 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16694 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16695 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16696 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16700 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16701 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16702 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16703 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16706 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16707 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16708 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16709 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16710 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16711 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16712 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16713 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16715 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16716 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16717 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16718 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16719 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16720 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16721 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16722 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16724 // precompute rc4 data for later use
16740 uint salt_pc_block
[32] = { 0 };
16742 char *salt_pc_ptr
= (char *) salt_pc_block
;
16744 memcpy (salt_pc_ptr
, padding
, 32);
16745 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16747 uint salt_pc_digest
[4] = { 0 };
16749 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16751 pdf
->rc4data
[0] = salt_pc_digest
[0];
16752 pdf
->rc4data
[1] = salt_pc_digest
[1];
16754 // we use ID for salt, maybe needs to change, we will see...
16756 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16757 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16758 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16759 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16760 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16761 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16762 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16763 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16764 salt
->salt_len
= pdf
->id_len
+ 16;
16766 salt
->salt_iter
= ROUNDS_PDF14
;
16768 digest
[0] = pdf
->u_buf
[0];
16769 digest
[1] = pdf
->u_buf
[1];
16773 return (PARSER_OK
);
16776 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16778 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16780 if (ret
!= PARSER_OK
)
16785 u32
*digest
= (u32
*) hash_buf
->digest
;
16787 salt_t
*salt
= hash_buf
->salt
;
16789 digest
[0] -= SHA256M_A
;
16790 digest
[1] -= SHA256M_B
;
16791 digest
[2] -= SHA256M_C
;
16792 digest
[3] -= SHA256M_D
;
16793 digest
[4] -= SHA256M_E
;
16794 digest
[5] -= SHA256M_F
;
16795 digest
[6] -= SHA256M_G
;
16796 digest
[7] -= SHA256M_H
;
16798 salt
->salt_buf
[2] = 0x80;
16800 return (PARSER_OK
);
16803 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16805 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16807 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16809 u32
*digest
= (u32
*) hash_buf
->digest
;
16811 salt_t
*salt
= hash_buf
->salt
;
16813 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16819 char *V_pos
= input_buf
+ 5;
16821 char *R_pos
= strchr (V_pos
, '*');
16823 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16825 u32 V_len
= R_pos
- V_pos
;
16829 char *bits_pos
= strchr (R_pos
, '*');
16831 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16833 u32 R_len
= bits_pos
- R_pos
;
16837 char *P_pos
= strchr (bits_pos
, '*');
16839 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16841 u32 bits_len
= P_pos
- bits_pos
;
16845 char *enc_md_pos
= strchr (P_pos
, '*');
16847 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16849 u32 P_len
= enc_md_pos
- P_pos
;
16853 char *id_len_pos
= strchr (enc_md_pos
, '*');
16855 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16857 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16861 char *id_buf_pos
= strchr (id_len_pos
, '*');
16863 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16865 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16869 char *u_len_pos
= strchr (id_buf_pos
, '*');
16871 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16873 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16877 char *u_buf_pos
= strchr (u_len_pos
, '*');
16879 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16881 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16885 char *o_len_pos
= strchr (u_buf_pos
, '*');
16887 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16889 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16893 char *o_buf_pos
= strchr (o_len_pos
, '*');
16895 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16897 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16901 char *last
= strchr (o_buf_pos
, '*');
16903 if (last
== NULL
) last
= input_buf
+ input_len
;
16905 u32 o_buf_len
= last
- o_buf_pos
;
16909 const int V
= atoi (V_pos
);
16910 const int R
= atoi (R_pos
);
16914 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16915 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16917 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16919 const int bits
= atoi (bits_pos
);
16921 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16923 int enc_md
= atoi (enc_md_pos
);
16925 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16927 const uint id_len
= atoi (id_len_pos
);
16928 const uint u_len
= atoi (u_len_pos
);
16929 const uint o_len
= atoi (o_len_pos
);
16931 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16932 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16933 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16934 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16935 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16936 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16937 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16938 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16940 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16941 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16942 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16944 // copy data to esalt
16946 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16948 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16950 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
16953 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16954 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16956 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16957 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16959 salt
->salt_len
= 8;
16960 salt
->salt_iter
= ROUNDS_PDF17L8
;
16962 digest
[0] = pdf
->u_buf
[0];
16963 digest
[1] = pdf
->u_buf
[1];
16964 digest
[2] = pdf
->u_buf
[2];
16965 digest
[3] = pdf
->u_buf
[3];
16966 digest
[4] = pdf
->u_buf
[4];
16967 digest
[5] = pdf
->u_buf
[5];
16968 digest
[6] = pdf
->u_buf
[6];
16969 digest
[7] = pdf
->u_buf
[7];
16971 return (PARSER_OK
);
16974 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16976 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
16978 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
16980 u32
*digest
= (u32
*) hash_buf
->digest
;
16982 salt_t
*salt
= hash_buf
->salt
;
16984 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16992 char *iter_pos
= input_buf
+ 7;
16994 u32 iter
= atoi (iter_pos
);
16996 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16997 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
16999 // first is *raw* salt
17001 char *salt_pos
= strchr (iter_pos
, ':');
17003 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17007 char *hash_pos
= strchr (salt_pos
, ':');
17009 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17011 u32 salt_len
= hash_pos
- salt_pos
;
17013 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17017 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17019 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17023 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17025 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17027 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17029 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17030 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17032 salt
->salt_len
= salt_len
;
17033 salt
->salt_iter
= iter
- 1;
17037 u8 tmp_buf
[100] = { 0 };
17039 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17041 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17043 memcpy (digest
, tmp_buf
, 16);
17045 digest
[0] = byte_swap_32 (digest
[0]);
17046 digest
[1] = byte_swap_32 (digest
[1]);
17047 digest
[2] = byte_swap_32 (digest
[2]);
17048 digest
[3] = byte_swap_32 (digest
[3]);
17050 // add some stuff to normal salt to make sorted happy
17052 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17053 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17054 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17055 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17056 salt
->salt_buf
[4] = salt
->salt_iter
;
17058 return (PARSER_OK
);
17061 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17063 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17065 u32
*digest
= (u32
*) hash_buf
->digest
;
17067 salt_t
*salt
= hash_buf
->salt
;
17069 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17070 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17071 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17072 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17074 digest
[0] = byte_swap_32 (digest
[0]);
17075 digest
[1] = byte_swap_32 (digest
[1]);
17076 digest
[2] = byte_swap_32 (digest
[2]);
17077 digest
[3] = byte_swap_32 (digest
[3]);
17079 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17081 uint salt_len
= input_len
- 32 - 1;
17083 char *salt_buf
= input_buf
+ 32 + 1;
17085 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17087 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17089 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17091 salt
->salt_len
= salt_len
;
17093 return (PARSER_OK
);
17096 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17098 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17100 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17102 u32
*digest
= (u32
*) hash_buf
->digest
;
17104 salt_t
*salt
= hash_buf
->salt
;
17106 char *user_pos
= input_buf
+ 10;
17108 char *salt_pos
= strchr (user_pos
, '*');
17110 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17114 char *hash_pos
= strchr (salt_pos
, '*');
17118 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17120 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17122 uint user_len
= salt_pos
- user_pos
- 1;
17124 uint salt_len
= hash_pos
- salt_pos
- 1;
17126 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17132 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17133 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17134 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17135 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17137 digest
[0] = byte_swap_32 (digest
[0]);
17138 digest
[1] = byte_swap_32 (digest
[1]);
17139 digest
[2] = byte_swap_32 (digest
[2]);
17140 digest
[3] = byte_swap_32 (digest
[3]);
17142 digest
[0] -= MD5M_A
;
17143 digest
[1] -= MD5M_B
;
17144 digest
[2] -= MD5M_C
;
17145 digest
[3] -= MD5M_D
;
17151 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17153 // first 4 bytes are the "challenge"
17155 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17156 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17157 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17158 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17160 // append the user name
17162 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17164 salt
->salt_len
= 4 + user_len
;
17166 return (PARSER_OK
);
17169 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17171 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17173 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17175 u32
*digest
= (u32
*) hash_buf
->digest
;
17177 salt_t
*salt
= hash_buf
->salt
;
17179 char *salt_pos
= input_buf
+ 9;
17181 char *hash_pos
= strchr (salt_pos
, '*');
17183 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17187 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17189 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17191 uint salt_len
= hash_pos
- salt_pos
- 1;
17193 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17199 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17200 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17201 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17202 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17203 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17209 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17211 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17213 salt
->salt_len
= salt_len
;
17215 return (PARSER_OK
);
17218 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17220 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17222 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17224 u32
*digest
= (u32
*) hash_buf
->digest
;
17226 salt_t
*salt
= hash_buf
->salt
;
17228 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17234 char *cry_master_len_pos
= input_buf
+ 9;
17236 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17238 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17240 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17242 cry_master_buf_pos
++;
17244 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17246 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17248 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17250 cry_salt_len_pos
++;
17252 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17254 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17256 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17258 cry_salt_buf_pos
++;
17260 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17262 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17264 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17268 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17270 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17272 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17276 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17278 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17280 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17284 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17286 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17288 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17290 public_key_len_pos
++;
17292 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17294 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17296 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17298 public_key_buf_pos
++;
17300 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;
17302 const uint cry_master_len
= atoi (cry_master_len_pos
);
17303 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17304 const uint ckey_len
= atoi (ckey_len_pos
);
17305 const uint public_key_len
= atoi (public_key_len_pos
);
17307 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17308 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17309 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17310 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17312 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17314 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17316 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17319 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17321 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17323 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17326 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17328 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17330 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17333 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17334 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17335 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17338 * store digest (should be unique enought, hopefully)
17341 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17342 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17343 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17344 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17350 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17352 const uint cry_rounds
= atoi (cry_rounds_pos
);
17354 salt
->salt_iter
= cry_rounds
- 1;
17356 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17358 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17360 salt
->salt_len
= salt_len
;
17362 return (PARSER_OK
);
17365 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17367 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17369 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17371 u32
*digest
= (u32
*) hash_buf
->digest
;
17373 salt_t
*salt
= hash_buf
->salt
;
17375 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17377 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17379 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17381 memcpy (temp_input_buf
, input_buf
, input_len
);
17385 char *URI_server_pos
= temp_input_buf
+ 6;
17387 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17389 if (URI_client_pos
== NULL
)
17391 myfree (temp_input_buf
);
17393 return (PARSER_SEPARATOR_UNMATCHED
);
17396 URI_client_pos
[0] = 0;
17399 uint URI_server_len
= strlen (URI_server_pos
);
17401 if (URI_server_len
> 512)
17403 myfree (temp_input_buf
);
17405 return (PARSER_SALT_LENGTH
);
17410 char *user_pos
= strchr (URI_client_pos
, '*');
17412 if (user_pos
== NULL
)
17414 myfree (temp_input_buf
);
17416 return (PARSER_SEPARATOR_UNMATCHED
);
17422 uint URI_client_len
= strlen (URI_client_pos
);
17424 if (URI_client_len
> 512)
17426 myfree (temp_input_buf
);
17428 return (PARSER_SALT_LENGTH
);
17433 char *realm_pos
= strchr (user_pos
, '*');
17435 if (realm_pos
== NULL
)
17437 myfree (temp_input_buf
);
17439 return (PARSER_SEPARATOR_UNMATCHED
);
17445 uint user_len
= strlen (user_pos
);
17447 if (user_len
> 116)
17449 myfree (temp_input_buf
);
17451 return (PARSER_SALT_LENGTH
);
17456 char *method_pos
= strchr (realm_pos
, '*');
17458 if (method_pos
== NULL
)
17460 myfree (temp_input_buf
);
17462 return (PARSER_SEPARATOR_UNMATCHED
);
17468 uint realm_len
= strlen (realm_pos
);
17470 if (realm_len
> 116)
17472 myfree (temp_input_buf
);
17474 return (PARSER_SALT_LENGTH
);
17479 char *URI_prefix_pos
= strchr (method_pos
, '*');
17481 if (URI_prefix_pos
== NULL
)
17483 myfree (temp_input_buf
);
17485 return (PARSER_SEPARATOR_UNMATCHED
);
17488 URI_prefix_pos
[0] = 0;
17491 uint method_len
= strlen (method_pos
);
17493 if (method_len
> 246)
17495 myfree (temp_input_buf
);
17497 return (PARSER_SALT_LENGTH
);
17502 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17504 if (URI_resource_pos
== NULL
)
17506 myfree (temp_input_buf
);
17508 return (PARSER_SEPARATOR_UNMATCHED
);
17511 URI_resource_pos
[0] = 0;
17512 URI_resource_pos
++;
17514 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17516 if (URI_prefix_len
> 245)
17518 myfree (temp_input_buf
);
17520 return (PARSER_SALT_LENGTH
);
17525 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17527 if (URI_suffix_pos
== NULL
)
17529 myfree (temp_input_buf
);
17531 return (PARSER_SEPARATOR_UNMATCHED
);
17534 URI_suffix_pos
[0] = 0;
17537 uint URI_resource_len
= strlen (URI_resource_pos
);
17539 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17541 myfree (temp_input_buf
);
17543 return (PARSER_SALT_LENGTH
);
17548 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17550 if (nonce_pos
== NULL
)
17552 myfree (temp_input_buf
);
17554 return (PARSER_SEPARATOR_UNMATCHED
);
17560 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17562 if (URI_suffix_len
> 245)
17564 myfree (temp_input_buf
);
17566 return (PARSER_SALT_LENGTH
);
17571 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17573 if (nonce_client_pos
== NULL
)
17575 myfree (temp_input_buf
);
17577 return (PARSER_SEPARATOR_UNMATCHED
);
17580 nonce_client_pos
[0] = 0;
17581 nonce_client_pos
++;
17583 uint nonce_len
= strlen (nonce_pos
);
17585 if (nonce_len
< 1 || nonce_len
> 50)
17587 myfree (temp_input_buf
);
17589 return (PARSER_SALT_LENGTH
);
17594 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17596 if (nonce_count_pos
== NULL
)
17598 myfree (temp_input_buf
);
17600 return (PARSER_SEPARATOR_UNMATCHED
);
17603 nonce_count_pos
[0] = 0;
17606 uint nonce_client_len
= strlen (nonce_client_pos
);
17608 if (nonce_client_len
> 50)
17610 myfree (temp_input_buf
);
17612 return (PARSER_SALT_LENGTH
);
17617 char *qop_pos
= strchr (nonce_count_pos
, '*');
17619 if (qop_pos
== NULL
)
17621 myfree (temp_input_buf
);
17623 return (PARSER_SEPARATOR_UNMATCHED
);
17629 uint nonce_count_len
= strlen (nonce_count_pos
);
17631 if (nonce_count_len
> 50)
17633 myfree (temp_input_buf
);
17635 return (PARSER_SALT_LENGTH
);
17640 char *directive_pos
= strchr (qop_pos
, '*');
17642 if (directive_pos
== NULL
)
17644 myfree (temp_input_buf
);
17646 return (PARSER_SEPARATOR_UNMATCHED
);
17649 directive_pos
[0] = 0;
17652 uint qop_len
= strlen (qop_pos
);
17656 myfree (temp_input_buf
);
17658 return (PARSER_SALT_LENGTH
);
17663 char *digest_pos
= strchr (directive_pos
, '*');
17665 if (digest_pos
== NULL
)
17667 myfree (temp_input_buf
);
17669 return (PARSER_SEPARATOR_UNMATCHED
);
17675 uint directive_len
= strlen (directive_pos
);
17677 if (directive_len
!= 3)
17679 myfree (temp_input_buf
);
17681 return (PARSER_SALT_LENGTH
);
17684 if (memcmp (directive_pos
, "MD5", 3))
17686 log_info ("ERROR: only the MD5 directive is currently supported\n");
17688 myfree (temp_input_buf
);
17690 return (PARSER_SIP_AUTH_DIRECTIVE
);
17694 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17699 uint md5_max_len
= 4 * 64;
17701 uint md5_remaining_len
= md5_max_len
;
17703 uint tmp_md5_buf
[64] = { 0 };
17705 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17707 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17709 md5_len
+= method_len
+ 1;
17710 tmp_md5_ptr
+= method_len
+ 1;
17712 if (URI_prefix_len
> 0)
17714 md5_remaining_len
= md5_max_len
- md5_len
;
17716 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17718 md5_len
+= URI_prefix_len
+ 1;
17719 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17722 md5_remaining_len
= md5_max_len
- md5_len
;
17724 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17726 md5_len
+= URI_resource_len
;
17727 tmp_md5_ptr
+= URI_resource_len
;
17729 if (URI_suffix_len
> 0)
17731 md5_remaining_len
= md5_max_len
- md5_len
;
17733 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17735 md5_len
+= 1 + URI_suffix_len
;
17738 uint tmp_digest
[4] = { 0 };
17740 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17742 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17743 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17744 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17745 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17751 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17753 uint esalt_len
= 0;
17755 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17757 // there are 2 possibilities for the esalt:
17759 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17761 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17763 if (esalt_len
> max_esalt_len
)
17765 myfree (temp_input_buf
);
17767 return (PARSER_SALT_LENGTH
);
17770 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17782 esalt_len
= 1 + nonce_len
+ 1 + 32;
17784 if (esalt_len
> max_esalt_len
)
17786 myfree (temp_input_buf
);
17788 return (PARSER_SALT_LENGTH
);
17791 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17799 // add 0x80 to esalt
17801 esalt_buf_ptr
[esalt_len
] = 0x80;
17803 sip
->esalt_len
= esalt_len
;
17809 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17811 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17813 uint max_salt_len
= 119;
17815 if (salt_len
> max_salt_len
)
17817 myfree (temp_input_buf
);
17819 return (PARSER_SALT_LENGTH
);
17822 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17824 sip
->salt_len
= salt_len
;
17827 * fake salt (for sorting)
17830 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17834 uint fake_salt_len
= salt_len
;
17836 if (fake_salt_len
> max_salt_len
)
17838 fake_salt_len
= max_salt_len
;
17841 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17843 salt
->salt_len
= fake_salt_len
;
17849 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17850 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17851 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17852 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17854 digest
[0] = byte_swap_32 (digest
[0]);
17855 digest
[1] = byte_swap_32 (digest
[1]);
17856 digest
[2] = byte_swap_32 (digest
[2]);
17857 digest
[3] = byte_swap_32 (digest
[3]);
17859 myfree (temp_input_buf
);
17861 return (PARSER_OK
);
17864 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17866 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17868 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17870 u32
*digest
= (u32
*) hash_buf
->digest
;
17872 salt_t
*salt
= hash_buf
->salt
;
17876 char *digest_pos
= input_buf
;
17878 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17885 char *salt_buf
= input_buf
+ 8 + 1;
17889 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17891 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17893 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17895 salt
->salt_len
= salt_len
;
17897 return (PARSER_OK
);
17900 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17902 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17904 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17906 u32
*digest
= (u32
*) hash_buf
->digest
;
17908 salt_t
*salt
= hash_buf
->salt
;
17910 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17916 char *p_buf_pos
= input_buf
+ 4;
17918 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17920 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17922 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17924 NumCyclesPower_pos
++;
17926 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17928 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17930 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17934 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17936 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17938 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
17942 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17944 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17946 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17950 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17952 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17954 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
17958 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17960 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17962 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17966 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17968 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17970 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
17974 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17976 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17978 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
17982 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17984 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17986 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17990 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;
17992 const uint iter
= atoi (NumCyclesPower_pos
);
17993 const uint crc
= atoi (crc_buf_pos
);
17994 const uint p_buf
= atoi (p_buf_pos
);
17995 const uint salt_len
= atoi (salt_len_pos
);
17996 const uint iv_len
= atoi (iv_len_pos
);
17997 const uint unpack_size
= atoi (unpack_size_pos
);
17998 const uint data_len
= atoi (data_len_pos
);
18004 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18005 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18007 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18009 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18011 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18017 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18018 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18019 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18020 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18022 seven_zip
->iv_len
= iv_len
;
18024 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18026 seven_zip
->salt_len
= 0;
18028 seven_zip
->crc
= crc
;
18030 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18032 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18034 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18037 seven_zip
->data_len
= data_len
;
18039 seven_zip
->unpack_size
= unpack_size
;
18043 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18044 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18045 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18046 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18048 salt
->salt_len
= 16;
18050 salt
->salt_sign
[0] = iter
;
18052 salt
->salt_iter
= 1 << iter
;
18063 return (PARSER_OK
);
18066 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18068 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18070 u32
*digest
= (u32
*) hash_buf
->digest
;
18072 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18073 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18074 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18075 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18076 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18077 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18078 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18079 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18081 digest
[0] = byte_swap_32 (digest
[0]);
18082 digest
[1] = byte_swap_32 (digest
[1]);
18083 digest
[2] = byte_swap_32 (digest
[2]);
18084 digest
[3] = byte_swap_32 (digest
[3]);
18085 digest
[4] = byte_swap_32 (digest
[4]);
18086 digest
[5] = byte_swap_32 (digest
[5]);
18087 digest
[6] = byte_swap_32 (digest
[6]);
18088 digest
[7] = byte_swap_32 (digest
[7]);
18090 return (PARSER_OK
);
18093 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18095 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18097 u32
*digest
= (u32
*) hash_buf
->digest
;
18099 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18100 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18101 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18102 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18103 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18104 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18105 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18106 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18107 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18108 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18109 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18110 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18111 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18112 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18113 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18114 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18116 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18117 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18118 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18119 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18120 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18121 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18122 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18123 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18124 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18125 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18126 digest
[10] = byte_swap_32 (digest
[10]);
18127 digest
[11] = byte_swap_32 (digest
[11]);
18128 digest
[12] = byte_swap_32 (digest
[12]);
18129 digest
[13] = byte_swap_32 (digest
[13]);
18130 digest
[14] = byte_swap_32 (digest
[14]);
18131 digest
[15] = byte_swap_32 (digest
[15]);
18133 return (PARSER_OK
);
18136 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18138 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18140 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18142 u32
*digest
= (u32
*) hash_buf
->digest
;
18144 salt_t
*salt
= hash_buf
->salt
;
18146 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18154 char *iter_pos
= input_buf
+ 4;
18156 u32 iter
= atoi (iter_pos
);
18158 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18159 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18161 // first is *raw* salt
18163 char *salt_pos
= strchr (iter_pos
, ':');
18165 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18169 char *hash_pos
= strchr (salt_pos
, ':');
18171 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18173 u32 salt_len
= hash_pos
- salt_pos
;
18175 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18179 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18181 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18185 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18187 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18189 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18191 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18192 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18194 salt
->salt_len
= salt_len
;
18195 salt
->salt_iter
= iter
- 1;
18199 u8 tmp_buf
[100] = { 0 };
18201 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18203 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18205 memcpy (digest
, tmp_buf
, 16);
18207 // add some stuff to normal salt to make sorted happy
18209 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18210 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18211 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18212 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18213 salt
->salt_buf
[4] = salt
->salt_iter
;
18215 return (PARSER_OK
);
18218 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18220 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18222 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18224 u32
*digest
= (u32
*) hash_buf
->digest
;
18226 salt_t
*salt
= hash_buf
->salt
;
18228 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18236 char *iter_pos
= input_buf
+ 5;
18238 u32 iter
= atoi (iter_pos
);
18240 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18241 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18243 // first is *raw* salt
18245 char *salt_pos
= strchr (iter_pos
, ':');
18247 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18251 char *hash_pos
= strchr (salt_pos
, ':');
18253 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18255 u32 salt_len
= hash_pos
- salt_pos
;
18257 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18261 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18263 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18267 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18269 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18271 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18273 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18274 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18276 salt
->salt_len
= salt_len
;
18277 salt
->salt_iter
= iter
- 1;
18281 u8 tmp_buf
[100] = { 0 };
18283 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18285 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18287 memcpy (digest
, tmp_buf
, 16);
18289 digest
[0] = byte_swap_32 (digest
[0]);
18290 digest
[1] = byte_swap_32 (digest
[1]);
18291 digest
[2] = byte_swap_32 (digest
[2]);
18292 digest
[3] = byte_swap_32 (digest
[3]);
18294 // add some stuff to normal salt to make sorted happy
18296 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18297 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18298 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18299 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18300 salt
->salt_buf
[4] = salt
->salt_iter
;
18302 return (PARSER_OK
);
18305 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18307 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18309 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18311 u64
*digest
= (u64
*) hash_buf
->digest
;
18313 salt_t
*salt
= hash_buf
->salt
;
18315 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18323 char *iter_pos
= input_buf
+ 7;
18325 u32 iter
= atoi (iter_pos
);
18327 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18328 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18330 // first is *raw* salt
18332 char *salt_pos
= strchr (iter_pos
, ':');
18334 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18338 char *hash_pos
= strchr (salt_pos
, ':');
18340 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18342 u32 salt_len
= hash_pos
- salt_pos
;
18344 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18348 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18350 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18354 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18356 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18358 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18360 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18361 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18363 salt
->salt_len
= salt_len
;
18364 salt
->salt_iter
= iter
- 1;
18368 u8 tmp_buf
[100] = { 0 };
18370 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18372 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18374 memcpy (digest
, tmp_buf
, 64);
18376 digest
[0] = byte_swap_64 (digest
[0]);
18377 digest
[1] = byte_swap_64 (digest
[1]);
18378 digest
[2] = byte_swap_64 (digest
[2]);
18379 digest
[3] = byte_swap_64 (digest
[3]);
18380 digest
[4] = byte_swap_64 (digest
[4]);
18381 digest
[5] = byte_swap_64 (digest
[5]);
18382 digest
[6] = byte_swap_64 (digest
[6]);
18383 digest
[7] = byte_swap_64 (digest
[7]);
18385 // add some stuff to normal salt to make sorted happy
18387 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18388 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18389 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18390 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18391 salt
->salt_buf
[4] = salt
->salt_iter
;
18393 return (PARSER_OK
);
18396 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18398 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18400 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18402 uint
*digest
= (uint
*) hash_buf
->digest
;
18404 salt_t
*salt
= hash_buf
->salt
;
18410 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18412 char *hash_pos
= strchr (salt_pos
, '$');
18414 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18416 u32 salt_len
= hash_pos
- salt_pos
;
18418 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18422 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18424 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18428 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18429 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18447 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18448 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18450 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18451 salt
->salt_len
= 8;
18453 return (PARSER_OK
);
18456 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18458 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18460 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18462 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18464 if (c19
& 3) return (PARSER_HASH_VALUE
);
18466 salt_t
*salt
= hash_buf
->salt
;
18468 u32
*digest
= (u32
*) hash_buf
->digest
;
18472 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18473 | itoa64_to_int (input_buf
[2]) << 6
18474 | itoa64_to_int (input_buf
[3]) << 12
18475 | itoa64_to_int (input_buf
[4]) << 18;
18479 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18480 | itoa64_to_int (input_buf
[6]) << 6
18481 | itoa64_to_int (input_buf
[7]) << 12
18482 | itoa64_to_int (input_buf
[8]) << 18;
18484 salt
->salt_len
= 4;
18486 u8 tmp_buf
[100] = { 0 };
18488 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18490 memcpy (digest
, tmp_buf
, 8);
18494 IP (digest
[0], digest
[1], tt
);
18496 digest
[0] = rotr32 (digest
[0], 31);
18497 digest
[1] = rotr32 (digest
[1], 31);
18501 return (PARSER_OK
);
18504 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18506 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18508 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18510 u32
*digest
= (u32
*) hash_buf
->digest
;
18512 salt_t
*salt
= hash_buf
->salt
;
18518 char *type_pos
= input_buf
+ 6 + 1;
18520 char *salt_pos
= strchr (type_pos
, '*');
18522 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18524 u32 type_len
= salt_pos
- type_pos
;
18526 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18530 char *crypted_pos
= strchr (salt_pos
, '*');
18532 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18534 u32 salt_len
= crypted_pos
- salt_pos
;
18536 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18540 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18542 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18548 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18549 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18551 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18552 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18554 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18555 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18556 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18557 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18559 salt
->salt_len
= 24;
18560 salt
->salt_iter
= ROUNDS_RAR3
;
18562 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18563 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18565 digest
[0] = 0xc43d7b00;
18566 digest
[1] = 0x40070000;
18570 return (PARSER_OK
);
18573 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18575 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18577 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18579 u32
*digest
= (u32
*) hash_buf
->digest
;
18581 salt_t
*salt
= hash_buf
->salt
;
18583 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18589 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18591 char *param1_pos
= strchr (param0_pos
, '$');
18593 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18595 u32 param0_len
= param1_pos
- param0_pos
;
18599 char *param2_pos
= strchr (param1_pos
, '$');
18601 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18603 u32 param1_len
= param2_pos
- param1_pos
;
18607 char *param3_pos
= strchr (param2_pos
, '$');
18609 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18611 u32 param2_len
= param3_pos
- param2_pos
;
18615 char *param4_pos
= strchr (param3_pos
, '$');
18617 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18619 u32 param3_len
= param4_pos
- param3_pos
;
18623 char *param5_pos
= strchr (param4_pos
, '$');
18625 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18627 u32 param4_len
= param5_pos
- param4_pos
;
18631 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18633 char *salt_buf
= param1_pos
;
18634 char *iv
= param3_pos
;
18635 char *pswcheck
= param5_pos
;
18637 const uint salt_len
= atoi (param0_pos
);
18638 const uint iterations
= atoi (param2_pos
);
18639 const uint pswcheck_len
= atoi (param4_pos
);
18645 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18646 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18647 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18649 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18650 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18651 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18657 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18658 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18659 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18660 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18662 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18663 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18664 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18665 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18667 salt
->salt_len
= 16;
18669 salt
->salt_sign
[0] = iterations
;
18671 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18677 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18678 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18682 return (PARSER_OK
);
18685 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18687 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18689 u32
*digest
= (u32
*) hash_buf
->digest
;
18691 salt_t
*salt
= hash_buf
->salt
;
18693 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18694 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18695 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18696 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18697 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18698 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18699 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18700 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18702 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18704 uint salt_len
= input_len
- 64 - 1;
18706 char *salt_buf
= input_buf
+ 64 + 1;
18708 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18710 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18712 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18714 salt
->salt_len
= salt_len
;
18717 * we can precompute the first sha256 transform
18720 uint w
[16] = { 0 };
18722 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18723 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18724 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18725 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18726 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18727 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18728 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18729 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18730 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18731 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18732 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18733 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18734 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18735 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18736 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18737 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18739 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
18741 sha256_64 (w
, pc256
);
18743 salt
->salt_buf_pc
[0] = pc256
[0];
18744 salt
->salt_buf_pc
[1] = pc256
[1];
18745 salt
->salt_buf_pc
[2] = pc256
[2];
18746 salt
->salt_buf_pc
[3] = pc256
[3];
18747 salt
->salt_buf_pc
[4] = pc256
[4];
18748 salt
->salt_buf_pc
[5] = pc256
[5];
18749 salt
->salt_buf_pc
[6] = pc256
[6];
18750 salt
->salt_buf_pc
[7] = pc256
[7];
18752 digest
[0] -= pc256
[0];
18753 digest
[1] -= pc256
[1];
18754 digest
[2] -= pc256
[2];
18755 digest
[3] -= pc256
[3];
18756 digest
[4] -= pc256
[4];
18757 digest
[5] -= pc256
[5];
18758 digest
[6] -= pc256
[6];
18759 digest
[7] -= pc256
[7];
18761 return (PARSER_OK
);
18764 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18766 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18768 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18770 u32
*digest
= (u32
*) hash_buf
->digest
;
18772 salt_t
*salt
= hash_buf
->salt
;
18778 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18780 char *data_buf_pos
= strchr (data_len_pos
, '$');
18782 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18784 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18786 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18787 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18791 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18793 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18795 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18797 u32 data_len
= atoi (data_len_pos
);
18799 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18805 char *salt_pos
= data_buf_pos
;
18807 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18808 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18809 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
18810 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
18812 // this is actually the CT, which is also the hash later (if matched)
18814 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
18815 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
18816 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
18817 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
18819 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18821 salt
->salt_iter
= 10 - 1;
18827 digest
[0] = salt
->salt_buf
[4];
18828 digest
[1] = salt
->salt_buf
[5];
18829 digest
[2] = salt
->salt_buf
[6];
18830 digest
[3] = salt
->salt_buf
[7];
18832 return (PARSER_OK
);
18835 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18837 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18839 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18841 u32
*digest
= (u32
*) hash_buf
->digest
;
18843 salt_t
*salt
= hash_buf
->salt
;
18849 char *salt_pos
= input_buf
+ 11 + 1;
18851 char *iter_pos
= strchr (salt_pos
, ',');
18853 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18855 u32 salt_len
= iter_pos
- salt_pos
;
18857 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18861 char *hash_pos
= strchr (iter_pos
, ',');
18863 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18865 u32 iter_len
= hash_pos
- iter_pos
;
18867 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18871 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18873 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18879 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18880 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18881 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
18882 salt
->salt_buf
[3] = 0x00018000;
18884 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18885 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18886 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18887 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18889 salt
->salt_len
= salt_len
/ 2;
18891 salt
->salt_iter
= atoi (iter_pos
) - 1;
18897 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18898 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18899 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18900 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18901 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18902 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18903 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18904 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18906 return (PARSER_OK
);
18909 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18911 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
18913 u32
*digest
= (u32
*) hash_buf
->digest
;
18915 salt_t
*salt
= hash_buf
->salt
;
18921 char *hash_pos
= input_buf
+ 64;
18922 char *salt1_pos
= input_buf
+ 128;
18923 char *salt2_pos
= input_buf
;
18929 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
18930 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
18931 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
18932 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
18934 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
18935 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
18936 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
18937 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
18939 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
18940 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
18941 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
18942 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
18944 salt
->salt_len
= 48;
18946 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
18952 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18953 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18954 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18955 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18956 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18957 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18958 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18959 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18961 return (PARSER_OK
);
18965 * parallel running threads
18970 BOOL WINAPI
sigHandler_default (DWORD sig
)
18974 case CTRL_CLOSE_EVENT
:
18977 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18978 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18979 * function otherwise it is too late (e.g. after returning from this function)
18984 SetConsoleCtrlHandler (NULL
, TRUE
);
18991 case CTRL_LOGOFF_EVENT
:
18992 case CTRL_SHUTDOWN_EVENT
:
18996 SetConsoleCtrlHandler (NULL
, TRUE
);
19004 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19008 case CTRL_CLOSE_EVENT
:
19012 SetConsoleCtrlHandler (NULL
, TRUE
);
19019 case CTRL_LOGOFF_EVENT
:
19020 case CTRL_SHUTDOWN_EVENT
:
19024 SetConsoleCtrlHandler (NULL
, TRUE
);
19032 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19034 if (callback
== NULL
)
19036 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19040 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19046 void sigHandler_default (int sig
)
19050 signal (sig
, NULL
);
19053 void sigHandler_benchmark (int sig
)
19057 signal (sig
, NULL
);
19060 void hc_signal (void (callback
) (int))
19062 if (callback
== NULL
) callback
= SIG_DFL
;
19064 signal (SIGINT
, callback
);
19065 signal (SIGTERM
, callback
);
19066 signal (SIGABRT
, callback
);
19071 void status_display ();
19073 void *thread_keypress (void *p
)
19075 int benchmark
= *((int *) p
);
19077 uint quiet
= data
.quiet
;
19081 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19083 int ch
= tty_getchar();
19085 if (ch
== -1) break;
19087 if (ch
== 0) continue;
19093 hc_thread_mutex_lock (mux_display
);
19108 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19109 if (quiet
== 0) fflush (stdout
);
19121 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19122 if (quiet
== 0) fflush (stdout
);
19134 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19135 if (quiet
== 0) fflush (stdout
);
19147 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19148 if (quiet
== 0) fflush (stdout
);
19156 if (benchmark
== 1) break;
19158 stop_at_checkpoint ();
19162 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19163 if (quiet
== 0) fflush (stdout
);
19171 if (benchmark
== 1)
19183 hc_thread_mutex_unlock (mux_display
);
19195 bool class_num (const u8 c
)
19197 return ((c
>= '0') && (c
<= '9'));
19200 bool class_lower (const u8 c
)
19202 return ((c
>= 'a') && (c
<= 'z'));
19205 bool class_upper (const u8 c
)
19207 return ((c
>= 'A') && (c
<= 'Z'));
19210 bool class_alpha (const u8 c
)
19212 return (class_lower (c
) || class_upper (c
));
19215 int conv_ctoi (const u8 c
)
19221 else if (class_upper (c
))
19223 return c
- 'A' + 10;
19229 int conv_itoc (const u8 c
)
19237 return c
+ 'A' - 10;
19247 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19248 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19249 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19250 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19251 #define MAX_KERNEL_RULES 255
19252 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19253 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19254 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19256 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19257 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19258 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19259 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19261 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19266 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19268 switch (rule_buf
[rule_pos
])
19274 case RULE_OP_MANGLE_NOOP
:
19275 SET_NAME (rule
, rule_buf
[rule_pos
]);
19278 case RULE_OP_MANGLE_LREST
:
19279 SET_NAME (rule
, rule_buf
[rule_pos
]);
19282 case RULE_OP_MANGLE_UREST
:
19283 SET_NAME (rule
, rule_buf
[rule_pos
]);
19286 case RULE_OP_MANGLE_LREST_UFIRST
:
19287 SET_NAME (rule
, rule_buf
[rule_pos
]);
19290 case RULE_OP_MANGLE_UREST_LFIRST
:
19291 SET_NAME (rule
, rule_buf
[rule_pos
]);
19294 case RULE_OP_MANGLE_TREST
:
19295 SET_NAME (rule
, rule_buf
[rule_pos
]);
19298 case RULE_OP_MANGLE_TOGGLE_AT
:
19299 SET_NAME (rule
, rule_buf
[rule_pos
]);
19300 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19303 case RULE_OP_MANGLE_REVERSE
:
19304 SET_NAME (rule
, rule_buf
[rule_pos
]);
19307 case RULE_OP_MANGLE_DUPEWORD
:
19308 SET_NAME (rule
, rule_buf
[rule_pos
]);
19311 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19312 SET_NAME (rule
, rule_buf
[rule_pos
]);
19313 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19316 case RULE_OP_MANGLE_REFLECT
:
19317 SET_NAME (rule
, rule_buf
[rule_pos
]);
19320 case RULE_OP_MANGLE_ROTATE_LEFT
:
19321 SET_NAME (rule
, rule_buf
[rule_pos
]);
19324 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19325 SET_NAME (rule
, rule_buf
[rule_pos
]);
19328 case RULE_OP_MANGLE_APPEND
:
19329 SET_NAME (rule
, rule_buf
[rule_pos
]);
19330 SET_P0 (rule
, rule_buf
[rule_pos
]);
19333 case RULE_OP_MANGLE_PREPEND
:
19334 SET_NAME (rule
, rule_buf
[rule_pos
]);
19335 SET_P0 (rule
, rule_buf
[rule_pos
]);
19338 case RULE_OP_MANGLE_DELETE_FIRST
:
19339 SET_NAME (rule
, rule_buf
[rule_pos
]);
19342 case RULE_OP_MANGLE_DELETE_LAST
:
19343 SET_NAME (rule
, rule_buf
[rule_pos
]);
19346 case RULE_OP_MANGLE_DELETE_AT
:
19347 SET_NAME (rule
, rule_buf
[rule_pos
]);
19348 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19351 case RULE_OP_MANGLE_EXTRACT
:
19352 SET_NAME (rule
, rule_buf
[rule_pos
]);
19353 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19354 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19357 case RULE_OP_MANGLE_OMIT
:
19358 SET_NAME (rule
, rule_buf
[rule_pos
]);
19359 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19360 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19363 case RULE_OP_MANGLE_INSERT
:
19364 SET_NAME (rule
, rule_buf
[rule_pos
]);
19365 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19366 SET_P1 (rule
, rule_buf
[rule_pos
]);
19369 case RULE_OP_MANGLE_OVERSTRIKE
:
19370 SET_NAME (rule
, rule_buf
[rule_pos
]);
19371 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19372 SET_P1 (rule
, rule_buf
[rule_pos
]);
19375 case RULE_OP_MANGLE_TRUNCATE_AT
:
19376 SET_NAME (rule
, rule_buf
[rule_pos
]);
19377 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19380 case RULE_OP_MANGLE_REPLACE
:
19381 SET_NAME (rule
, rule_buf
[rule_pos
]);
19382 SET_P0 (rule
, rule_buf
[rule_pos
]);
19383 SET_P1 (rule
, rule_buf
[rule_pos
]);
19386 case RULE_OP_MANGLE_PURGECHAR
:
19390 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19394 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19395 SET_NAME (rule
, rule_buf
[rule_pos
]);
19396 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19399 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19400 SET_NAME (rule
, rule_buf
[rule_pos
]);
19401 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19404 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19405 SET_NAME (rule
, rule_buf
[rule_pos
]);
19408 case RULE_OP_MANGLE_SWITCH_FIRST
:
19409 SET_NAME (rule
, rule_buf
[rule_pos
]);
19412 case RULE_OP_MANGLE_SWITCH_LAST
:
19413 SET_NAME (rule
, rule_buf
[rule_pos
]);
19416 case RULE_OP_MANGLE_SWITCH_AT
:
19417 SET_NAME (rule
, rule_buf
[rule_pos
]);
19418 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19419 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19422 case RULE_OP_MANGLE_CHR_SHIFTL
:
19423 SET_NAME (rule
, rule_buf
[rule_pos
]);
19424 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19427 case RULE_OP_MANGLE_CHR_SHIFTR
:
19428 SET_NAME (rule
, rule_buf
[rule_pos
]);
19429 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19432 case RULE_OP_MANGLE_CHR_INCR
:
19433 SET_NAME (rule
, rule_buf
[rule_pos
]);
19434 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19437 case RULE_OP_MANGLE_CHR_DECR
:
19438 SET_NAME (rule
, rule_buf
[rule_pos
]);
19439 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19442 case RULE_OP_MANGLE_REPLACE_NP1
:
19443 SET_NAME (rule
, rule_buf
[rule_pos
]);
19444 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19447 case RULE_OP_MANGLE_REPLACE_NM1
:
19448 SET_NAME (rule
, rule_buf
[rule_pos
]);
19449 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19452 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19453 SET_NAME (rule
, rule_buf
[rule_pos
]);
19454 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19457 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19458 SET_NAME (rule
, rule_buf
[rule_pos
]);
19459 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19462 case RULE_OP_MANGLE_TITLE
:
19463 SET_NAME (rule
, rule_buf
[rule_pos
]);
19472 if (rule_pos
< rule_len
) return (-1);
19477 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19481 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19485 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19489 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19493 case RULE_OP_MANGLE_NOOP
:
19494 rule_buf
[rule_pos
] = rule_cmd
;
19497 case RULE_OP_MANGLE_LREST
:
19498 rule_buf
[rule_pos
] = rule_cmd
;
19501 case RULE_OP_MANGLE_UREST
:
19502 rule_buf
[rule_pos
] = rule_cmd
;
19505 case RULE_OP_MANGLE_LREST_UFIRST
:
19506 rule_buf
[rule_pos
] = rule_cmd
;
19509 case RULE_OP_MANGLE_UREST_LFIRST
:
19510 rule_buf
[rule_pos
] = rule_cmd
;
19513 case RULE_OP_MANGLE_TREST
:
19514 rule_buf
[rule_pos
] = rule_cmd
;
19517 case RULE_OP_MANGLE_TOGGLE_AT
:
19518 rule_buf
[rule_pos
] = rule_cmd
;
19519 GET_P0_CONV (rule
);
19522 case RULE_OP_MANGLE_REVERSE
:
19523 rule_buf
[rule_pos
] = rule_cmd
;
19526 case RULE_OP_MANGLE_DUPEWORD
:
19527 rule_buf
[rule_pos
] = rule_cmd
;
19530 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19531 rule_buf
[rule_pos
] = rule_cmd
;
19532 GET_P0_CONV (rule
);
19535 case RULE_OP_MANGLE_REFLECT
:
19536 rule_buf
[rule_pos
] = rule_cmd
;
19539 case RULE_OP_MANGLE_ROTATE_LEFT
:
19540 rule_buf
[rule_pos
] = rule_cmd
;
19543 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19544 rule_buf
[rule_pos
] = rule_cmd
;
19547 case RULE_OP_MANGLE_APPEND
:
19548 rule_buf
[rule_pos
] = rule_cmd
;
19552 case RULE_OP_MANGLE_PREPEND
:
19553 rule_buf
[rule_pos
] = rule_cmd
;
19557 case RULE_OP_MANGLE_DELETE_FIRST
:
19558 rule_buf
[rule_pos
] = rule_cmd
;
19561 case RULE_OP_MANGLE_DELETE_LAST
:
19562 rule_buf
[rule_pos
] = rule_cmd
;
19565 case RULE_OP_MANGLE_DELETE_AT
:
19566 rule_buf
[rule_pos
] = rule_cmd
;
19567 GET_P0_CONV (rule
);
19570 case RULE_OP_MANGLE_EXTRACT
:
19571 rule_buf
[rule_pos
] = rule_cmd
;
19572 GET_P0_CONV (rule
);
19573 GET_P1_CONV (rule
);
19576 case RULE_OP_MANGLE_OMIT
:
19577 rule_buf
[rule_pos
] = rule_cmd
;
19578 GET_P0_CONV (rule
);
19579 GET_P1_CONV (rule
);
19582 case RULE_OP_MANGLE_INSERT
:
19583 rule_buf
[rule_pos
] = rule_cmd
;
19584 GET_P0_CONV (rule
);
19588 case RULE_OP_MANGLE_OVERSTRIKE
:
19589 rule_buf
[rule_pos
] = rule_cmd
;
19590 GET_P0_CONV (rule
);
19594 case RULE_OP_MANGLE_TRUNCATE_AT
:
19595 rule_buf
[rule_pos
] = rule_cmd
;
19596 GET_P0_CONV (rule
);
19599 case RULE_OP_MANGLE_REPLACE
:
19600 rule_buf
[rule_pos
] = rule_cmd
;
19605 case RULE_OP_MANGLE_PURGECHAR
:
19609 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19613 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19614 rule_buf
[rule_pos
] = rule_cmd
;
19615 GET_P0_CONV (rule
);
19618 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19619 rule_buf
[rule_pos
] = rule_cmd
;
19620 GET_P0_CONV (rule
);
19623 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19624 rule_buf
[rule_pos
] = rule_cmd
;
19627 case RULE_OP_MANGLE_SWITCH_FIRST
:
19628 rule_buf
[rule_pos
] = rule_cmd
;
19631 case RULE_OP_MANGLE_SWITCH_LAST
:
19632 rule_buf
[rule_pos
] = rule_cmd
;
19635 case RULE_OP_MANGLE_SWITCH_AT
:
19636 rule_buf
[rule_pos
] = rule_cmd
;
19637 GET_P0_CONV (rule
);
19638 GET_P1_CONV (rule
);
19641 case RULE_OP_MANGLE_CHR_SHIFTL
:
19642 rule_buf
[rule_pos
] = rule_cmd
;
19643 GET_P0_CONV (rule
);
19646 case RULE_OP_MANGLE_CHR_SHIFTR
:
19647 rule_buf
[rule_pos
] = rule_cmd
;
19648 GET_P0_CONV (rule
);
19651 case RULE_OP_MANGLE_CHR_INCR
:
19652 rule_buf
[rule_pos
] = rule_cmd
;
19653 GET_P0_CONV (rule
);
19656 case RULE_OP_MANGLE_CHR_DECR
:
19657 rule_buf
[rule_pos
] = rule_cmd
;
19658 GET_P0_CONV (rule
);
19661 case RULE_OP_MANGLE_REPLACE_NP1
:
19662 rule_buf
[rule_pos
] = rule_cmd
;
19663 GET_P0_CONV (rule
);
19666 case RULE_OP_MANGLE_REPLACE_NM1
:
19667 rule_buf
[rule_pos
] = rule_cmd
;
19668 GET_P0_CONV (rule
);
19671 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19672 rule_buf
[rule_pos
] = rule_cmd
;
19673 GET_P0_CONV (rule
);
19676 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19677 rule_buf
[rule_pos
] = rule_cmd
;
19678 GET_P0_CONV (rule
);
19681 case RULE_OP_MANGLE_TITLE
:
19682 rule_buf
[rule_pos
] = rule_cmd
;
19686 return rule_pos
- 1;
19704 * CPU rules : this is from hashcat sources, cpu based rules
19707 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19708 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19710 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19711 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19712 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19714 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19715 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19716 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19718 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19722 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19727 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19731 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19736 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19740 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19745 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19750 for (l
= 0; l
< arr_len
; l
++)
19752 r
= arr_len
- 1 - l
;
19756 MANGLE_SWITCH (arr
, l
, r
);
19762 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19764 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19766 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19768 return (arr_len
* 2);
19771 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19773 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19775 int orig_len
= arr_len
;
19779 for (i
= 0; i
< times
; i
++)
19781 memcpy (&arr
[arr_len
], arr
, orig_len
);
19783 arr_len
+= orig_len
;
19789 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19791 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19793 mangle_double (arr
, arr_len
);
19795 mangle_reverse (arr
+ arr_len
, arr_len
);
19797 return (arr_len
* 2);
19800 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19805 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19807 MANGLE_SWITCH (arr
, l
, r
);
19813 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19818 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19820 MANGLE_SWITCH (arr
, l
, r
);
19826 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19828 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19832 return (arr_len
+ 1);
19835 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19837 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19841 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19843 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19848 return (arr_len
+ 1);
19851 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19853 if (upos
>= arr_len
) return (arr_len
);
19857 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19859 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19862 return (arr_len
- 1);
19865 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19867 if (upos
>= arr_len
) return (arr_len
);
19869 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19873 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19875 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19881 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19883 if (upos
>= arr_len
) return (arr_len
);
19885 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19889 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19891 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19894 return (arr_len
- ulen
);
19897 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19899 if (upos
>= arr_len
) return (arr_len
);
19901 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19905 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19907 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19912 return (arr_len
+ 1);
19915 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
)
19917 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19919 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19921 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19923 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19925 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19927 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19929 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19931 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19933 return (arr_len
+ arr2_cpy
);
19936 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19938 if (upos
>= arr_len
) return (arr_len
);
19945 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19947 if (upos
>= arr_len
) return (arr_len
);
19949 memset (arr
+ upos
, 0, arr_len
- upos
);
19954 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19958 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19960 if (arr
[arr_pos
] != oldc
) continue;
19962 arr
[arr_pos
] = newc
;
19968 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19974 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19976 if (arr
[arr_pos
] == c
) continue;
19978 arr
[ret_len
] = arr
[arr_pos
];
19986 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19988 if (ulen
> arr_len
) return (arr_len
);
19990 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19992 char cs
[100] = { 0 };
19994 memcpy (cs
, arr
, ulen
);
19998 for (i
= 0; i
< ulen
; i
++)
20002 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20008 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20010 if (ulen
> arr_len
) return (arr_len
);
20012 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20014 int upos
= arr_len
- ulen
;
20018 for (i
= 0; i
< ulen
; i
++)
20020 char c
= arr
[upos
+ i
];
20022 arr_len
= mangle_append (arr
, arr_len
, c
);
20028 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20030 if ( arr_len
== 0) return (arr_len
);
20031 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20033 char c
= arr
[upos
];
20037 for (i
= 0; i
< ulen
; i
++)
20039 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20045 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20047 if ( arr_len
== 0) return (arr_len
);
20048 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20052 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20054 int new_pos
= arr_pos
* 2;
20056 arr
[new_pos
] = arr
[arr_pos
];
20058 arr
[new_pos
+ 1] = arr
[arr_pos
];
20061 return (arr_len
* 2);
20064 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20066 if (upos
>= arr_len
) return (arr_len
);
20067 if (upos2
>= arr_len
) return (arr_len
);
20069 MANGLE_SWITCH (arr
, upos
, upos2
);
20074 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20076 MANGLE_SWITCH (arr
, upos
, upos2
);
20081 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20083 if (upos
>= arr_len
) return (arr_len
);
20090 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20092 if (upos
>= arr_len
) return (arr_len
);
20099 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20101 if (upos
>= arr_len
) return (arr_len
);
20108 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20110 if (upos
>= arr_len
) return (arr_len
);
20117 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20119 int upper_next
= 1;
20123 for (pos
= 0; pos
< arr_len
; pos
++)
20125 if (arr
[pos
] == ' ')
20136 MANGLE_UPPER_AT (arr
, pos
);
20140 MANGLE_LOWER_AT (arr
, pos
);
20147 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20149 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20155 for (j
= 0; j
< rp_gen_num
; j
++)
20162 switch ((char) get_random_num (0, 9))
20165 r
= get_random_num (0, sizeof (grp_op_nop
));
20166 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20170 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20171 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20172 p1
= get_random_num (0, sizeof (grp_pos
));
20173 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20177 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20178 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20179 p1
= get_random_num (1, 6);
20180 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20184 r
= get_random_num (0, sizeof (grp_op_chr
));
20185 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20186 p1
= get_random_num (0x20, 0x7e);
20187 rule_buf
[rule_pos
++] = (char) p1
;
20191 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20192 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20193 p1
= get_random_num (0x20, 0x7e);
20194 rule_buf
[rule_pos
++] = (char) p1
;
20195 p2
= get_random_num (0x20, 0x7e);
20197 p2
= get_random_num (0x20, 0x7e);
20198 rule_buf
[rule_pos
++] = (char) p2
;
20202 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20203 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20204 p1
= get_random_num (0, sizeof (grp_pos
));
20205 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20206 p2
= get_random_num (0x20, 0x7e);
20207 rule_buf
[rule_pos
++] = (char) p2
;
20211 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20212 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20213 p1
= get_random_num (0, sizeof (grp_pos
));
20214 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20215 p2
= get_random_num (0, sizeof (grp_pos
));
20217 p2
= get_random_num (0, sizeof (grp_pos
));
20218 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20222 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20223 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20224 p1
= get_random_num (0, sizeof (grp_pos
));
20225 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20226 p2
= get_random_num (1, sizeof (grp_pos
));
20228 p2
= get_random_num (1, sizeof (grp_pos
));
20229 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20233 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20234 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20235 p1
= get_random_num (0, sizeof (grp_pos
));
20236 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20237 p2
= get_random_num (1, sizeof (grp_pos
));
20238 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20239 p3
= get_random_num (0, sizeof (grp_pos
));
20240 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20248 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20250 char mem
[BLOCK_SIZE
] = { 0 };
20252 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20254 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20256 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20258 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20260 int out_len
= in_len
;
20261 int mem_len
= in_len
;
20263 memcpy (out
, in
, out_len
);
20267 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20272 switch (rule
[rule_pos
])
20277 case RULE_OP_MANGLE_NOOP
:
20280 case RULE_OP_MANGLE_LREST
:
20281 out_len
= mangle_lrest (out
, out_len
);
20284 case RULE_OP_MANGLE_UREST
:
20285 out_len
= mangle_urest (out
, out_len
);
20288 case RULE_OP_MANGLE_LREST_UFIRST
:
20289 out_len
= mangle_lrest (out
, out_len
);
20290 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20293 case RULE_OP_MANGLE_UREST_LFIRST
:
20294 out_len
= mangle_urest (out
, out_len
);
20295 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20298 case RULE_OP_MANGLE_TREST
:
20299 out_len
= mangle_trest (out
, out_len
);
20302 case RULE_OP_MANGLE_TOGGLE_AT
:
20303 NEXT_RULEPOS (rule_pos
);
20304 NEXT_RPTOI (rule
, rule_pos
, upos
);
20305 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20308 case RULE_OP_MANGLE_REVERSE
:
20309 out_len
= mangle_reverse (out
, out_len
);
20312 case RULE_OP_MANGLE_DUPEWORD
:
20313 out_len
= mangle_double (out
, out_len
);
20316 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20317 NEXT_RULEPOS (rule_pos
);
20318 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20319 out_len
= mangle_double_times (out
, out_len
, ulen
);
20322 case RULE_OP_MANGLE_REFLECT
:
20323 out_len
= mangle_reflect (out
, out_len
);
20326 case RULE_OP_MANGLE_ROTATE_LEFT
:
20327 mangle_rotate_left (out
, out_len
);
20330 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20331 mangle_rotate_right (out
, out_len
);
20334 case RULE_OP_MANGLE_APPEND
:
20335 NEXT_RULEPOS (rule_pos
);
20336 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20339 case RULE_OP_MANGLE_PREPEND
:
20340 NEXT_RULEPOS (rule_pos
);
20341 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20344 case RULE_OP_MANGLE_DELETE_FIRST
:
20345 out_len
= mangle_delete_at (out
, out_len
, 0);
20348 case RULE_OP_MANGLE_DELETE_LAST
:
20349 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20352 case RULE_OP_MANGLE_DELETE_AT
:
20353 NEXT_RULEPOS (rule_pos
);
20354 NEXT_RPTOI (rule
, rule_pos
, upos
);
20355 out_len
= mangle_delete_at (out
, out_len
, upos
);
20358 case RULE_OP_MANGLE_EXTRACT
:
20359 NEXT_RULEPOS (rule_pos
);
20360 NEXT_RPTOI (rule
, rule_pos
, upos
);
20361 NEXT_RULEPOS (rule_pos
);
20362 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20363 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20366 case RULE_OP_MANGLE_OMIT
:
20367 NEXT_RULEPOS (rule_pos
);
20368 NEXT_RPTOI (rule
, rule_pos
, upos
);
20369 NEXT_RULEPOS (rule_pos
);
20370 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20371 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20374 case RULE_OP_MANGLE_INSERT
:
20375 NEXT_RULEPOS (rule_pos
);
20376 NEXT_RPTOI (rule
, rule_pos
, upos
);
20377 NEXT_RULEPOS (rule_pos
);
20378 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20381 case RULE_OP_MANGLE_OVERSTRIKE
:
20382 NEXT_RULEPOS (rule_pos
);
20383 NEXT_RPTOI (rule
, rule_pos
, upos
);
20384 NEXT_RULEPOS (rule_pos
);
20385 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20388 case RULE_OP_MANGLE_TRUNCATE_AT
:
20389 NEXT_RULEPOS (rule_pos
);
20390 NEXT_RPTOI (rule
, rule_pos
, upos
);
20391 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20394 case RULE_OP_MANGLE_REPLACE
:
20395 NEXT_RULEPOS (rule_pos
);
20396 NEXT_RULEPOS (rule_pos
);
20397 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20400 case RULE_OP_MANGLE_PURGECHAR
:
20401 NEXT_RULEPOS (rule_pos
);
20402 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20405 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20409 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20410 NEXT_RULEPOS (rule_pos
);
20411 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20412 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20415 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20416 NEXT_RULEPOS (rule_pos
);
20417 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20418 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20421 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20422 out_len
= mangle_dupechar (out
, out_len
);
20425 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20426 NEXT_RULEPOS (rule_pos
);
20427 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20428 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20431 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20432 NEXT_RULEPOS (rule_pos
);
20433 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20434 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20437 case RULE_OP_MANGLE_SWITCH_FIRST
:
20438 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20441 case RULE_OP_MANGLE_SWITCH_LAST
:
20442 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20445 case RULE_OP_MANGLE_SWITCH_AT
:
20446 NEXT_RULEPOS (rule_pos
);
20447 NEXT_RPTOI (rule
, rule_pos
, upos
);
20448 NEXT_RULEPOS (rule_pos
);
20449 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20450 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20453 case RULE_OP_MANGLE_CHR_SHIFTL
:
20454 NEXT_RULEPOS (rule_pos
);
20455 NEXT_RPTOI (rule
, rule_pos
, upos
);
20456 mangle_chr_shiftl (out
, out_len
, upos
);
20459 case RULE_OP_MANGLE_CHR_SHIFTR
:
20460 NEXT_RULEPOS (rule_pos
);
20461 NEXT_RPTOI (rule
, rule_pos
, upos
);
20462 mangle_chr_shiftr (out
, out_len
, upos
);
20465 case RULE_OP_MANGLE_CHR_INCR
:
20466 NEXT_RULEPOS (rule_pos
);
20467 NEXT_RPTOI (rule
, rule_pos
, upos
);
20468 mangle_chr_incr (out
, out_len
, upos
);
20471 case RULE_OP_MANGLE_CHR_DECR
:
20472 NEXT_RULEPOS (rule_pos
);
20473 NEXT_RPTOI (rule
, rule_pos
, upos
);
20474 mangle_chr_decr (out
, out_len
, upos
);
20477 case RULE_OP_MANGLE_REPLACE_NP1
:
20478 NEXT_RULEPOS (rule_pos
);
20479 NEXT_RPTOI (rule
, rule_pos
, upos
);
20480 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20483 case RULE_OP_MANGLE_REPLACE_NM1
:
20484 NEXT_RULEPOS (rule_pos
);
20485 NEXT_RPTOI (rule
, rule_pos
, upos
);
20486 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20489 case RULE_OP_MANGLE_TITLE
:
20490 out_len
= mangle_title (out
, out_len
);
20493 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20494 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20495 NEXT_RULEPOS (rule_pos
);
20496 NEXT_RPTOI (rule
, rule_pos
, upos
);
20497 NEXT_RULEPOS (rule_pos
);
20498 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20499 NEXT_RULEPOS (rule_pos
);
20500 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20501 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20504 case RULE_OP_MANGLE_APPEND_MEMORY
:
20505 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20506 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20507 memcpy (out
+ out_len
, mem
, mem_len
);
20508 out_len
+= mem_len
;
20511 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20512 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20513 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20514 memcpy (mem
+ mem_len
, out
, out_len
);
20515 out_len
+= mem_len
;
20516 memcpy (out
, mem
, out_len
);
20519 case RULE_OP_MEMORIZE_WORD
:
20520 memcpy (mem
, out
, out_len
);
20524 case RULE_OP_REJECT_LESS
:
20525 NEXT_RULEPOS (rule_pos
);
20526 NEXT_RPTOI (rule
, rule_pos
, upos
);
20527 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20530 case RULE_OP_REJECT_GREATER
:
20531 NEXT_RULEPOS (rule_pos
);
20532 NEXT_RPTOI (rule
, rule_pos
, upos
);
20533 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20536 case RULE_OP_REJECT_CONTAIN
:
20537 NEXT_RULEPOS (rule_pos
);
20538 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20541 case RULE_OP_REJECT_NOT_CONTAIN
:
20542 NEXT_RULEPOS (rule_pos
);
20543 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20546 case RULE_OP_REJECT_EQUAL_FIRST
:
20547 NEXT_RULEPOS (rule_pos
);
20548 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20551 case RULE_OP_REJECT_EQUAL_LAST
:
20552 NEXT_RULEPOS (rule_pos
);
20553 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20556 case RULE_OP_REJECT_EQUAL_AT
:
20557 NEXT_RULEPOS (rule_pos
);
20558 NEXT_RPTOI (rule
, rule_pos
, upos
);
20559 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20560 NEXT_RULEPOS (rule_pos
);
20561 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20564 case RULE_OP_REJECT_CONTAINS
:
20565 NEXT_RULEPOS (rule_pos
);
20566 NEXT_RPTOI (rule
, rule_pos
, upos
);
20567 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20568 NEXT_RULEPOS (rule_pos
);
20569 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20570 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20573 case RULE_OP_REJECT_MEMORY
:
20574 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20578 return (RULE_RC_SYNTAX_ERROR
);
20583 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);