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
);
2658 #endif /* F_SETLKW */
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 (hc_NvAPI_EnumPhysicalGPUs (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 (hc_NVML_nvmlDeviceGetHandleByIndex (data
.hm_dll_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 // hc_NVML_nvmlDeviceGetName (data.hm_dll_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2710 log_info ("WARN: No NVML adapters found");
2717 #endif // LINUX && HAVE_NVML
2719 #if defined(HAVE_ADL) || defined(HAVE_NVML)
2720 void hm_close (HM_LIB hm_dll
)
2726 FreeLibrary (hm_dll
);
2731 HM_LIB
hm_init (const cl_uint vendor_id
)
2733 HM_LIB hm_dll
= NULL
;
2736 if (vendor_id
== VENDOR_ID_AMD
)
2739 hm_dll
= dlopen ("libatiadlxx.so", RTLD_LAZY
| RTLD_GLOBAL
);
2742 hm_dll
= LoadLibrary ("atiadlxx.dll");
2746 hm_dll
= LoadLibrary ("atiadlxy.dll");
2753 #if defined(LINUX) && defined(HAVE_NVML)
2754 if (vendor_id
== VENDOR_ID_NV
)
2756 hm_dll
= dlopen ("libnvidia-ml.so", RTLD_LAZY
| RTLD_GLOBAL
);
2762 #endif // HAVE_ADL || HAVE_NVML
2765 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2767 if (hc_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2769 if (iNumberAdapters
== 0)
2771 log_info ("WARN: No ADL adapters found.");
2780 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2782 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2783 ADLODParameters lpOdParameters;
2785 lpOdParameters.iSize = sizeof (ADLODParameters);
2786 size_t plevels_size = 0;
2788 if (hc_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2790 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2791 __func__, iAdapterIndex,
2792 lpOdParameters.iNumberOfPerformanceLevels,
2793 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2794 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2796 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2798 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2800 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2802 if (hc_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2804 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2805 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2806 __func__, iAdapterIndex, j,
2807 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2809 myfree (lpOdPerformanceLevels);
2815 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2817 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2819 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2821 if (hc_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2823 return lpAdapterInfo
;
2828 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2831 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2835 for (uint i = 0; i < num_adl_adapters; i++)
2837 int opencl_bus_num = hm_device[i].busid;
2838 int opencl_dev_num = hm_device[i].devid;
2840 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2848 if (idx >= DEVICES_MAX) return -1;
2853 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2855 for (uint i = 0; i < opencl_num_devices; i++)
2857 cl_device_topology_amd device_topology;
2859 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2861 hm_device[i].busid = device_topology.pcie.bus;
2862 hm_device[i].devid = device_topology.pcie.device;
2867 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2869 // basically bubble sort
2871 for (int i
= 0; i
< num_adl_adapters
; i
++)
2873 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2875 // get info of adapter [x]
2877 u32 adapter_index_x
= valid_adl_device_list
[j
];
2878 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2880 u32 bus_num_x
= info_x
.iBusNumber
;
2881 u32 dev_num_x
= info_x
.iDeviceNumber
;
2883 // get info of adapter [y]
2885 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2886 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2888 u32 bus_num_y
= info_y
.iBusNumber
;
2889 u32 dev_num_y
= info_y
.iDeviceNumber
;
2893 if (bus_num_y
< bus_num_x
)
2897 else if (bus_num_y
== bus_num_x
)
2899 if (dev_num_y
< dev_num_x
)
2907 u32 temp
= valid_adl_device_list
[j
+ 1];
2909 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2910 valid_adl_device_list
[j
+ 0] = temp
;
2916 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2918 *num_adl_adapters
= 0;
2920 u32
*adl_adapters
= NULL
;
2922 int *bus_numbers
= NULL
;
2923 int *device_numbers
= NULL
;
2925 for (int i
= 0; i
< iNumberAdapters
; i
++)
2927 AdapterInfo info
= lpAdapterInfo
[i
];
2929 if (strlen (info
.strUDID
) < 1) continue;
2932 if (info
.iVendorID
!= 1002) continue;
2934 if (info
.iVendorID
!= 0x1002) continue;
2937 if (info
.iBusNumber
< 0) continue;
2938 if (info
.iDeviceNumber
< 0) continue;
2942 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2944 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2951 if (found
) continue;
2953 // add it to the list
2955 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2957 adl_adapters
[*num_adl_adapters
] = i
;
2959 // rest is just bookkeeping
2961 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2962 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2964 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2965 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2967 (*num_adl_adapters
)++;
2970 myfree (bus_numbers
);
2971 myfree (device_numbers
);
2973 // sort the list by increasing bus id, device id number
2975 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2977 return adl_adapters
;
2980 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2982 // loop through all valid devices
2984 for (int i
= 0; i
< num_adl_adapters
; i
++)
2986 u32 adapter_index
= valid_adl_device_list
[i
];
2990 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2992 // unfortunately this doesn't work since bus id and dev id are not unique
2993 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2994 // if (opencl_device_index == -1) continue;
2996 int opencl_device_index
= i
;
2998 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
3000 // get fanspeed info
3002 if (hm_device
[opencl_device_index
].od_version
== 5)
3004 ADLFanSpeedInfo FanSpeedInfo
;
3006 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
3008 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
3010 if (hc_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
3012 // check read and write capability in fanspeedinfo
3014 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
3015 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
3017 hm_device
[opencl_device_index
].fan_supported
= 1;
3021 hm_device
[opencl_device_index
].fan_supported
= 0;
3024 else // od_version == 6
3026 ADLOD6FanSpeedInfo faninfo
;
3028 memset (&faninfo
, 0, sizeof (faninfo
));
3030 if (hc_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
3032 // check read capability in fanspeedinfo
3034 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
3036 hm_device
[opencl_device_index
].fan_supported
= 1;
3040 hm_device
[opencl_device_index
].fan_supported
= 0;
3048 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3050 for (int i
= 0; i
< num_adl_adapters
; i
++)
3052 u32 adapter_index
= valid_adl_device_list
[i
];
3056 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3058 // get overdrive version
3060 int od_supported
= 0;
3064 if (hc_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3066 // store the overdrive version in hm_device
3068 // unfortunately this doesn't work since bus id and dev id are not unique
3069 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3070 // if (opencl_device_index == -1) continue;
3072 int opencl_device_index
= i
;
3074 hm_device
[opencl_device_index
].od_version
= od_version
;
3080 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3082 for (int i
= 0; i
< num_adl_adapters
; i
++)
3084 u32 adapter_index
= valid_adl_device_list
[i
];
3088 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3090 // store the iAdapterIndex in hm_device
3092 // unfortunately this doesn't work since bus id and dev id are not unique
3093 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3094 // if (opencl_device_index == -1) continue;
3096 int opencl_device_index
= i
;
3098 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3101 return num_adl_adapters
;
3105 int hm_get_temperature_with_device_id (const uint device_id
)
3107 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3110 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3114 if (data
.hm_device
[device_id
].od_version
== 5)
3116 ADLTemperature Temperature
;
3118 Temperature
.iSize
= sizeof (ADLTemperature
);
3120 if (hc_ADL_Overdrive5_Temperature_Get (data
.adl
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3122 return Temperature
.iTemperature
/ 1000;
3124 else if (data
.hm_device
[device_id
].od_version
== 6)
3126 int Temperature
= 0;
3128 if (hc_ADL_Overdrive6_Temperature_Get (data
.adl
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3130 return Temperature
/ 1000;
3136 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3137 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3139 #if defined(LINUX) && defined(HAVE_NVML)
3140 int temperature
= 0;
3142 hc_NVML_nvmlDeviceGetTemperature (data
.hm_dll_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3147 #if defined(WIN) && defined(HAVE_NVAPI)
3148 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3150 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3151 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3152 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3153 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3155 if (hc_NvAPI_GPU_GetThermalSettings (data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3157 return pThermalSettings
.sensor
[0].currentTemp
;
3158 #endif // WIN && HAVE_NVAPI
3160 #endif // HAVE_NVML || HAVE_NVAPI
3165 int hm_get_fanspeed_with_device_id (const uint device_id
)
3167 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3168 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3170 if (data
.hm_device
[device_id
].fan_supported
== 1)
3173 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3177 if (data
.hm_device
[device_id
].od_version
== 5)
3179 ADLFanSpeedValue lpFanSpeedValue
;
3181 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3183 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3184 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3185 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3187 if (hc_ADL_Overdrive5_FanSpeed_Get (data
.adl
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3189 return lpFanSpeedValue
.iFanSpeed
;
3191 else // od_version == 6
3193 ADLOD6FanSpeedInfo faninfo
;
3195 memset (&faninfo
, 0, sizeof (faninfo
));
3197 if (hc_ADL_Overdrive6_FanSpeed_Get (data
.adl
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3199 return faninfo
.iFanSpeedPercent
;
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)
3211 hc_NVML_nvmlDeviceGetFanSpeed (data
.hm_dll_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3216 #if defined(WIN) && defined(HAVE_NVAPI)
3219 hc_NvAPI_GPU_GetTachReading (data
.hm_device
[device_id
].adapter_index
.nv
, &speed
);
3224 #endif // HAVE_NVML || HAVE_NVAPI
3230 int hm_get_utilization_with_device_id (const uint device_id
)
3232 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3235 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3239 ADLPMActivity PMActivity
;
3241 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3243 if (hc_ADL_Overdrive_CurrentActivity_Get (data
.adl
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3245 return PMActivity
.iActivityPercent
;
3250 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3251 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3253 #if defined(LINUX) && defined(HAVE_NVML)
3254 nvmlUtilization_t utilization
;
3256 hc_NVML_nvmlDeviceGetUtilizationRates (data
.hm_dll_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3258 return utilization
.gpu
;
3261 #if defined(WIN) && defined(HAVE_NVAPI)
3262 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3264 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3266 if (hc_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3268 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3271 #endif // HAVE_NVML || HAVE_NVAPI
3277 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3279 if (data
.hm_device
[device_id
].fan_supported
== 1)
3283 if (data
.hm_device
[device_id
].od_version
== 5)
3285 ADLFanSpeedValue lpFanSpeedValue
;
3287 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3289 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3290 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3291 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3292 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3294 if (hc_ADL_Overdrive5_FanSpeed_Set (data
.adl
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3298 else // od_version == 6
3300 ADLOD6FanSpeedValue fan_speed_value
;
3302 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3304 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3305 fan_speed_value
.iFanSpeed
= fanspeed
;
3307 if (hc_ADL_Overdrive6_FanSpeed_Set (data
.adl
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3318 // helper function for status display
3320 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3322 #define VALUE_NOT_AVAILABLE "N/A"
3326 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3330 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3333 #endif // HAVE_HWMON
3339 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3341 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3343 if (css_cnt
> SP_PW_MAX
)
3345 log_error ("ERROR: mask length is too long");
3350 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3352 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3354 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3355 uint cs_len
= css
[css_pos
].cs_len
;
3357 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3359 uint c
= cs_buf
[cs_pos
] & 0xff;
3366 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3368 cs_t
*cs
= &css
[css_cnt
];
3370 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3372 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3376 for (i
= 0; i
< cs
->cs_len
; i
++)
3378 const uint u
= cs
->cs_buf
[i
];
3383 for (i
= 0; i
< in_len
; i
++)
3385 uint u
= in_buf
[i
] & 0xff;
3387 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3389 if (css_uniq
[u
] == 1) continue;
3393 cs
->cs_buf
[cs
->cs_len
] = u
;
3401 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3405 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3407 uint p0
= in_buf
[in_pos
] & 0xff;
3409 if (interpret
== 1 && p0
== '?')
3413 if (in_pos
== in_len
) break;
3415 uint p1
= in_buf
[in_pos
] & 0xff;
3419 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3421 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3423 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3425 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3427 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3429 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3431 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3432 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3434 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3435 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3437 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3438 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3440 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3441 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3443 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3445 default: log_error ("Syntax error: %s", in_buf
);
3451 if (data
.hex_charset
)
3455 if (in_pos
== in_len
)
3457 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3462 uint p1
= in_buf
[in_pos
] & 0xff;
3464 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3466 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3473 chr
= hex_convert (p1
) << 0;
3474 chr
|= hex_convert (p0
) << 4;
3476 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3482 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3488 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3492 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3494 sum
*= css
[css_pos
].cs_len
;
3500 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3502 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3507 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3509 char p0
= mask_buf
[mask_pos
];
3515 if (mask_pos
== mask_len
) break;
3517 char p1
= mask_buf
[mask_pos
];
3523 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3525 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3527 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3529 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3531 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3533 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3535 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3536 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3538 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3539 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3541 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3542 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3544 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3545 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3547 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3549 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3555 if (data
.hex_charset
)
3559 // if there is no 2nd hex character, show an error:
3561 if (mask_pos
== mask_len
)
3563 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3568 char p1
= mask_buf
[mask_pos
];
3570 // if they are not valid hex character, show an error:
3572 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3574 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3581 chr
|= hex_convert (p1
) << 0;
3582 chr
|= hex_convert (p0
) << 4;
3584 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3590 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3597 log_error ("ERROR: invalid mask length (0)");
3607 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3609 for (int i
= 0; i
< css_cnt
; i
++)
3611 uint len
= css
[i
].cs_len
;
3612 u64 next
= val
/ len
;
3613 uint pos
= val
% len
;
3614 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3619 void mp_cut_at (char *mask
, uint max
)
3623 uint mask_len
= strlen (mask
);
3625 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3627 if (mask
[i
] == '?') i
++;
3633 void mp_setup_sys (cs_t
*mp_sys
)
3637 uint donec
[CHARSIZ
] = { 0 };
3639 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3640 mp_sys
[0].cs_buf
[pos
++] = chr
;
3641 mp_sys
[0].cs_len
= pos
; }
3643 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3644 mp_sys
[1].cs_buf
[pos
++] = chr
;
3645 mp_sys
[1].cs_len
= pos
; }
3647 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3648 mp_sys
[2].cs_buf
[pos
++] = chr
;
3649 mp_sys
[2].cs_len
= pos
; }
3651 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3652 mp_sys
[3].cs_buf
[pos
++] = chr
;
3653 mp_sys
[3].cs_len
= pos
; }
3655 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3656 mp_sys
[4].cs_len
= pos
; }
3658 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3659 mp_sys
[5].cs_len
= pos
; }
3662 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3664 FILE *fp
= fopen (buf
, "rb");
3666 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3668 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3672 char mp_file
[1024] = { 0 };
3674 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3678 len
= in_superchop (mp_file
);
3682 log_info ("WARNING: charset file corrupted");
3684 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3688 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3693 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3695 mp_usr
[index
].cs_len
= 0;
3697 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3700 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3702 char *new_mask_buf
= (char *) mymalloc (256);
3708 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3710 if (css_pos
== len
) break;
3712 char p0
= mask_buf
[mask_pos
];
3714 new_mask_buf
[mask_pos
] = p0
;
3720 if (mask_pos
== mask_len
) break;
3722 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3726 if (data
.hex_charset
)
3730 if (mask_pos
== mask_len
)
3732 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3737 char p1
= mask_buf
[mask_pos
];
3739 // if they are not valid hex character, show an error:
3741 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3743 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3748 new_mask_buf
[mask_pos
] = p1
;
3753 if (css_pos
== len
) return (new_mask_buf
);
3755 myfree (new_mask_buf
);
3764 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3770 for (i
= start
; i
< stop
; i
++)
3772 sum
*= root_css_buf
[i
].cs_len
;
3778 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3782 cs_t
*cs
= &root_css_buf
[start
];
3786 for (i
= start
; i
< stop
; i
++)
3788 const u64 m
= v
% cs
->cs_len
;
3789 const u64 d
= v
/ cs
->cs_len
;
3793 const uint k
= cs
->cs_buf
[m
];
3795 pw_buf
[i
- start
] = (char) k
;
3797 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3801 int sp_comp_val (const void *p1
, const void *p2
)
3803 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3804 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3806 return b2
->val
- b1
->val
;
3809 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
)
3816 * Initialize hcstats
3819 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3821 u64
*root_stats_ptr
= root_stats_buf
;
3823 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3825 for (i
= 0; i
< SP_PW_MAX
; i
++)
3827 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3829 root_stats_ptr
+= CHARSIZ
;
3832 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3834 u64
*markov_stats_ptr
= markov_stats_buf
;
3836 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3838 for (i
= 0; i
< SP_PW_MAX
; i
++)
3840 for (j
= 0; j
< CHARSIZ
; j
++)
3842 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3844 markov_stats_ptr
+= CHARSIZ
;
3854 char hcstat_tmp
[256] = { 0 };
3856 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3858 hcstat
= hcstat_tmp
;
3861 FILE *fd
= fopen (hcstat
, "rb");
3865 log_error ("%s: %s", hcstat
, strerror (errno
));
3870 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3872 log_error ("%s: Could not load data", hcstat
);
3879 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3881 log_error ("%s: Could not load data", hcstat
);
3891 * Markov modifier of hcstat_table on user request
3896 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3897 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3902 /* Add all stats to first position */
3904 for (i
= 1; i
< SP_PW_MAX
; i
++)
3906 u64
*out
= root_stats_buf_by_pos
[0];
3907 u64
*in
= root_stats_buf_by_pos
[i
];
3909 for (j
= 0; j
< CHARSIZ
; j
++)
3915 for (i
= 1; i
< SP_PW_MAX
; i
++)
3917 u64
*out
= markov_stats_buf_by_key
[0][0];
3918 u64
*in
= markov_stats_buf_by_key
[i
][0];
3920 for (j
= 0; j
< CHARSIZ
; j
++)
3922 for (k
= 0; k
< CHARSIZ
; k
++)
3929 /* copy them to all pw_positions */
3931 for (i
= 1; i
< SP_PW_MAX
; i
++)
3933 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3936 for (i
= 1; i
< SP_PW_MAX
; i
++)
3938 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3946 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3948 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3950 for (i
= 0; i
< SP_PW_MAX
; i
++)
3952 root_table_buf_by_pos
[i
] = root_table_ptr
;
3954 root_table_ptr
+= CHARSIZ
;
3957 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3959 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3961 for (i
= 0; i
< SP_PW_MAX
; i
++)
3963 for (j
= 0; j
< CHARSIZ
; j
++)
3965 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3967 markov_table_ptr
+= CHARSIZ
;
3972 * Convert hcstat to tables
3975 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3977 uint key
= i
% CHARSIZ
;
3979 root_table_buf
[i
].key
= key
;
3980 root_table_buf
[i
].val
= root_stats_buf
[i
];
3983 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3985 uint key
= i
% CHARSIZ
;
3987 markov_table_buf
[i
].key
= key
;
3988 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3991 myfree (root_stats_buf
);
3992 myfree (markov_stats_buf
);
3998 for (i
= 0; i
< SP_PW_MAX
; i
++)
4000 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4003 for (i
= 0; i
< SP_PW_MAX
; i
++)
4005 for (j
= 0; j
< CHARSIZ
; j
++)
4007 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4012 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
])
4015 * Convert tables to css
4018 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4020 uint pw_pos
= i
/ CHARSIZ
;
4022 cs_t
*cs
= &root_css_buf
[pw_pos
];
4024 if (cs
->cs_len
== threshold
) continue;
4026 uint key
= root_table_buf
[i
].key
;
4028 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4030 cs
->cs_buf
[cs
->cs_len
] = key
;
4036 * Convert table to css
4039 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4041 uint c
= i
/ CHARSIZ
;
4043 cs_t
*cs
= &markov_css_buf
[c
];
4045 if (cs
->cs_len
== threshold
) continue;
4047 uint pw_pos
= c
/ CHARSIZ
;
4049 uint key
= markov_table_buf
[i
].key
;
4051 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4053 cs
->cs_buf
[cs
->cs_len
] = key
;
4059 for (uint i = 0; i < 8; i++)
4061 for (uint j = 0x20; j < 0x80; j++)
4063 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4065 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4067 for (uint k = 0; k < 10; k++)
4069 printf (" %u\n", ptr->cs_buf[k]);
4076 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4078 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4080 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4090 for (uint j
= 1; j
< CHARSIZ
; j
++)
4100 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4102 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4104 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4106 out
+= CHARSIZ
* CHARSIZ
;
4107 in
+= CHARSIZ
* CHARSIZ
;
4109 for (uint j
= 0; j
< CHARSIZ
; j
++)
4116 for (uint k
= 1; k
< CHARSIZ
; k
++)
4128 * mixed shared functions
4131 void dump_hex (const u8
*s
, const int sz
)
4133 for (int i
= 0; i
< sz
; i
++)
4135 log_info_nn ("%02x ", s
[i
]);
4141 void usage_mini_print (const char *progname
)
4143 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4146 void usage_big_print (const char *progname
)
4148 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4151 char *get_exec_path ()
4153 int exec_path_len
= 1024;
4155 char *exec_path
= (char *) mymalloc (exec_path_len
);
4159 char tmp
[32] = { 0 };
4161 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4163 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4167 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4171 uint size
= exec_path_len
;
4173 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4175 log_error("! executable path buffer too small\n");
4180 const int len
= strlen (exec_path
);
4183 #error Your Operating System is not supported or detected
4191 char *get_install_dir (const char *progname
)
4193 char *install_dir
= mystrdup (progname
);
4194 char *last_slash
= NULL
;
4196 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4200 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4206 install_dir
[0] = '.';
4210 return (install_dir
);
4213 char *get_profile_dir (const char *homedir
)
4215 #define DOT_HASHCAT ".hashcat"
4217 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4219 char *profile_dir
= (char *) mymalloc (len
+ 1);
4221 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4226 char *get_session_dir (const char *profile_dir
)
4228 #define SESSIONS_FOLDER "sessions"
4230 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4232 char *session_dir
= (char *) mymalloc (len
+ 1);
4234 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4239 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4243 FILE *fd
= fopen (filename
, "rb");
4247 log_error ("%s: %s", filename
, strerror (errno
));
4252 #define MAX_KEY_SIZE (1024 * 1024)
4254 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4256 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4262 for (int fpos
= 0; fpos
< nread
; fpos
++)
4264 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4266 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4267 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4268 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4269 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4271 if (kpos
>= 64) kpos
= 0;
4277 void set_cpu_affinity (char *cpu_affinity
)
4280 DWORD_PTR aff_mask
= 0;
4288 char *devices
= strdup (cpu_affinity
);
4290 char *next
= strtok (devices
, ",");
4294 uint cpu_id
= atoi (next
);
4309 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4315 aff_mask
|= 1 << (cpu_id
- 1);
4317 CPU_SET ((cpu_id
- 1), &cpuset
);
4320 } while ((next
= strtok (NULL
, ",")) != NULL
);
4326 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4327 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4329 pthread_t thread
= pthread_self ();
4330 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4334 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4336 char *element
, *end
;
4338 end
= (char *) base
+ nmemb
* size
;
4340 for (element
= (char *) base
; element
< end
; element
+= size
)
4341 if (!compar (element
, key
))
4347 int sort_by_salt (const void *v1
, const void *v2
)
4349 const salt_t
*s1
= (const salt_t
*) v1
;
4350 const salt_t
*s2
= (const salt_t
*) v2
;
4352 const int res1
= s1
->salt_len
- s2
->salt_len
;
4354 if (res1
!= 0) return (res1
);
4356 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4358 if (res2
!= 0) return (res2
);
4366 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4367 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4374 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4375 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4381 int sort_by_salt_buf (const void *v1
, const void *v2
)
4383 const pot_t
*p1
= (const pot_t
*) v1
;
4384 const pot_t
*p2
= (const pot_t
*) v2
;
4386 const hash_t
*h1
= &p1
->hash
;
4387 const hash_t
*h2
= &p2
->hash
;
4389 const salt_t
*s1
= h1
->salt
;
4390 const salt_t
*s2
= h2
->salt
;
4396 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4397 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4403 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4405 const hash_t
*h1
= (const hash_t
*) v1
;
4406 const hash_t
*h2
= (const hash_t
*) v2
;
4408 const salt_t
*s1
= h1
->salt
;
4409 const salt_t
*s2
= h2
->salt
;
4411 // testphase: this should work
4416 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4417 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4420 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4421 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4422 if (s1->salt_len > s2->salt_len) return ( 1);
4423 if (s1->salt_len < s2->salt_len) return (-1);
4425 uint n = s1->salt_len;
4429 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4430 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4437 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4439 const hash_t
*h1
= (const hash_t
*) v1
;
4440 const hash_t
*h2
= (const hash_t
*) v2
;
4442 const salt_t
*s1
= h1
->salt
;
4443 const salt_t
*s2
= h2
->salt
;
4445 // 12 - 2 (since last 2 uints contain the digest)
4450 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4451 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4457 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4459 const hash_t
*h1
= (const hash_t
*) v1
;
4460 const hash_t
*h2
= (const hash_t
*) v2
;
4462 const void *d1
= h1
->digest
;
4463 const void *d2
= h2
->digest
;
4465 return data
.sort_by_digest (d1
, d2
);
4468 int sort_by_hash (const void *v1
, const void *v2
)
4470 const hash_t
*h1
= (const hash_t
*) v1
;
4471 const hash_t
*h2
= (const hash_t
*) v2
;
4475 const salt_t
*s1
= h1
->salt
;
4476 const salt_t
*s2
= h2
->salt
;
4478 int res
= sort_by_salt (s1
, s2
);
4480 if (res
!= 0) return (res
);
4483 const void *d1
= h1
->digest
;
4484 const void *d2
= h2
->digest
;
4486 return data
.sort_by_digest (d1
, d2
);
4489 int sort_by_pot (const void *v1
, const void *v2
)
4491 const pot_t
*p1
= (const pot_t
*) v1
;
4492 const pot_t
*p2
= (const pot_t
*) v2
;
4494 const hash_t
*h1
= &p1
->hash
;
4495 const hash_t
*h2
= &p2
->hash
;
4497 return sort_by_hash (h1
, h2
);
4500 int sort_by_mtime (const void *p1
, const void *p2
)
4502 const char **f1
= (const char **) p1
;
4503 const char **f2
= (const char **) p2
;
4505 struct stat s1
; stat (*f1
, &s1
);
4506 struct stat s2
; stat (*f2
, &s2
);
4508 return s2
.st_mtime
- s1
.st_mtime
;
4511 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4513 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4514 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4516 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4519 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4521 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4522 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4524 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4527 int sort_by_stringptr (const void *p1
, const void *p2
)
4529 const char **s1
= (const char **) p1
;
4530 const char **s2
= (const char **) p2
;
4532 return strcmp (*s1
, *s2
);
4535 int sort_by_dictstat (const void *s1
, const void *s2
)
4537 dictstat_t
*d1
= (dictstat_t
*) s1
;
4538 dictstat_t
*d2
= (dictstat_t
*) s2
;
4541 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4543 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4546 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4549 int sort_by_bitmap (const void *p1
, const void *p2
)
4551 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4552 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4554 return b1
->collisions
- b2
->collisions
;
4557 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4559 const u32
*d1
= (const u32
*) v1
;
4560 const u32
*d2
= (const u32
*) v2
;
4566 if (d1
[n
] > d2
[n
]) return ( 1);
4567 if (d1
[n
] < d2
[n
]) return (-1);
4573 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4575 const u32
*d1
= (const u32
*) v1
;
4576 const u32
*d2
= (const u32
*) v2
;
4582 if (d1
[n
] > d2
[n
]) return ( 1);
4583 if (d1
[n
] < d2
[n
]) return (-1);
4589 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4591 const u32
*d1
= (const u32
*) v1
;
4592 const u32
*d2
= (const u32
*) v2
;
4598 if (d1
[n
] > d2
[n
]) return ( 1);
4599 if (d1
[n
] < d2
[n
]) return (-1);
4605 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4607 const u32
*d1
= (const u32
*) v1
;
4608 const u32
*d2
= (const u32
*) v2
;
4614 if (d1
[n
] > d2
[n
]) return ( 1);
4615 if (d1
[n
] < d2
[n
]) return (-1);
4621 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4623 const u32
*d1
= (const u32
*) v1
;
4624 const u32
*d2
= (const u32
*) v2
;
4630 if (d1
[n
] > d2
[n
]) return ( 1);
4631 if (d1
[n
] < d2
[n
]) return (-1);
4637 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4639 const u32
*d1
= (const u32
*) v1
;
4640 const u32
*d2
= (const u32
*) v2
;
4646 if (d1
[n
] > d2
[n
]) return ( 1);
4647 if (d1
[n
] < d2
[n
]) return (-1);
4653 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4655 const u32
*d1
= (const u32
*) v1
;
4656 const u32
*d2
= (const u32
*) v2
;
4662 if (d1
[n
] > d2
[n
]) return ( 1);
4663 if (d1
[n
] < d2
[n
]) return (-1);
4669 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4671 const u32
*d1
= (const u32
*) v1
;
4672 const u32
*d2
= (const u32
*) v2
;
4678 if (d1
[n
] > d2
[n
]) return ( 1);
4679 if (d1
[n
] < d2
[n
]) return (-1);
4685 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4687 const u64
*d1
= (const u64
*) v1
;
4688 const u64
*d2
= (const u64
*) v2
;
4694 if (d1
[n
] > d2
[n
]) return ( 1);
4695 if (d1
[n
] < d2
[n
]) return (-1);
4701 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4703 const u64
*d1
= (const u64
*) v1
;
4704 const u64
*d2
= (const u64
*) v2
;
4710 if (d1
[n
] > d2
[n
]) return ( 1);
4711 if (d1
[n
] < d2
[n
]) return (-1);
4717 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4719 const u64
*d1
= (const u64
*) v1
;
4720 const u64
*d2
= (const u64
*) v2
;
4726 if (d1
[n
] > d2
[n
]) return ( 1);
4727 if (d1
[n
] < d2
[n
]) return (-1);
4733 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4735 const u32
*d1
= (const u32
*) v1
;
4736 const u32
*d2
= (const u32
*) v2
;
4738 const uint dgst_pos0
= data
.dgst_pos0
;
4739 const uint dgst_pos1
= data
.dgst_pos1
;
4740 const uint dgst_pos2
= data
.dgst_pos2
;
4741 const uint dgst_pos3
= data
.dgst_pos3
;
4743 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4744 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4745 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4746 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4747 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4748 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4749 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4750 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4755 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
)
4757 uint outfile_autohex
= data
.outfile_autohex
;
4759 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4761 FILE *debug_fp
= NULL
;
4763 if (debug_file
!= NULL
)
4765 debug_fp
= fopen (debug_file
, "ab");
4767 lock_file (debug_fp
);
4774 if (debug_fp
== NULL
)
4776 log_info ("WARNING: Could not open debug-file for writing");
4780 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4782 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4784 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4787 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4789 if (debug_mode
== 4)
4791 fputc (':', debug_fp
);
4793 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4796 fputc ('\n', debug_fp
);
4798 if (debug_file
!= NULL
) fclose (debug_fp
);
4802 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4804 int needs_hexify
= 0;
4806 if (outfile_autohex
== 1)
4808 for (uint i
= 0; i
< plain_len
; i
++)
4810 if (plain_ptr
[i
] < 0x20)
4817 if (plain_ptr
[i
] > 0x7f)
4826 if (needs_hexify
== 1)
4828 fprintf (fp
, "$HEX[");
4830 for (uint i
= 0; i
< plain_len
; i
++)
4832 fprintf (fp
, "%02x", plain_ptr
[i
]);
4839 fwrite (plain_ptr
, plain_len
, 1, fp
);
4843 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
)
4845 uint outfile_format
= data
.outfile_format
;
4847 char separator
= data
.separator
;
4849 if (outfile_format
& OUTFILE_FMT_HASH
)
4851 fprintf (out_fp
, "%s", out_buf
);
4853 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4855 fputc (separator
, out_fp
);
4858 else if (data
.username
)
4860 if (username
!= NULL
)
4862 for (uint i
= 0; i
< user_len
; i
++)
4864 fprintf (out_fp
, "%c", username
[i
]);
4867 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4869 fputc (separator
, out_fp
);
4874 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4876 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4878 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4880 fputc (separator
, out_fp
);
4884 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4886 for (uint i
= 0; i
< plain_len
; i
++)
4888 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4891 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4893 fputc (separator
, out_fp
);
4897 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4900 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4905 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4907 fprintf (out_fp
, "%llu", crackpos
);
4912 fputc ('\n', out_fp
);
4915 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
)
4919 pot_key
.hash
.salt
= hashes_buf
->salt
;
4920 pot_key
.hash
.digest
= hashes_buf
->digest
;
4922 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4928 input_buf
[input_len
] = 0;
4931 unsigned char *username
= NULL
;
4936 user_t
*user
= hashes_buf
->hash_info
->user
;
4940 username
= (unsigned char *) (user
->user_name
);
4942 user_len
= user
->user_len
;
4946 // do output the line
4947 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4951 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4952 #define LM_MASKED_PLAIN "[notfound]"
4954 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
)
4960 pot_left_key
.hash
.salt
= hash_left
->salt
;
4961 pot_left_key
.hash
.digest
= hash_left
->digest
;
4963 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4967 uint weak_hash_found
= 0;
4969 pot_t pot_right_key
;
4971 pot_right_key
.hash
.salt
= hash_right
->salt
;
4972 pot_right_key
.hash
.digest
= hash_right
->digest
;
4974 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4976 if (pot_right_ptr
== NULL
)
4978 // special case, if "weak hash"
4980 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4982 weak_hash_found
= 1;
4984 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4986 // in theory this is not needed, but we are paranoia:
4988 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4989 pot_right_ptr
->plain_len
= 0;
4993 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4995 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
5000 // at least one half was found:
5004 input_buf
[input_len
] = 0;
5008 unsigned char *username
= NULL
;
5013 user_t
*user
= hash_left
->hash_info
->user
;
5017 username
= (unsigned char *) (user
->user_name
);
5019 user_len
= user
->user_len
;
5023 // mask the part which was not found
5025 uint left_part_masked
= 0;
5026 uint right_part_masked
= 0;
5028 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5030 if (pot_left_ptr
== NULL
)
5032 left_part_masked
= 1;
5034 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5036 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5038 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5039 pot_left_ptr
->plain_len
= mask_plain_len
;
5042 if (pot_right_ptr
== NULL
)
5044 right_part_masked
= 1;
5046 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5048 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5050 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5051 pot_right_ptr
->plain_len
= mask_plain_len
;
5054 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5058 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5060 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5062 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5064 // do output the line
5066 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5068 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5070 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5071 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5074 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
)
5078 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5080 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5082 if (pot_ptr
== NULL
)
5086 input_buf
[input_len
] = 0;
5088 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5092 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
)
5098 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5100 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5104 pot_t pot_right_key
;
5106 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5108 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5110 uint weak_hash_found
= 0;
5112 if (pot_right_ptr
== NULL
)
5114 // special case, if "weak hash"
5116 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5118 weak_hash_found
= 1;
5120 // we just need that pot_right_ptr is not a NULL pointer
5122 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5126 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5128 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5133 // ... at least one part was not cracked
5137 input_buf
[input_len
] = 0;
5139 // only show the hash part which is still not cracked
5141 uint user_len
= input_len
- 32;
5143 char *hash_output
= (char *) mymalloc (33);
5145 memcpy (hash_output
, input_buf
, input_len
);
5147 if (pot_left_ptr
!= NULL
)
5149 // only show right part (because left part was already found)
5151 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5153 hash_output
[user_len
+ 16] = 0;
5156 if (pot_right_ptr
!= NULL
)
5158 // only show left part (because right part was already found)
5160 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5162 hash_output
[user_len
+ 16] = 0;
5165 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5167 myfree (hash_output
);
5169 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5172 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5174 uint opencl_platforms_filter
= 0;
5176 if (opencl_platforms
)
5178 char *platforms
= strdup (opencl_platforms
);
5180 char *next
= strtok (platforms
, ",");
5184 int platform
= atoi (next
);
5186 if (platform
< 1 || platform
> 32)
5188 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5193 opencl_platforms_filter
|= 1 << (platform
- 1);
5195 } while ((next
= strtok (NULL
, ",")) != NULL
);
5201 opencl_platforms_filter
= -1;
5204 return opencl_platforms_filter
;
5207 u32
setup_devices_filter (char *opencl_devices
)
5209 u32 devices_filter
= 0;
5213 char *devices
= strdup (opencl_devices
);
5215 char *next
= strtok (devices
, ",");
5219 int device_id
= atoi (next
);
5221 if (device_id
< 1 || device_id
> 32)
5223 log_error ("ERROR: invalid device_id %u specified", device_id
);
5228 devices_filter
|= 1 << (device_id
- 1);
5230 } while ((next
= strtok (NULL
, ",")) != NULL
);
5236 devices_filter
= -1;
5239 return devices_filter
;
5242 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5244 cl_device_type device_types_filter
= 0;
5246 if (opencl_device_types
)
5248 char *device_types
= strdup (opencl_device_types
);
5250 char *next
= strtok (device_types
, ",");
5254 int device_type
= atoi (next
);
5256 if (device_type
< 1 || device_type
> 3)
5258 log_error ("ERROR: invalid device_type %u specified", device_type
);
5263 device_types_filter
|= 1 << device_type
;
5265 } while ((next
= strtok (NULL
, ",")) != NULL
);
5267 free (device_types
);
5271 // Do not use CPU by default, this often reduces GPU performance because
5272 // the CPU is too busy to handle GPU synchronization
5274 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5277 return device_types_filter
;
5280 u32
get_random_num (const u32 min
, const u32 max
)
5282 if (min
== max
) return (min
);
5284 return ((rand () % (max
- min
)) + min
);
5287 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5289 u32 quotient
= dividend
/ divisor
;
5291 if (dividend
% divisor
) quotient
++;
5296 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5298 u64 quotient
= dividend
/ divisor
;
5300 if (dividend
% divisor
) quotient
++;
5305 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5307 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5308 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5310 if (tm
->tm_year
- 70)
5312 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5313 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5315 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5317 else if (tm
->tm_yday
)
5319 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5320 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5322 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5324 else if (tm
->tm_hour
)
5326 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5327 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5329 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5331 else if (tm
->tm_min
)
5333 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5334 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5336 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5340 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5342 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5346 void format_speed_display (float val
, char *buf
, size_t len
)
5357 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5368 /* generate output */
5372 snprintf (buf
, len
- 1, "%.0f ", val
);
5376 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5380 void lowercase (u8
*buf
, int len
)
5382 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5385 void uppercase (u8
*buf
, int len
)
5387 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5390 int fgetl (FILE *fp
, char *line_buf
)
5396 const int c
= fgetc (fp
);
5398 if (c
== EOF
) break;
5400 line_buf
[line_len
] = (char) c
;
5404 if (line_len
== BUFSIZ
) line_len
--;
5406 if (c
== '\n') break;
5409 if (line_len
== 0) return 0;
5411 if (line_buf
[line_len
- 1] == '\n')
5415 line_buf
[line_len
] = 0;
5418 if (line_len
== 0) return 0;
5420 if (line_buf
[line_len
- 1] == '\r')
5424 line_buf
[line_len
] = 0;
5430 int in_superchop (char *buf
)
5432 int len
= strlen (buf
);
5436 if (buf
[len
- 1] == '\n')
5443 if (buf
[len
- 1] == '\r')
5458 char **scan_directory (const char *path
)
5460 char *tmp_path
= mystrdup (path
);
5462 size_t tmp_path_len
= strlen (tmp_path
);
5464 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5466 tmp_path
[tmp_path_len
- 1] = 0;
5468 tmp_path_len
= strlen (tmp_path
);
5471 char **files
= NULL
;
5477 if ((d
= opendir (tmp_path
)) != NULL
)
5483 memset (&e
, 0, sizeof (e
));
5484 struct dirent
*de
= NULL
;
5486 if (readdir_r (d
, &e
, &de
) != 0)
5488 log_error ("ERROR: readdir_r() failed");
5493 if (de
== NULL
) break;
5497 while ((de
= readdir (d
)) != NULL
)
5500 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5502 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5504 char *path_file
= (char *) mymalloc (path_size
+ 1);
5506 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5508 path_file
[path_size
] = 0;
5512 if ((d_test
= opendir (path_file
)) != NULL
)
5520 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5524 files
[num_files
- 1] = path_file
;
5530 else if (errno
== ENOTDIR
)
5532 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5536 files
[num_files
- 1] = mystrdup (path
);
5539 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5543 files
[num_files
- 1] = NULL
;
5550 int count_dictionaries (char **dictionary_files
)
5552 if (dictionary_files
== NULL
) return 0;
5556 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5564 char *stroptitype (const uint opti_type
)
5568 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5569 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5570 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5571 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5572 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5573 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5574 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5575 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5576 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5577 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5578 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5579 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5580 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5581 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5587 char *strparser (const uint parser_status
)
5589 switch (parser_status
)
5591 case PARSER_OK
: return ((char *) PA_000
); break;
5592 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5593 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5594 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5595 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5596 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5597 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5598 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5599 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5600 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5601 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5602 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5603 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5604 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5605 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5606 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5607 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5610 return ((char *) PA_255
);
5613 char *strhashtype (const uint hash_mode
)
5617 case 0: return ((char *) HT_00000
); break;
5618 case 10: return ((char *) HT_00010
); break;
5619 case 11: return ((char *) HT_00011
); break;
5620 case 12: return ((char *) HT_00012
); break;
5621 case 20: return ((char *) HT_00020
); break;
5622 case 21: return ((char *) HT_00021
); break;
5623 case 22: return ((char *) HT_00022
); break;
5624 case 23: return ((char *) HT_00023
); break;
5625 case 30: return ((char *) HT_00030
); break;
5626 case 40: return ((char *) HT_00040
); break;
5627 case 50: return ((char *) HT_00050
); break;
5628 case 60: return ((char *) HT_00060
); break;
5629 case 100: return ((char *) HT_00100
); break;
5630 case 101: return ((char *) HT_00101
); break;
5631 case 110: return ((char *) HT_00110
); break;
5632 case 111: return ((char *) HT_00111
); break;
5633 case 112: return ((char *) HT_00112
); break;
5634 case 120: return ((char *) HT_00120
); break;
5635 case 121: return ((char *) HT_00121
); break;
5636 case 122: return ((char *) HT_00122
); break;
5637 case 124: return ((char *) HT_00124
); break;
5638 case 130: return ((char *) HT_00130
); break;
5639 case 131: return ((char *) HT_00131
); break;
5640 case 132: return ((char *) HT_00132
); break;
5641 case 133: return ((char *) HT_00133
); break;
5642 case 140: return ((char *) HT_00140
); break;
5643 case 141: return ((char *) HT_00141
); break;
5644 case 150: return ((char *) HT_00150
); break;
5645 case 160: return ((char *) HT_00160
); break;
5646 case 190: return ((char *) HT_00190
); break;
5647 case 200: return ((char *) HT_00200
); break;
5648 case 300: return ((char *) HT_00300
); break;
5649 case 400: return ((char *) HT_00400
); break;
5650 case 500: return ((char *) HT_00500
); break;
5651 case 501: return ((char *) HT_00501
); break;
5652 case 900: return ((char *) HT_00900
); break;
5653 case 910: return ((char *) HT_00910
); break;
5654 case 1000: return ((char *) HT_01000
); break;
5655 case 1100: return ((char *) HT_01100
); break;
5656 case 1400: return ((char *) HT_01400
); break;
5657 case 1410: return ((char *) HT_01410
); break;
5658 case 1420: return ((char *) HT_01420
); break;
5659 case 1421: return ((char *) HT_01421
); break;
5660 case 1430: return ((char *) HT_01430
); break;
5661 case 1440: return ((char *) HT_01440
); break;
5662 case 1441: return ((char *) HT_01441
); break;
5663 case 1450: return ((char *) HT_01450
); break;
5664 case 1460: return ((char *) HT_01460
); break;
5665 case 1500: return ((char *) HT_01500
); break;
5666 case 1600: return ((char *) HT_01600
); break;
5667 case 1700: return ((char *) HT_01700
); break;
5668 case 1710: return ((char *) HT_01710
); break;
5669 case 1711: return ((char *) HT_01711
); break;
5670 case 1720: return ((char *) HT_01720
); break;
5671 case 1722: return ((char *) HT_01722
); break;
5672 case 1730: return ((char *) HT_01730
); break;
5673 case 1731: return ((char *) HT_01731
); break;
5674 case 1740: return ((char *) HT_01740
); break;
5675 case 1750: return ((char *) HT_01750
); break;
5676 case 1760: return ((char *) HT_01760
); break;
5677 case 1800: return ((char *) HT_01800
); break;
5678 case 2100: return ((char *) HT_02100
); break;
5679 case 2400: return ((char *) HT_02400
); break;
5680 case 2410: return ((char *) HT_02410
); break;
5681 case 2500: return ((char *) HT_02500
); break;
5682 case 2600: return ((char *) HT_02600
); break;
5683 case 2611: return ((char *) HT_02611
); break;
5684 case 2612: return ((char *) HT_02612
); break;
5685 case 2711: return ((char *) HT_02711
); break;
5686 case 2811: return ((char *) HT_02811
); break;
5687 case 3000: return ((char *) HT_03000
); break;
5688 case 3100: return ((char *) HT_03100
); break;
5689 case 3200: return ((char *) HT_03200
); break;
5690 case 3710: return ((char *) HT_03710
); break;
5691 case 3711: return ((char *) HT_03711
); break;
5692 case 3800: return ((char *) HT_03800
); break;
5693 case 4300: return ((char *) HT_04300
); break;
5694 case 4400: return ((char *) HT_04400
); break;
5695 case 4500: return ((char *) HT_04500
); break;
5696 case 4700: return ((char *) HT_04700
); break;
5697 case 4800: return ((char *) HT_04800
); break;
5698 case 4900: return ((char *) HT_04900
); break;
5699 case 5000: return ((char *) HT_05000
); break;
5700 case 5100: return ((char *) HT_05100
); break;
5701 case 5200: return ((char *) HT_05200
); break;
5702 case 5300: return ((char *) HT_05300
); break;
5703 case 5400: return ((char *) HT_05400
); break;
5704 case 5500: return ((char *) HT_05500
); break;
5705 case 5600: return ((char *) HT_05600
); break;
5706 case 5700: return ((char *) HT_05700
); break;
5707 case 5800: return ((char *) HT_05800
); break;
5708 case 6000: return ((char *) HT_06000
); break;
5709 case 6100: return ((char *) HT_06100
); break;
5710 case 6211: return ((char *) HT_06211
); break;
5711 case 6212: return ((char *) HT_06212
); break;
5712 case 6213: return ((char *) HT_06213
); break;
5713 case 6221: return ((char *) HT_06221
); break;
5714 case 6222: return ((char *) HT_06222
); break;
5715 case 6223: return ((char *) HT_06223
); break;
5716 case 6231: return ((char *) HT_06231
); break;
5717 case 6232: return ((char *) HT_06232
); break;
5718 case 6233: return ((char *) HT_06233
); break;
5719 case 6241: return ((char *) HT_06241
); break;
5720 case 6242: return ((char *) HT_06242
); break;
5721 case 6243: return ((char *) HT_06243
); break;
5722 case 6300: return ((char *) HT_06300
); break;
5723 case 6400: return ((char *) HT_06400
); break;
5724 case 6500: return ((char *) HT_06500
); break;
5725 case 6600: return ((char *) HT_06600
); break;
5726 case 6700: return ((char *) HT_06700
); break;
5727 case 6800: return ((char *) HT_06800
); break;
5728 case 6900: return ((char *) HT_06900
); break;
5729 case 7100: return ((char *) HT_07100
); break;
5730 case 7200: return ((char *) HT_07200
); break;
5731 case 7300: return ((char *) HT_07300
); break;
5732 case 7400: return ((char *) HT_07400
); break;
5733 case 7500: return ((char *) HT_07500
); break;
5734 case 7600: return ((char *) HT_07600
); break;
5735 case 7700: return ((char *) HT_07700
); break;
5736 case 7800: return ((char *) HT_07800
); break;
5737 case 7900: return ((char *) HT_07900
); break;
5738 case 8000: return ((char *) HT_08000
); break;
5739 case 8100: return ((char *) HT_08100
); break;
5740 case 8200: return ((char *) HT_08200
); break;
5741 case 8300: return ((char *) HT_08300
); break;
5742 case 8400: return ((char *) HT_08400
); break;
5743 case 8500: return ((char *) HT_08500
); break;
5744 case 8600: return ((char *) HT_08600
); break;
5745 case 8700: return ((char *) HT_08700
); break;
5746 case 8800: return ((char *) HT_08800
); break;
5747 case 8900: return ((char *) HT_08900
); break;
5748 case 9000: return ((char *) HT_09000
); break;
5749 case 9100: return ((char *) HT_09100
); break;
5750 case 9200: return ((char *) HT_09200
); break;
5751 case 9300: return ((char *) HT_09300
); break;
5752 case 9400: return ((char *) HT_09400
); break;
5753 case 9500: return ((char *) HT_09500
); break;
5754 case 9600: return ((char *) HT_09600
); break;
5755 case 9700: return ((char *) HT_09700
); break;
5756 case 9710: return ((char *) HT_09710
); break;
5757 case 9720: return ((char *) HT_09720
); break;
5758 case 9800: return ((char *) HT_09800
); break;
5759 case 9810: return ((char *) HT_09810
); break;
5760 case 9820: return ((char *) HT_09820
); break;
5761 case 9900: return ((char *) HT_09900
); break;
5762 case 10000: return ((char *) HT_10000
); break;
5763 case 10100: return ((char *) HT_10100
); break;
5764 case 10200: return ((char *) HT_10200
); break;
5765 case 10300: return ((char *) HT_10300
); break;
5766 case 10400: return ((char *) HT_10400
); break;
5767 case 10410: return ((char *) HT_10410
); break;
5768 case 10420: return ((char *) HT_10420
); break;
5769 case 10500: return ((char *) HT_10500
); break;
5770 case 10600: return ((char *) HT_10600
); break;
5771 case 10700: return ((char *) HT_10700
); break;
5772 case 10800: return ((char *) HT_10800
); break;
5773 case 10900: return ((char *) HT_10900
); break;
5774 case 11000: return ((char *) HT_11000
); break;
5775 case 11100: return ((char *) HT_11100
); break;
5776 case 11200: return ((char *) HT_11200
); break;
5777 case 11300: return ((char *) HT_11300
); break;
5778 case 11400: return ((char *) HT_11400
); break;
5779 case 11500: return ((char *) HT_11500
); break;
5780 case 11600: return ((char *) HT_11600
); break;
5781 case 11700: return ((char *) HT_11700
); break;
5782 case 11800: return ((char *) HT_11800
); break;
5783 case 11900: return ((char *) HT_11900
); break;
5784 case 12000: return ((char *) HT_12000
); break;
5785 case 12100: return ((char *) HT_12100
); break;
5786 case 12200: return ((char *) HT_12200
); break;
5787 case 12300: return ((char *) HT_12300
); break;
5788 case 12400: return ((char *) HT_12400
); break;
5789 case 12500: return ((char *) HT_12500
); break;
5790 case 12600: return ((char *) HT_12600
); break;
5791 case 12700: return ((char *) HT_12700
); break;
5792 case 12800: return ((char *) HT_12800
); break;
5793 case 12900: return ((char *) HT_12900
); break;
5794 case 13000: return ((char *) HT_13000
); break;
5797 return ((char *) "Unknown");
5800 char *strstatus (const uint devices_status
)
5802 switch (devices_status
)
5804 case STATUS_INIT
: return ((char *) ST_0000
); break;
5805 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5806 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5807 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5808 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5809 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5810 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5811 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5812 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5813 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5816 return ((char *) "Unknown");
5819 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5821 uint hash_type
= data
.hash_type
;
5822 uint hash_mode
= data
.hash_mode
;
5823 uint salt_type
= data
.salt_type
;
5824 uint opts_type
= data
.opts_type
;
5825 uint opti_type
= data
.opti_type
;
5826 uint dgst_size
= data
.dgst_size
;
5828 char *hashfile
= data
.hashfile
;
5832 uint digest_buf
[64] = { 0 };
5834 u64
*digest_buf64
= (u64
*) digest_buf
;
5836 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5838 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5840 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5846 case HASH_TYPE_DESCRYPT
:
5847 FP (digest_buf
[1], digest_buf
[0], tt
);
5850 case HASH_TYPE_DESRACF
:
5851 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5852 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5854 FP (digest_buf
[1], digest_buf
[0], tt
);
5858 FP (digest_buf
[1], digest_buf
[0], tt
);
5861 case HASH_TYPE_NETNTLM
:
5862 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5863 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5864 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5865 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5867 FP (digest_buf
[1], digest_buf
[0], tt
);
5868 FP (digest_buf
[3], digest_buf
[2], tt
);
5871 case HASH_TYPE_BSDICRYPT
:
5872 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5873 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5875 FP (digest_buf
[1], digest_buf
[0], tt
);
5880 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5885 digest_buf
[0] += MD4M_A
;
5886 digest_buf
[1] += MD4M_B
;
5887 digest_buf
[2] += MD4M_C
;
5888 digest_buf
[3] += MD4M_D
;
5892 digest_buf
[0] += MD5M_A
;
5893 digest_buf
[1] += MD5M_B
;
5894 digest_buf
[2] += MD5M_C
;
5895 digest_buf
[3] += MD5M_D
;
5898 case HASH_TYPE_SHA1
:
5899 digest_buf
[0] += SHA1M_A
;
5900 digest_buf
[1] += SHA1M_B
;
5901 digest_buf
[2] += SHA1M_C
;
5902 digest_buf
[3] += SHA1M_D
;
5903 digest_buf
[4] += SHA1M_E
;
5906 case HASH_TYPE_SHA256
:
5907 digest_buf
[0] += SHA256M_A
;
5908 digest_buf
[1] += SHA256M_B
;
5909 digest_buf
[2] += SHA256M_C
;
5910 digest_buf
[3] += SHA256M_D
;
5911 digest_buf
[4] += SHA256M_E
;
5912 digest_buf
[5] += SHA256M_F
;
5913 digest_buf
[6] += SHA256M_G
;
5914 digest_buf
[7] += SHA256M_H
;
5917 case HASH_TYPE_SHA384
:
5918 digest_buf64
[0] += SHA384M_A
;
5919 digest_buf64
[1] += SHA384M_B
;
5920 digest_buf64
[2] += SHA384M_C
;
5921 digest_buf64
[3] += SHA384M_D
;
5922 digest_buf64
[4] += SHA384M_E
;
5923 digest_buf64
[5] += SHA384M_F
;
5924 digest_buf64
[6] += 0;
5925 digest_buf64
[7] += 0;
5928 case HASH_TYPE_SHA512
:
5929 digest_buf64
[0] += SHA512M_A
;
5930 digest_buf64
[1] += SHA512M_B
;
5931 digest_buf64
[2] += SHA512M_C
;
5932 digest_buf64
[3] += SHA512M_D
;
5933 digest_buf64
[4] += SHA512M_E
;
5934 digest_buf64
[5] += SHA512M_F
;
5935 digest_buf64
[6] += SHA512M_G
;
5936 digest_buf64
[7] += SHA512M_H
;
5941 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5943 if (dgst_size
== DGST_SIZE_4_2
)
5945 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5947 else if (dgst_size
== DGST_SIZE_4_4
)
5949 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5951 else if (dgst_size
== DGST_SIZE_4_5
)
5953 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5955 else if (dgst_size
== DGST_SIZE_4_6
)
5957 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5959 else if (dgst_size
== DGST_SIZE_4_8
)
5961 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5963 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5965 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5967 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5969 else if (hash_type
== HASH_TYPE_SHA384
)
5971 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5973 else if (hash_type
== HASH_TYPE_SHA512
)
5975 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5977 else if (hash_type
== HASH_TYPE_GOST
)
5979 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5982 else if (dgst_size
== DGST_SIZE_4_64
)
5984 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5986 else if (dgst_size
== DGST_SIZE_8_25
)
5988 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5992 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5993 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5994 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6000 memset (&salt
, 0, sizeof (salt_t
));
6002 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6004 char *ptr
= (char *) salt
.salt_buf
;
6006 uint len
= salt
.salt_len
;
6008 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6014 case HASH_TYPE_NETNTLM
:
6016 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6017 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6019 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6025 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6027 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6035 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6037 uint max
= salt
.salt_len
/ 4;
6041 for (uint i
= 0; i
< max
; i
++)
6043 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6047 if (opts_type
& OPTS_TYPE_ST_HEX
)
6049 char tmp
[64] = { 0 };
6051 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6053 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6058 memcpy (ptr
, tmp
, len
);
6061 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6063 memset (ptr
+ len
, 0, memset_size
);
6065 salt
.salt_len
= len
;
6069 // some modes require special encoding
6072 uint out_buf_plain
[256] = { 0 };
6073 uint out_buf_salt
[256] = { 0 };
6075 char tmp_buf
[1024] = { 0 };
6077 char *ptr_plain
= (char *) out_buf_plain
;
6078 char *ptr_salt
= (char *) out_buf_salt
;
6080 if (hash_mode
== 22)
6082 char username
[30] = { 0 };
6084 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6086 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6088 u16
*ptr
= (u16
*) digest_buf
;
6090 tmp_buf
[ 0] = sig
[0];
6091 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6092 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6093 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6094 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6095 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6096 tmp_buf
[ 6] = sig
[1];
6097 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6098 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6099 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6100 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6101 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6102 tmp_buf
[12] = sig
[2];
6103 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6104 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6105 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6106 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6107 tmp_buf
[17] = sig
[3];
6108 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6109 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6110 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6111 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6112 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6113 tmp_buf
[23] = sig
[4];
6114 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6115 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6116 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6117 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6118 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6119 tmp_buf
[29] = sig
[5];
6121 snprintf (out_buf
, len
-1, "%s:%s",
6125 else if (hash_mode
== 23)
6127 // do not show the \nskyper\n part in output
6129 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6131 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6133 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6140 else if (hash_mode
== 101)
6142 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6144 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6145 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6146 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6147 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6148 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6150 memcpy (tmp_buf
, digest_buf
, 20);
6152 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6154 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6156 else if (hash_mode
== 111)
6158 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6160 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6161 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6162 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6163 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6164 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6166 memcpy (tmp_buf
, digest_buf
, 20);
6167 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6169 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6171 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6173 else if (hash_mode
== 122)
6175 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6176 (char *) salt
.salt_buf
,
6183 else if (hash_mode
== 124)
6185 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6186 (char *) salt
.salt_buf
,
6193 else if (hash_mode
== 131)
6195 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6196 (char *) salt
.salt_buf
,
6204 else if (hash_mode
== 132)
6206 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6207 (char *) salt
.salt_buf
,
6214 else if (hash_mode
== 133)
6216 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6218 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6219 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6220 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6221 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6222 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6224 memcpy (tmp_buf
, digest_buf
, 20);
6226 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6228 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6230 else if (hash_mode
== 141)
6232 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6234 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6236 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6238 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6240 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6241 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6242 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6243 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6244 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6246 memcpy (tmp_buf
, digest_buf
, 20);
6248 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6252 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6254 else if (hash_mode
== 400)
6256 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6258 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6259 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6260 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6261 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6263 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6265 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6267 else if (hash_mode
== 500)
6269 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6271 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6272 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6273 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6274 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6276 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6278 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6280 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6284 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6287 else if (hash_mode
== 501)
6289 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6291 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6292 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6294 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6296 else if (hash_mode
== 1421)
6298 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6300 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6316 else if (hash_mode
== 1441)
6318 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6320 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6322 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6324 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6326 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6327 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6328 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6329 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6330 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6331 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6332 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6333 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6335 memcpy (tmp_buf
, digest_buf
, 32);
6337 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6341 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6343 else if (hash_mode
== 1500)
6345 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6346 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6347 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6348 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6349 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6351 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6353 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6355 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6356 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6358 memcpy (tmp_buf
, digest_buf
, 8);
6360 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6362 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6366 else if (hash_mode
== 1600)
6368 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6370 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6371 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6372 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6373 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6375 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6377 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6379 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6383 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6386 else if (hash_mode
== 1711)
6388 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6390 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6391 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6392 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6393 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6394 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6395 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6396 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6397 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6399 memcpy (tmp_buf
, digest_buf
, 64);
6400 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6402 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6404 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6406 else if (hash_mode
== 1722)
6408 uint
*ptr
= digest_buf
;
6410 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6411 (unsigned char *) salt
.salt_buf
,
6421 else if (hash_mode
== 1731)
6423 uint
*ptr
= digest_buf
;
6425 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6426 (unsigned char *) salt
.salt_buf
,
6436 else if (hash_mode
== 1800)
6440 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6441 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6442 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6443 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6444 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6445 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6446 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6447 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6449 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6451 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6453 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6457 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6460 else if (hash_mode
== 2100)
6464 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6466 salt
.salt_iter
+ 1);
6468 uint signature_len
= strlen (out_buf
);
6470 pos
+= signature_len
;
6471 len
-= signature_len
;
6473 char *salt_ptr
= (char *) salt
.salt_buf
;
6475 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6477 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6478 byte_swap_32 (digest_buf
[0]),
6479 byte_swap_32 (digest_buf
[1]),
6480 byte_swap_32 (digest_buf
[2]),
6481 byte_swap_32 (digest_buf
[3]));
6483 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6485 memcpy (tmp_buf
, digest_buf
, 16);
6487 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6489 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6490 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6491 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6492 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6494 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6495 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6496 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6497 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6499 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6500 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6501 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6502 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6504 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6505 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6506 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6507 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6509 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6510 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6511 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6512 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6516 else if (hash_mode
== 2500)
6518 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6520 wpa_t
*wpa
= &wpas
[salt_pos
];
6522 uint pke
[25] = { 0 };
6524 char *pke_ptr
= (char *) pke
;
6526 for (uint i
= 0; i
< 25; i
++)
6528 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6531 unsigned char mac1
[6] = { 0 };
6532 unsigned char mac2
[6] = { 0 };
6534 memcpy (mac1
, pke_ptr
+ 23, 6);
6535 memcpy (mac2
, pke_ptr
+ 29, 6);
6537 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6538 (char *) salt
.salt_buf
,
6552 else if (hash_mode
== 4400)
6554 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6555 byte_swap_32 (digest_buf
[0]),
6556 byte_swap_32 (digest_buf
[1]),
6557 byte_swap_32 (digest_buf
[2]),
6558 byte_swap_32 (digest_buf
[3]));
6560 else if (hash_mode
== 4700)
6562 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6563 byte_swap_32 (digest_buf
[0]),
6564 byte_swap_32 (digest_buf
[1]),
6565 byte_swap_32 (digest_buf
[2]),
6566 byte_swap_32 (digest_buf
[3]),
6567 byte_swap_32 (digest_buf
[4]));
6569 else if (hash_mode
== 4800)
6571 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6573 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6578 byte_swap_32 (salt
.salt_buf
[0]),
6579 byte_swap_32 (salt
.salt_buf
[1]),
6580 byte_swap_32 (salt
.salt_buf
[2]),
6581 byte_swap_32 (salt
.salt_buf
[3]),
6584 else if (hash_mode
== 4900)
6586 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6587 byte_swap_32 (digest_buf
[0]),
6588 byte_swap_32 (digest_buf
[1]),
6589 byte_swap_32 (digest_buf
[2]),
6590 byte_swap_32 (digest_buf
[3]),
6591 byte_swap_32 (digest_buf
[4]));
6593 else if (hash_mode
== 5100)
6595 snprintf (out_buf
, len
-1, "%08x%08x",
6599 else if (hash_mode
== 5200)
6601 snprintf (out_buf
, len
-1, "%s", hashfile
);
6603 else if (hash_mode
== 5300)
6605 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6607 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6609 int buf_len
= len
-1;
6613 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6615 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6617 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6619 snprintf (out_buf
, buf_len
, ":");
6625 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6633 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6635 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6637 if ((i
== 0) || (i
== 5))
6639 snprintf (out_buf
, buf_len
, ":");
6645 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6653 for (uint i
= 0; i
< 4; i
++)
6657 snprintf (out_buf
, buf_len
, ":");
6663 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6669 else if (hash_mode
== 5400)
6671 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6673 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6675 int buf_len
= len
-1;
6679 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6681 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6683 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6685 snprintf (out_buf
, buf_len
, ":");
6691 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6699 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6701 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6703 if ((i
== 0) || (i
== 5))
6705 snprintf (out_buf
, buf_len
, ":");
6711 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6719 for (uint i
= 0; i
< 5; i
++)
6723 snprintf (out_buf
, buf_len
, ":");
6729 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6735 else if (hash_mode
== 5500)
6737 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6739 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6741 char user_buf
[64] = { 0 };
6742 char domain_buf
[64] = { 0 };
6743 char srvchall_buf
[1024] = { 0 };
6744 char clichall_buf
[1024] = { 0 };
6746 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6748 char *ptr
= (char *) netntlm
->userdomain_buf
;
6750 user_buf
[i
] = ptr
[j
];
6753 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6755 char *ptr
= (char *) netntlm
->userdomain_buf
;
6757 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6760 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6762 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6764 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6767 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6769 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6771 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6774 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6782 byte_swap_32 (salt
.salt_buf_pc
[0]),
6783 byte_swap_32 (salt
.salt_buf_pc
[1]),
6786 else if (hash_mode
== 5600)
6788 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6790 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6792 char user_buf
[64] = { 0 };
6793 char domain_buf
[64] = { 0 };
6794 char srvchall_buf
[1024] = { 0 };
6795 char clichall_buf
[1024] = { 0 };
6797 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6799 char *ptr
= (char *) netntlm
->userdomain_buf
;
6801 user_buf
[i
] = ptr
[j
];
6804 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6806 char *ptr
= (char *) netntlm
->userdomain_buf
;
6808 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6811 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6813 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6815 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6818 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6820 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6822 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6825 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6835 else if (hash_mode
== 5700)
6837 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6839 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6840 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6841 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6842 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6843 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6844 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6845 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6846 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6848 memcpy (tmp_buf
, digest_buf
, 32);
6850 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6854 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6856 else if (hash_mode
== 5800)
6858 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6859 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6860 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6861 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6862 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6864 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6871 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6873 snprintf (out_buf
, len
-1, "%s", hashfile
);
6875 else if (hash_mode
== 6300)
6877 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6879 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6880 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6881 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6882 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6884 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6886 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6888 else if (hash_mode
== 6400)
6890 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6892 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6894 else if (hash_mode
== 6500)
6896 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6898 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6900 else if (hash_mode
== 6600)
6902 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6904 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6906 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6907 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6909 uint buf_len
= len
- 1;
6911 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6914 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6916 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6921 else if (hash_mode
== 6700)
6923 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6925 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6927 else if (hash_mode
== 6800)
6929 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6931 else if (hash_mode
== 7100)
6933 uint
*ptr
= digest_buf
;
6935 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6937 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6939 uint esalt
[8] = { 0 };
6941 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6942 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6943 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6944 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6945 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6946 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6947 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6948 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6950 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",
6951 SIGNATURE_SHA512OSX
,
6953 esalt
[ 0], esalt
[ 1],
6954 esalt
[ 2], esalt
[ 3],
6955 esalt
[ 4], esalt
[ 5],
6956 esalt
[ 6], esalt
[ 7],
6964 ptr
[15], ptr
[14]);
6966 else if (hash_mode
== 7200)
6968 uint
*ptr
= digest_buf
;
6970 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6972 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6976 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6978 len_used
= strlen (out_buf
);
6980 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6982 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6984 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6987 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",
6995 ptr
[15], ptr
[14]);
6997 else if (hash_mode
== 7300)
6999 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7001 rakp_t
*rakp
= &rakps
[salt_pos
];
7003 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7005 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7008 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7015 else if (hash_mode
== 7400)
7017 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7019 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7020 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7021 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7022 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7023 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7024 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7025 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7026 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7028 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7030 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7032 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7036 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7039 else if (hash_mode
== 7500)
7041 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7043 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7045 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7046 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7048 char data
[128] = { 0 };
7050 char *ptr_data
= data
;
7052 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7054 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7057 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7059 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7064 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7066 (char *) krb5pa
->user
,
7067 (char *) krb5pa
->realm
,
7068 (char *) krb5pa
->salt
,
7071 else if (hash_mode
== 7700)
7073 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7074 (char *) salt
.salt_buf
,
7078 else if (hash_mode
== 7800)
7080 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7081 (char *) salt
.salt_buf
,
7088 else if (hash_mode
== 7900)
7090 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7094 char *tmp
= (char *) salt
.salt_buf_pc
;
7096 ptr_plain
[42] = tmp
[0];
7102 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7104 else if (hash_mode
== 8000)
7106 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7107 (unsigned char *) salt
.salt_buf
,
7117 else if (hash_mode
== 8100)
7119 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7120 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7122 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7123 (unsigned char *) salt
.salt_buf
,
7130 else if (hash_mode
== 8200)
7132 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7134 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7136 char data_buf
[4096] = { 0 };
7138 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7140 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7143 data_buf
[cloudkey
->data_len
* 2] = 0;
7145 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7146 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7147 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7148 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7149 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7150 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7151 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7152 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7154 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7155 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7156 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7157 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7159 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7175 else if (hash_mode
== 8300)
7177 char digest_buf_c
[34] = { 0 };
7179 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7181 digest_buf_c
[32] = 0;
7185 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7187 char domain_buf_c
[33] = { 0 };
7189 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7191 for (uint i
= 0; i
< salt_pc_len
; i
++)
7193 const char next
= domain_buf_c
[i
];
7195 domain_buf_c
[i
] = '.';
7200 domain_buf_c
[salt_pc_len
] = 0;
7204 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7206 else if (hash_mode
== 8500)
7208 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7210 else if (hash_mode
== 2612)
7212 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7214 (char *) salt
.salt_buf
,
7220 else if (hash_mode
== 3711)
7222 char *salt_ptr
= (char *) salt
.salt_buf
;
7224 salt_ptr
[salt
.salt_len
- 1] = 0;
7226 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7227 SIGNATURE_MEDIAWIKI_B
,
7234 else if (hash_mode
== 8800)
7236 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7238 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7240 char tmp
[3073] = { 0 };
7242 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7244 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7249 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7250 SIGNATURE_ANDROIDFDE
,
7251 byte_swap_32 (salt
.salt_buf
[0]),
7252 byte_swap_32 (salt
.salt_buf
[1]),
7253 byte_swap_32 (salt
.salt_buf
[2]),
7254 byte_swap_32 (salt
.salt_buf
[3]),
7255 byte_swap_32 (digest_buf
[0]),
7256 byte_swap_32 (digest_buf
[1]),
7257 byte_swap_32 (digest_buf
[2]),
7258 byte_swap_32 (digest_buf
[3]),
7261 else if (hash_mode
== 8900)
7263 uint N
= salt
.scrypt_N
;
7264 uint r
= salt
.scrypt_r
;
7265 uint p
= salt
.scrypt_p
;
7267 char base64_salt
[32] = { 0 };
7269 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7271 memset (tmp_buf
, 0, 46);
7273 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7274 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7275 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7276 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7277 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7278 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7279 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7280 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7281 digest_buf
[8] = 0; // needed for base64_encode ()
7283 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7285 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7293 else if (hash_mode
== 9000)
7295 snprintf (out_buf
, len
-1, "%s", hashfile
);
7297 else if (hash_mode
== 9200)
7301 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7303 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7305 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7309 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7310 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7311 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7312 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7313 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7314 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7315 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7316 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7317 digest_buf
[8] = 0; // needed for base64_encode ()
7319 char tmp_buf
[64] = { 0 };
7321 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7322 tmp_buf
[43] = 0; // cut it here
7326 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7328 else if (hash_mode
== 9300)
7330 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7331 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7332 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7333 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7334 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7335 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7336 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7337 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7338 digest_buf
[8] = 0; // needed for base64_encode ()
7340 char tmp_buf
[64] = { 0 };
7342 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7343 tmp_buf
[43] = 0; // cut it here
7345 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7347 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7349 else if (hash_mode
== 9400)
7351 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7353 office2007_t
*office2007
= &office2007s
[salt_pos
];
7355 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7356 SIGNATURE_OFFICE2007
,
7359 office2007
->keySize
,
7365 office2007
->encryptedVerifier
[0],
7366 office2007
->encryptedVerifier
[1],
7367 office2007
->encryptedVerifier
[2],
7368 office2007
->encryptedVerifier
[3],
7369 office2007
->encryptedVerifierHash
[0],
7370 office2007
->encryptedVerifierHash
[1],
7371 office2007
->encryptedVerifierHash
[2],
7372 office2007
->encryptedVerifierHash
[3],
7373 office2007
->encryptedVerifierHash
[4]);
7375 else if (hash_mode
== 9500)
7377 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7379 office2010_t
*office2010
= &office2010s
[salt_pos
];
7381 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,
7387 office2010
->encryptedVerifier
[0],
7388 office2010
->encryptedVerifier
[1],
7389 office2010
->encryptedVerifier
[2],
7390 office2010
->encryptedVerifier
[3],
7391 office2010
->encryptedVerifierHash
[0],
7392 office2010
->encryptedVerifierHash
[1],
7393 office2010
->encryptedVerifierHash
[2],
7394 office2010
->encryptedVerifierHash
[3],
7395 office2010
->encryptedVerifierHash
[4],
7396 office2010
->encryptedVerifierHash
[5],
7397 office2010
->encryptedVerifierHash
[6],
7398 office2010
->encryptedVerifierHash
[7]);
7400 else if (hash_mode
== 9600)
7402 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7404 office2013_t
*office2013
= &office2013s
[salt_pos
];
7406 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,
7412 office2013
->encryptedVerifier
[0],
7413 office2013
->encryptedVerifier
[1],
7414 office2013
->encryptedVerifier
[2],
7415 office2013
->encryptedVerifier
[3],
7416 office2013
->encryptedVerifierHash
[0],
7417 office2013
->encryptedVerifierHash
[1],
7418 office2013
->encryptedVerifierHash
[2],
7419 office2013
->encryptedVerifierHash
[3],
7420 office2013
->encryptedVerifierHash
[4],
7421 office2013
->encryptedVerifierHash
[5],
7422 office2013
->encryptedVerifierHash
[6],
7423 office2013
->encryptedVerifierHash
[7]);
7425 else if (hash_mode
== 9700)
7427 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7429 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7431 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7432 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7433 byte_swap_32 (salt
.salt_buf
[0]),
7434 byte_swap_32 (salt
.salt_buf
[1]),
7435 byte_swap_32 (salt
.salt_buf
[2]),
7436 byte_swap_32 (salt
.salt_buf
[3]),
7437 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7438 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7439 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7440 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7441 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7442 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7443 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7444 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7446 else if (hash_mode
== 9710)
7448 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7450 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7452 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7453 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7454 byte_swap_32 (salt
.salt_buf
[0]),
7455 byte_swap_32 (salt
.salt_buf
[1]),
7456 byte_swap_32 (salt
.salt_buf
[2]),
7457 byte_swap_32 (salt
.salt_buf
[3]),
7458 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7459 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7460 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7461 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7462 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7463 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7464 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7465 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7467 else if (hash_mode
== 9720)
7469 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7471 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7473 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7475 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7476 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7477 byte_swap_32 (salt
.salt_buf
[0]),
7478 byte_swap_32 (salt
.salt_buf
[1]),
7479 byte_swap_32 (salt
.salt_buf
[2]),
7480 byte_swap_32 (salt
.salt_buf
[3]),
7481 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7482 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7483 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7484 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7485 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7486 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7487 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7488 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7495 else if (hash_mode
== 9800)
7497 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7499 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7501 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7502 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7507 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7508 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7509 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7510 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7511 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7512 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7513 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7514 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7515 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7517 else if (hash_mode
== 9810)
7519 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7521 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7523 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7524 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7529 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7530 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7531 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7532 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7533 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7534 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7535 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7536 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7537 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7539 else if (hash_mode
== 9820)
7541 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7543 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7545 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7547 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7548 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7553 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7554 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7555 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7556 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7557 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7558 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7559 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7560 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7561 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7568 else if (hash_mode
== 10000)
7572 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7574 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7576 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7580 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7581 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7582 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7583 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7584 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7585 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7586 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7587 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7588 digest_buf
[8] = 0; // needed for base64_encode ()
7590 char tmp_buf
[64] = { 0 };
7592 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7596 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7598 else if (hash_mode
== 10100)
7600 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7605 byte_swap_32 (salt
.salt_buf
[0]),
7606 byte_swap_32 (salt
.salt_buf
[1]),
7607 byte_swap_32 (salt
.salt_buf
[2]),
7608 byte_swap_32 (salt
.salt_buf
[3]));
7610 else if (hash_mode
== 10200)
7612 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7614 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7618 char challenge
[100] = { 0 };
7620 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7624 char tmp_buf
[100] = { 0 };
7626 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7627 (char *) cram_md5
->user
,
7633 char response
[100] = { 0 };
7635 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7637 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7639 else if (hash_mode
== 10300)
7641 char tmp_buf
[100] = { 0 };
7643 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7644 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7646 uint tmp_len
= 20 + salt
.salt_len
;
7650 char base64_encoded
[100] = { 0 };
7652 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7654 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7656 else if (hash_mode
== 10400)
7658 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7660 pdf_t
*pdf
= &pdfs
[salt_pos
];
7662 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",
7670 byte_swap_32 (pdf
->id_buf
[0]),
7671 byte_swap_32 (pdf
->id_buf
[1]),
7672 byte_swap_32 (pdf
->id_buf
[2]),
7673 byte_swap_32 (pdf
->id_buf
[3]),
7675 byte_swap_32 (pdf
->u_buf
[0]),
7676 byte_swap_32 (pdf
->u_buf
[1]),
7677 byte_swap_32 (pdf
->u_buf
[2]),
7678 byte_swap_32 (pdf
->u_buf
[3]),
7679 byte_swap_32 (pdf
->u_buf
[4]),
7680 byte_swap_32 (pdf
->u_buf
[5]),
7681 byte_swap_32 (pdf
->u_buf
[6]),
7682 byte_swap_32 (pdf
->u_buf
[7]),
7684 byte_swap_32 (pdf
->o_buf
[0]),
7685 byte_swap_32 (pdf
->o_buf
[1]),
7686 byte_swap_32 (pdf
->o_buf
[2]),
7687 byte_swap_32 (pdf
->o_buf
[3]),
7688 byte_swap_32 (pdf
->o_buf
[4]),
7689 byte_swap_32 (pdf
->o_buf
[5]),
7690 byte_swap_32 (pdf
->o_buf
[6]),
7691 byte_swap_32 (pdf
->o_buf
[7])
7694 else if (hash_mode
== 10410)
7696 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7698 pdf_t
*pdf
= &pdfs
[salt_pos
];
7700 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",
7708 byte_swap_32 (pdf
->id_buf
[0]),
7709 byte_swap_32 (pdf
->id_buf
[1]),
7710 byte_swap_32 (pdf
->id_buf
[2]),
7711 byte_swap_32 (pdf
->id_buf
[3]),
7713 byte_swap_32 (pdf
->u_buf
[0]),
7714 byte_swap_32 (pdf
->u_buf
[1]),
7715 byte_swap_32 (pdf
->u_buf
[2]),
7716 byte_swap_32 (pdf
->u_buf
[3]),
7717 byte_swap_32 (pdf
->u_buf
[4]),
7718 byte_swap_32 (pdf
->u_buf
[5]),
7719 byte_swap_32 (pdf
->u_buf
[6]),
7720 byte_swap_32 (pdf
->u_buf
[7]),
7722 byte_swap_32 (pdf
->o_buf
[0]),
7723 byte_swap_32 (pdf
->o_buf
[1]),
7724 byte_swap_32 (pdf
->o_buf
[2]),
7725 byte_swap_32 (pdf
->o_buf
[3]),
7726 byte_swap_32 (pdf
->o_buf
[4]),
7727 byte_swap_32 (pdf
->o_buf
[5]),
7728 byte_swap_32 (pdf
->o_buf
[6]),
7729 byte_swap_32 (pdf
->o_buf
[7])
7732 else if (hash_mode
== 10420)
7734 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7736 pdf_t
*pdf
= &pdfs
[salt_pos
];
7738 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7740 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",
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]),
7753 byte_swap_32 (pdf
->u_buf
[0]),
7754 byte_swap_32 (pdf
->u_buf
[1]),
7755 byte_swap_32 (pdf
->u_buf
[2]),
7756 byte_swap_32 (pdf
->u_buf
[3]),
7757 byte_swap_32 (pdf
->u_buf
[4]),
7758 byte_swap_32 (pdf
->u_buf
[5]),
7759 byte_swap_32 (pdf
->u_buf
[6]),
7760 byte_swap_32 (pdf
->u_buf
[7]),
7762 byte_swap_32 (pdf
->o_buf
[0]),
7763 byte_swap_32 (pdf
->o_buf
[1]),
7764 byte_swap_32 (pdf
->o_buf
[2]),
7765 byte_swap_32 (pdf
->o_buf
[3]),
7766 byte_swap_32 (pdf
->o_buf
[4]),
7767 byte_swap_32 (pdf
->o_buf
[5]),
7768 byte_swap_32 (pdf
->o_buf
[6]),
7769 byte_swap_32 (pdf
->o_buf
[7]),
7777 else if (hash_mode
== 10500)
7779 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7781 pdf_t
*pdf
= &pdfs
[salt_pos
];
7783 if (pdf
->id_len
== 32)
7785 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",
7793 byte_swap_32 (pdf
->id_buf
[0]),
7794 byte_swap_32 (pdf
->id_buf
[1]),
7795 byte_swap_32 (pdf
->id_buf
[2]),
7796 byte_swap_32 (pdf
->id_buf
[3]),
7797 byte_swap_32 (pdf
->id_buf
[4]),
7798 byte_swap_32 (pdf
->id_buf
[5]),
7799 byte_swap_32 (pdf
->id_buf
[6]),
7800 byte_swap_32 (pdf
->id_buf
[7]),
7802 byte_swap_32 (pdf
->u_buf
[0]),
7803 byte_swap_32 (pdf
->u_buf
[1]),
7804 byte_swap_32 (pdf
->u_buf
[2]),
7805 byte_swap_32 (pdf
->u_buf
[3]),
7806 byte_swap_32 (pdf
->u_buf
[4]),
7807 byte_swap_32 (pdf
->u_buf
[5]),
7808 byte_swap_32 (pdf
->u_buf
[6]),
7809 byte_swap_32 (pdf
->u_buf
[7]),
7811 byte_swap_32 (pdf
->o_buf
[0]),
7812 byte_swap_32 (pdf
->o_buf
[1]),
7813 byte_swap_32 (pdf
->o_buf
[2]),
7814 byte_swap_32 (pdf
->o_buf
[3]),
7815 byte_swap_32 (pdf
->o_buf
[4]),
7816 byte_swap_32 (pdf
->o_buf
[5]),
7817 byte_swap_32 (pdf
->o_buf
[6]),
7818 byte_swap_32 (pdf
->o_buf
[7])
7823 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",
7831 byte_swap_32 (pdf
->id_buf
[0]),
7832 byte_swap_32 (pdf
->id_buf
[1]),
7833 byte_swap_32 (pdf
->id_buf
[2]),
7834 byte_swap_32 (pdf
->id_buf
[3]),
7836 byte_swap_32 (pdf
->u_buf
[0]),
7837 byte_swap_32 (pdf
->u_buf
[1]),
7838 byte_swap_32 (pdf
->u_buf
[2]),
7839 byte_swap_32 (pdf
->u_buf
[3]),
7840 byte_swap_32 (pdf
->u_buf
[4]),
7841 byte_swap_32 (pdf
->u_buf
[5]),
7842 byte_swap_32 (pdf
->u_buf
[6]),
7843 byte_swap_32 (pdf
->u_buf
[7]),
7845 byte_swap_32 (pdf
->o_buf
[0]),
7846 byte_swap_32 (pdf
->o_buf
[1]),
7847 byte_swap_32 (pdf
->o_buf
[2]),
7848 byte_swap_32 (pdf
->o_buf
[3]),
7849 byte_swap_32 (pdf
->o_buf
[4]),
7850 byte_swap_32 (pdf
->o_buf
[5]),
7851 byte_swap_32 (pdf
->o_buf
[6]),
7852 byte_swap_32 (pdf
->o_buf
[7])
7856 else if (hash_mode
== 10600)
7858 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7860 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7861 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7863 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7865 else if (hash_mode
== 10700)
7867 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7869 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7870 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7872 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7874 else if (hash_mode
== 10900)
7876 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7878 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7879 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7881 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7883 else if (hash_mode
== 11100)
7885 u32 salt_challenge
= salt
.salt_buf
[0];
7887 salt_challenge
= byte_swap_32 (salt_challenge
);
7889 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7891 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7892 SIGNATURE_POSTGRESQL_AUTH
,
7900 else if (hash_mode
== 11200)
7902 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7903 SIGNATURE_MYSQL_AUTH
,
7904 (unsigned char *) salt
.salt_buf
,
7911 else if (hash_mode
== 11300)
7913 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7915 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7917 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7918 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7919 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7921 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7922 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7923 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7925 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7927 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7929 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7932 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7934 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7936 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7939 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7941 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7943 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7946 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7947 SIGNATURE_BITCOIN_WALLET
,
7951 (unsigned char *) salt
.salt_buf
,
7959 free (cry_master_buf
);
7961 free (public_key_buf
);
7963 else if (hash_mode
== 11400)
7965 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7967 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7968 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7970 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7972 else if (hash_mode
== 11600)
7974 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7976 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7978 const uint data_len
= seven_zip
->data_len
;
7980 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7982 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7984 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
7986 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7989 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7990 SIGNATURE_SEVEN_ZIP
,
7994 (char *) seven_zip
->salt_buf
,
7996 seven_zip
->iv_buf
[0],
7997 seven_zip
->iv_buf
[1],
7998 seven_zip
->iv_buf
[2],
7999 seven_zip
->iv_buf
[3],
8001 seven_zip
->data_len
,
8002 seven_zip
->unpack_size
,
8007 else if (hash_mode
== 11700)
8009 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8019 else if (hash_mode
== 11800)
8021 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8039 else if (hash_mode
== 11900)
8041 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8043 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8044 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8046 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8048 else if (hash_mode
== 12000)
8050 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8052 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8053 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8055 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8057 else if (hash_mode
== 12100)
8059 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8061 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8062 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8064 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8066 else if (hash_mode
== 12200)
8068 uint
*ptr_digest
= digest_buf
;
8069 uint
*ptr_salt
= salt
.salt_buf
;
8071 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8078 else if (hash_mode
== 12300)
8080 uint
*ptr_digest
= digest_buf
;
8081 uint
*ptr_salt
= salt
.salt_buf
;
8083 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",
8084 ptr_digest
[ 0], ptr_digest
[ 1],
8085 ptr_digest
[ 2], ptr_digest
[ 3],
8086 ptr_digest
[ 4], ptr_digest
[ 5],
8087 ptr_digest
[ 6], ptr_digest
[ 7],
8088 ptr_digest
[ 8], ptr_digest
[ 9],
8089 ptr_digest
[10], ptr_digest
[11],
8090 ptr_digest
[12], ptr_digest
[13],
8091 ptr_digest
[14], ptr_digest
[15],
8097 else if (hash_mode
== 12400)
8099 // encode iteration count
8101 char salt_iter
[5] = { 0 };
8103 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8104 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8105 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8106 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8111 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8112 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8113 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8114 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8119 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8121 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8122 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8124 memcpy (tmp_buf
, digest_buf
, 8);
8126 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8130 // fill the resulting buffer
8132 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8134 else if (hash_mode
== 12500)
8136 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8138 byte_swap_32 (salt
.salt_buf
[0]),
8139 byte_swap_32 (salt
.salt_buf
[1]),
8145 else if (hash_mode
== 12600)
8147 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8148 digest_buf
[0] + salt
.salt_buf_pc
[0],
8149 digest_buf
[1] + salt
.salt_buf_pc
[1],
8150 digest_buf
[2] + salt
.salt_buf_pc
[2],
8151 digest_buf
[3] + salt
.salt_buf_pc
[3],
8152 digest_buf
[4] + salt
.salt_buf_pc
[4],
8153 digest_buf
[5] + salt
.salt_buf_pc
[5],
8154 digest_buf
[6] + salt
.salt_buf_pc
[6],
8155 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8157 else if (hash_mode
== 12700)
8159 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8161 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8162 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8164 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8166 else if (hash_mode
== 12800)
8168 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8170 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",
8183 byte_swap_32 (digest_buf
[0]),
8184 byte_swap_32 (digest_buf
[1]),
8185 byte_swap_32 (digest_buf
[2]),
8186 byte_swap_32 (digest_buf
[3]),
8187 byte_swap_32 (digest_buf
[4]),
8188 byte_swap_32 (digest_buf
[5]),
8189 byte_swap_32 (digest_buf
[6]),
8190 byte_swap_32 (digest_buf
[7])
8193 else if (hash_mode
== 12900)
8195 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",
8204 byte_swap_32 (digest_buf
[0]),
8205 byte_swap_32 (digest_buf
[1]),
8206 byte_swap_32 (digest_buf
[2]),
8207 byte_swap_32 (digest_buf
[3]),
8208 byte_swap_32 (digest_buf
[4]),
8209 byte_swap_32 (digest_buf
[5]),
8210 byte_swap_32 (digest_buf
[6]),
8211 byte_swap_32 (digest_buf
[7]),
8218 else if (hash_mode
== 13000)
8220 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8222 rar5_t
*rar5
= &rar5s
[salt_pos
];
8224 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8234 byte_swap_32 (digest_buf
[0]),
8235 byte_swap_32 (digest_buf
[1])
8240 if (hash_type
== HASH_TYPE_MD4
)
8242 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8248 else if (hash_type
== HASH_TYPE_MD5
)
8250 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8256 else if (hash_type
== HASH_TYPE_SHA1
)
8258 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8265 else if (hash_type
== HASH_TYPE_SHA256
)
8267 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8277 else if (hash_type
== HASH_TYPE_SHA384
)
8279 uint
*ptr
= digest_buf
;
8281 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8289 else if (hash_type
== HASH_TYPE_SHA512
)
8291 uint
*ptr
= digest_buf
;
8293 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8303 else if (hash_type
== HASH_TYPE_LM
)
8305 snprintf (out_buf
, len
-1, "%08x%08x",
8309 else if (hash_type
== HASH_TYPE_ORACLEH
)
8311 snprintf (out_buf
, len
-1, "%08X%08X",
8315 else if (hash_type
== HASH_TYPE_BCRYPT
)
8317 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8318 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8320 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8322 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8324 else if (hash_type
== HASH_TYPE_KECCAK
)
8326 uint
*ptr
= digest_buf
;
8328 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",
8356 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8358 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8360 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8367 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8369 digest_buf
[ 0] = digest_buf
[ 0];
8370 digest_buf
[ 1] = digest_buf
[ 1];
8371 digest_buf
[ 2] = digest_buf
[ 2];
8372 digest_buf
[ 3] = digest_buf
[ 3];
8373 digest_buf
[ 4] = digest_buf
[ 4];
8374 digest_buf
[ 5] = digest_buf
[ 5];
8375 digest_buf
[ 6] = digest_buf
[ 6];
8376 digest_buf
[ 7] = digest_buf
[ 7];
8377 digest_buf
[ 8] = digest_buf
[ 8];
8378 digest_buf
[ 9] = digest_buf
[ 9];
8379 digest_buf
[10] = digest_buf
[10];
8380 digest_buf
[11] = digest_buf
[11];
8381 digest_buf
[12] = digest_buf
[12];
8382 digest_buf
[13] = digest_buf
[13];
8383 digest_buf
[14] = digest_buf
[14];
8384 digest_buf
[15] = digest_buf
[15];
8386 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8404 else if (hash_type
== HASH_TYPE_GOST
)
8406 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8416 else if (hash_type
== HASH_TYPE_MYSQL
)
8418 snprintf (out_buf
, len
-1, "%08x%08x",
8422 else if (hash_type
== HASH_TYPE_LOTUS5
)
8424 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8430 else if (hash_type
== HASH_TYPE_LOTUS6
)
8432 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8433 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8434 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8435 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8437 char buf
[16] = { 0 };
8439 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8440 memcpy (buf
+ 5, digest_buf
, 9);
8444 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8446 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8449 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8451 else if (hash_type
== HASH_TYPE_LOTUS8
)
8453 char buf
[52] = { 0 };
8457 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8463 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8467 buf
[26] = salt
.salt_buf_pc
[0];
8468 buf
[27] = salt
.salt_buf_pc
[1];
8472 memcpy (buf
+ 28, digest_buf
, 8);
8474 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8478 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8480 else if (hash_type
== HASH_TYPE_CRC32
)
8482 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8486 if (salt_type
== SALT_TYPE_INTERN
)
8488 size_t pos
= strlen (out_buf
);
8490 out_buf
[pos
] = data
.separator
;
8492 char *ptr
= (char *) salt
.salt_buf
;
8494 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8496 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8500 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8502 memset (hccap
, 0, sizeof (hccap_t
));
8504 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8506 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8508 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8509 wpa_t
*wpa
= &wpas
[salt_pos
];
8511 hccap
->keyver
= wpa
->keyver
;
8513 hccap
->eapol_size
= wpa
->eapol_size
;
8515 if (wpa
->keyver
!= 1)
8517 uint eapol_tmp
[64] = { 0 };
8519 for (uint i
= 0; i
< 64; i
++)
8521 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8524 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8528 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8531 uint pke_tmp
[25] = { 0 };
8533 for (int i
= 5; i
< 25; i
++)
8535 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8538 char *pke_ptr
= (char *) pke_tmp
;
8540 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8541 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8542 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8543 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8545 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8547 uint dgst_size
= data
.dgst_size
;
8549 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8551 if (wpa
->keyver
!= 1)
8553 uint digest_tmp
[4] = { 0 };
8555 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8556 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8557 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8558 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8560 memcpy (hccap
->keymic
, digest_tmp
, 16);
8564 memcpy (hccap
->keymic
, digest_ptr
, 16);
8568 void SuspendThreads ()
8570 if (data
.devices_status
== STATUS_RUNNING
)
8572 hc_timer_set (&data
.timer_paused
);
8574 data
.devices_status
= STATUS_PAUSED
;
8576 log_info ("Paused");
8580 void ResumeThreads ()
8582 if (data
.devices_status
== STATUS_PAUSED
)
8586 hc_timer_get (data
.timer_paused
, ms_paused
);
8588 data
.ms_paused
+= ms_paused
;
8590 data
.devices_status
= STATUS_RUNNING
;
8592 log_info ("Resumed");
8598 if (data
.devices_status
!= STATUS_RUNNING
) return;
8600 data
.devices_status
= STATUS_BYPASS
;
8602 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8605 void stop_at_checkpoint ()
8607 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8609 if (data
.devices_status
!= STATUS_RUNNING
) return;
8612 // this feature only makes sense if --restore-disable was not specified
8614 if (data
.restore_disable
== 1)
8616 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8621 // check if monitoring of Restore Point updates should be enabled or disabled
8623 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8625 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8627 // save the current restore point value
8629 data
.checkpoint_cur_words
= get_lowest_words_done ();
8631 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8635 data
.devices_status
= STATUS_RUNNING
;
8637 // reset the global value for checkpoint checks
8639 data
.checkpoint_cur_words
= 0;
8641 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8647 if (data
.devices_status
== STATUS_INIT
) return;
8648 if (data
.devices_status
== STATUS_STARTING
) return;
8650 data
.devices_status
= STATUS_ABORTED
;
8655 if (data
.devices_status
== STATUS_INIT
) return;
8656 if (data
.devices_status
== STATUS_STARTING
) return;
8658 data
.devices_status
= STATUS_QUIT
;
8661 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8663 FILE *fp
= fopen (kernel_file
, "rb");
8669 memset (&st
, 0, sizeof (st
));
8671 stat (kernel_file
, &st
);
8673 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8675 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8677 if (num_read
!= (size_t) st
.st_size
)
8679 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8686 buf
[st
.st_size
] = 0;
8688 for (int i
= 0; i
< num_devices
; i
++)
8690 kernel_lengths
[i
] = (size_t) st
.st_size
;
8692 kernel_sources
[i
] = buf
;
8697 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8705 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8707 if (binary_size
> 0)
8709 FILE *fp
= fopen (dst
, "wb");
8712 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8723 restore_data_t
*init_restore (int argc
, char **argv
)
8725 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8727 if (data
.restore_disable
== 0)
8729 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8733 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8737 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8746 char pidbin
[BUFSIZ
] = { 0 };
8748 int pidbin_len
= -1;
8751 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8753 FILE *fd
= fopen (pidbin
, "rb");
8757 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8759 pidbin
[pidbin_len
] = 0;
8763 char *argv0_r
= strrchr (argv
[0], '/');
8765 char *pidbin_r
= strrchr (pidbin
, '/');
8767 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8769 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8771 if (strcmp (argv0_r
, pidbin_r
) == 0)
8773 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8780 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8782 char pidbin2
[BUFSIZ
] = { 0 };
8784 int pidbin2_len
= -1;
8786 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8787 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8789 pidbin
[pidbin_len
] = 0;
8790 pidbin2
[pidbin2_len
] = 0;
8794 if (strcmp (pidbin
, pidbin2
) == 0)
8796 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8804 if (rd
->version_bin
< RESTORE_MIN
)
8806 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8813 memset (rd
, 0, sizeof (restore_data_t
));
8815 rd
->version_bin
= VERSION_BIN
;
8818 rd
->pid
= getpid ();
8820 rd
->pid
= GetCurrentProcessId ();
8823 if (getcwd (rd
->cwd
, 255) == NULL
)
8836 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8838 FILE *fp
= fopen (eff_restore_file
, "rb");
8842 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8847 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8849 log_error ("ERROR: cannot read %s", eff_restore_file
);
8854 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8856 for (uint i
= 0; i
< rd
->argc
; i
++)
8858 char buf
[BUFSIZ
] = { 0 };
8860 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8862 log_error ("ERROR: cannot read %s", eff_restore_file
);
8867 size_t len
= strlen (buf
);
8869 if (len
) buf
[len
- 1] = 0;
8871 rd
->argv
[i
] = mystrdup (buf
);
8876 char new_cwd
[1024] = { 0 };
8878 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8882 log_error ("Restore file is corrupted");
8885 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8887 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8889 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8894 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8897 if (chdir (rd
->cwd
))
8899 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8905 u64
get_lowest_words_done ()
8909 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8911 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8913 if (device_param
->skipped
) continue;
8915 const u64 words_done
= device_param
->words_done
;
8917 if (words_done
< words_cur
) words_cur
= words_done
;
8920 // It's possible that a device's workload isn't finished right after a restore-case.
8921 // In that case, this function would return 0 and overwrite the real restore point
8922 // There's also data.words_cur which is set to rd->words_cur but it changes while
8923 // the attack is running therefore we should stick to rd->words_cur.
8924 // Note that -s influences rd->words_cur we should keep a close look on that.
8926 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8931 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8933 u64 words_cur
= get_lowest_words_done ();
8935 rd
->words_cur
= words_cur
;
8937 FILE *fp
= fopen (new_restore_file
, "wb");
8941 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8946 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8948 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8953 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8955 for (uint i
= 0; i
< rd
->argc
; i
++)
8957 fprintf (fp
, "%s", rd
->argv
[i
]);
8963 fsync (fileno (fp
));
8968 void cycle_restore ()
8970 const char *eff_restore_file
= data
.eff_restore_file
;
8971 const char *new_restore_file
= data
.new_restore_file
;
8973 restore_data_t
*rd
= data
.rd
;
8975 write_restore (new_restore_file
, rd
);
8979 memset (&st
, 0, sizeof(st
));
8981 if (stat (eff_restore_file
, &st
) == 0)
8983 if (unlink (eff_restore_file
))
8985 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8989 if (rename (new_restore_file
, eff_restore_file
))
8991 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8995 void check_checkpoint ()
8997 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8999 u64 words_cur
= get_lowest_words_done ();
9001 if (words_cur
!= data
.checkpoint_cur_words
)
9011 uint
set_kernel_accel (uint hash_mode
)
9015 case 0: return GET_ACCEL (0);
9016 case 10: return GET_ACCEL (10);
9017 case 11: return GET_ACCEL (11);
9018 case 12: return GET_ACCEL (12);
9019 case 20: return GET_ACCEL (20);
9020 case 21: return GET_ACCEL (21);
9021 case 22: return GET_ACCEL (22);
9022 case 23: return GET_ACCEL (23);
9023 case 30: return GET_ACCEL (30);
9024 case 40: return GET_ACCEL (40);
9025 case 50: return GET_ACCEL (50);
9026 case 60: return GET_ACCEL (60);
9027 case 100: return GET_ACCEL (100);
9028 case 101: return GET_ACCEL (101);
9029 case 110: return GET_ACCEL (110);
9030 case 111: return GET_ACCEL (111);
9031 case 112: return GET_ACCEL (112);
9032 case 120: return GET_ACCEL (120);
9033 case 121: return GET_ACCEL (121);
9034 case 122: return GET_ACCEL (122);
9035 case 124: return GET_ACCEL (124);
9036 case 130: return GET_ACCEL (130);
9037 case 131: return GET_ACCEL (131);
9038 case 132: return GET_ACCEL (132);
9039 case 133: return GET_ACCEL (133);
9040 case 140: return GET_ACCEL (140);
9041 case 141: return GET_ACCEL (141);
9042 case 150: return GET_ACCEL (150);
9043 case 160: return GET_ACCEL (160);
9044 case 190: return GET_ACCEL (190);
9045 case 200: return GET_ACCEL (200);
9046 case 300: return GET_ACCEL (300);
9047 case 400: return GET_ACCEL (400);
9048 case 500: return GET_ACCEL (500);
9049 case 501: return GET_ACCEL (501);
9050 case 900: return GET_ACCEL (900);
9051 case 910: return GET_ACCEL (910);
9052 case 1000: return GET_ACCEL (1000);
9053 case 1100: return GET_ACCEL (1100);
9054 case 1400: return GET_ACCEL (1400);
9055 case 1410: return GET_ACCEL (1410);
9056 case 1420: return GET_ACCEL (1420);
9057 case 1421: return GET_ACCEL (1421);
9058 case 1430: return GET_ACCEL (1430);
9059 case 1440: return GET_ACCEL (1440);
9060 case 1441: return GET_ACCEL (1441);
9061 case 1450: return GET_ACCEL (1450);
9062 case 1460: return GET_ACCEL (1460);
9063 case 1500: return GET_ACCEL (1500);
9064 case 1600: return GET_ACCEL (1600);
9065 case 1700: return GET_ACCEL (1700);
9066 case 1710: return GET_ACCEL (1710);
9067 case 1711: return GET_ACCEL (1711);
9068 case 1720: return GET_ACCEL (1720);
9069 case 1722: return GET_ACCEL (1722);
9070 case 1730: return GET_ACCEL (1730);
9071 case 1731: return GET_ACCEL (1731);
9072 case 1740: return GET_ACCEL (1740);
9073 case 1750: return GET_ACCEL (1750);
9074 case 1760: return GET_ACCEL (1760);
9075 case 1800: return GET_ACCEL (1800);
9076 case 2100: return GET_ACCEL (2100);
9077 case 2400: return GET_ACCEL (2400);
9078 case 2410: return GET_ACCEL (2410);
9079 case 2500: return GET_ACCEL (2500);
9080 case 2600: return GET_ACCEL (2600);
9081 case 2611: return GET_ACCEL (2611);
9082 case 2612: return GET_ACCEL (2612);
9083 case 2711: return GET_ACCEL (2711);
9084 case 2811: return GET_ACCEL (2811);
9085 case 3000: return GET_ACCEL (3000);
9086 case 3100: return GET_ACCEL (3100);
9087 case 3200: return GET_ACCEL (3200);
9088 case 3710: return GET_ACCEL (3710);
9089 case 3711: return GET_ACCEL (3711);
9090 case 3800: return GET_ACCEL (3800);
9091 case 4300: return GET_ACCEL (4300);
9092 case 4400: return GET_ACCEL (4400);
9093 case 4500: return GET_ACCEL (4500);
9094 case 4700: return GET_ACCEL (4700);
9095 case 4800: return GET_ACCEL (4800);
9096 case 4900: return GET_ACCEL (4900);
9097 case 5000: return GET_ACCEL (5000);
9098 case 5100: return GET_ACCEL (5100);
9099 case 5200: return GET_ACCEL (5200);
9100 case 5300: return GET_ACCEL (5300);
9101 case 5400: return GET_ACCEL (5400);
9102 case 5500: return GET_ACCEL (5500);
9103 case 5600: return GET_ACCEL (5600);
9104 case 5700: return GET_ACCEL (5700);
9105 case 5800: return GET_ACCEL (5800);
9106 case 6000: return GET_ACCEL (6000);
9107 case 6100: return GET_ACCEL (6100);
9108 case 6211: return GET_ACCEL (6211);
9109 case 6212: return GET_ACCEL (6212);
9110 case 6213: return GET_ACCEL (6213);
9111 case 6221: return GET_ACCEL (6221);
9112 case 6222: return GET_ACCEL (6222);
9113 case 6223: return GET_ACCEL (6223);
9114 case 6231: return GET_ACCEL (6231);
9115 case 6232: return GET_ACCEL (6232);
9116 case 6233: return GET_ACCEL (6233);
9117 case 6241: return GET_ACCEL (6241);
9118 case 6242: return GET_ACCEL (6242);
9119 case 6243: return GET_ACCEL (6243);
9120 case 6300: return GET_ACCEL (6300);
9121 case 6400: return GET_ACCEL (6400);
9122 case 6500: return GET_ACCEL (6500);
9123 case 6600: return GET_ACCEL (6600);
9124 case 6700: return GET_ACCEL (6700);
9125 case 6800: return GET_ACCEL (6800);
9126 case 6900: return GET_ACCEL (6900);
9127 case 7100: return GET_ACCEL (7100);
9128 case 7200: return GET_ACCEL (7200);
9129 case 7300: return GET_ACCEL (7300);
9130 case 7400: return GET_ACCEL (7400);
9131 case 7500: return GET_ACCEL (7500);
9132 case 7600: return GET_ACCEL (7600);
9133 case 7700: return GET_ACCEL (7700);
9134 case 7800: return GET_ACCEL (7800);
9135 case 7900: return GET_ACCEL (7900);
9136 case 8000: return GET_ACCEL (8000);
9137 case 8100: return GET_ACCEL (8100);
9138 case 8200: return GET_ACCEL (8200);
9139 case 8300: return GET_ACCEL (8300);
9140 case 8400: return GET_ACCEL (8400);
9141 case 8500: return GET_ACCEL (8500);
9142 case 8600: return GET_ACCEL (8600);
9143 case 8700: return GET_ACCEL (8700);
9144 case 8800: return GET_ACCEL (8800);
9145 case 8900: return GET_ACCEL (8900);
9146 case 9000: return GET_ACCEL (9000);
9147 case 9100: return GET_ACCEL (9100);
9148 case 9200: return GET_ACCEL (9200);
9149 case 9300: return GET_ACCEL (9300);
9150 case 9400: return GET_ACCEL (9400);
9151 case 9500: return GET_ACCEL (9500);
9152 case 9600: return GET_ACCEL (9600);
9153 case 9700: return GET_ACCEL (9700);
9154 case 9710: return GET_ACCEL (9710);
9155 case 9720: return GET_ACCEL (9720);
9156 case 9800: return GET_ACCEL (9800);
9157 case 9810: return GET_ACCEL (9810);
9158 case 9820: return GET_ACCEL (9820);
9159 case 9900: return GET_ACCEL (9900);
9160 case 10000: return GET_ACCEL (10000);
9161 case 10100: return GET_ACCEL (10100);
9162 case 10200: return GET_ACCEL (10200);
9163 case 10300: return GET_ACCEL (10300);
9164 case 10400: return GET_ACCEL (10400);
9165 case 10410: return GET_ACCEL (10410);
9166 case 10420: return GET_ACCEL (10420);
9167 case 10500: return GET_ACCEL (10500);
9168 case 10600: return GET_ACCEL (10600);
9169 case 10700: return GET_ACCEL (10700);
9170 case 10800: return GET_ACCEL (10800);
9171 case 10900: return GET_ACCEL (10900);
9172 case 11000: return GET_ACCEL (11000);
9173 case 11100: return GET_ACCEL (11100);
9174 case 11200: return GET_ACCEL (11200);
9175 case 11300: return GET_ACCEL (11300);
9176 case 11400: return GET_ACCEL (11400);
9177 case 11500: return GET_ACCEL (11500);
9178 case 11600: return GET_ACCEL (11600);
9179 case 11700: return GET_ACCEL (11700);
9180 case 11800: return GET_ACCEL (11800);
9181 case 11900: return GET_ACCEL (11900);
9182 case 12000: return GET_ACCEL (12000);
9183 case 12100: return GET_ACCEL (12100);
9184 case 12200: return GET_ACCEL (12200);
9185 case 12300: return GET_ACCEL (12300);
9186 case 12400: return GET_ACCEL (12400);
9187 case 12500: return GET_ACCEL (12500);
9188 case 12600: return GET_ACCEL (12600);
9189 case 12700: return GET_ACCEL (12700);
9190 case 12800: return GET_ACCEL (12800);
9191 case 12900: return GET_ACCEL (12900);
9192 case 13000: return GET_ACCEL (13000);
9198 uint
set_kernel_loops (uint hash_mode
)
9202 case 0: return GET_LOOPS (0);
9203 case 10: return GET_LOOPS (10);
9204 case 11: return GET_LOOPS (11);
9205 case 12: return GET_LOOPS (12);
9206 case 20: return GET_LOOPS (20);
9207 case 21: return GET_LOOPS (21);
9208 case 22: return GET_LOOPS (22);
9209 case 23: return GET_LOOPS (23);
9210 case 30: return GET_LOOPS (30);
9211 case 40: return GET_LOOPS (40);
9212 case 50: return GET_LOOPS (50);
9213 case 60: return GET_LOOPS (60);
9214 case 100: return GET_LOOPS (100);
9215 case 101: return GET_LOOPS (101);
9216 case 110: return GET_LOOPS (110);
9217 case 111: return GET_LOOPS (111);
9218 case 112: return GET_LOOPS (112);
9219 case 120: return GET_LOOPS (120);
9220 case 121: return GET_LOOPS (121);
9221 case 122: return GET_LOOPS (122);
9222 case 124: return GET_LOOPS (124);
9223 case 130: return GET_LOOPS (130);
9224 case 131: return GET_LOOPS (131);
9225 case 132: return GET_LOOPS (132);
9226 case 133: return GET_LOOPS (133);
9227 case 140: return GET_LOOPS (140);
9228 case 141: return GET_LOOPS (141);
9229 case 150: return GET_LOOPS (150);
9230 case 160: return GET_LOOPS (160);
9231 case 190: return GET_LOOPS (190);
9232 case 200: return GET_LOOPS (200);
9233 case 300: return GET_LOOPS (300);
9234 case 400: return GET_LOOPS (400);
9235 case 500: return GET_LOOPS (500);
9236 case 501: return GET_LOOPS (501);
9237 case 900: return GET_LOOPS (900);
9238 case 910: return GET_LOOPS (910);
9239 case 1000: return GET_LOOPS (1000);
9240 case 1100: return GET_LOOPS (1100);
9241 case 1400: return GET_LOOPS (1400);
9242 case 1410: return GET_LOOPS (1410);
9243 case 1420: return GET_LOOPS (1420);
9244 case 1421: return GET_LOOPS (1421);
9245 case 1430: return GET_LOOPS (1430);
9246 case 1440: return GET_LOOPS (1440);
9247 case 1441: return GET_LOOPS (1441);
9248 case 1450: return GET_LOOPS (1450);
9249 case 1460: return GET_LOOPS (1460);
9250 case 1500: return GET_LOOPS (1500);
9251 case 1600: return GET_LOOPS (1600);
9252 case 1700: return GET_LOOPS (1700);
9253 case 1710: return GET_LOOPS (1710);
9254 case 1711: return GET_LOOPS (1711);
9255 case 1720: return GET_LOOPS (1720);
9256 case 1722: return GET_LOOPS (1722);
9257 case 1730: return GET_LOOPS (1730);
9258 case 1731: return GET_LOOPS (1731);
9259 case 1740: return GET_LOOPS (1740);
9260 case 1750: return GET_LOOPS (1750);
9261 case 1760: return GET_LOOPS (1760);
9262 case 1800: return GET_LOOPS (1800);
9263 case 2100: return GET_LOOPS (2100);
9264 case 2400: return GET_LOOPS (2400);
9265 case 2410: return GET_LOOPS (2410);
9266 case 2500: return GET_LOOPS (2500);
9267 case 2600: return GET_LOOPS (2600);
9268 case 2611: return GET_LOOPS (2611);
9269 case 2612: return GET_LOOPS (2612);
9270 case 2711: return GET_LOOPS (2711);
9271 case 2811: return GET_LOOPS (2811);
9272 case 3000: return GET_LOOPS (3000);
9273 case 3100: return GET_LOOPS (3100);
9274 case 3200: return GET_LOOPS (3200);
9275 case 3710: return GET_LOOPS (3710);
9276 case 3711: return GET_LOOPS (3711);
9277 case 3800: return GET_LOOPS (3800);
9278 case 4300: return GET_LOOPS (4300);
9279 case 4400: return GET_LOOPS (4400);
9280 case 4500: return GET_LOOPS (4500);
9281 case 4700: return GET_LOOPS (4700);
9282 case 4800: return GET_LOOPS (4800);
9283 case 4900: return GET_LOOPS (4900);
9284 case 5000: return GET_LOOPS (5000);
9285 case 5100: return GET_LOOPS (5100);
9286 case 5200: return GET_LOOPS (5200);
9287 case 5300: return GET_LOOPS (5300);
9288 case 5400: return GET_LOOPS (5400);
9289 case 5500: return GET_LOOPS (5500);
9290 case 5600: return GET_LOOPS (5600);
9291 case 5700: return GET_LOOPS (5700);
9292 case 5800: return GET_LOOPS (5800);
9293 case 6000: return GET_LOOPS (6000);
9294 case 6100: return GET_LOOPS (6100);
9295 case 6211: return GET_LOOPS (6211);
9296 case 6212: return GET_LOOPS (6212);
9297 case 6213: return GET_LOOPS (6213);
9298 case 6221: return GET_LOOPS (6221);
9299 case 6222: return GET_LOOPS (6222);
9300 case 6223: return GET_LOOPS (6223);
9301 case 6231: return GET_LOOPS (6231);
9302 case 6232: return GET_LOOPS (6232);
9303 case 6233: return GET_LOOPS (6233);
9304 case 6241: return GET_LOOPS (6241);
9305 case 6242: return GET_LOOPS (6242);
9306 case 6243: return GET_LOOPS (6243);
9307 case 6300: return GET_LOOPS (6300);
9308 case 6400: return GET_LOOPS (6400);
9309 case 6500: return GET_LOOPS (6500);
9310 case 6600: return GET_LOOPS (6600);
9311 case 6700: return GET_LOOPS (6700);
9312 case 6800: return GET_LOOPS (6800);
9313 case 6900: return GET_LOOPS (6900);
9314 case 7100: return GET_LOOPS (7100);
9315 case 7200: return GET_LOOPS (7200);
9316 case 7300: return GET_LOOPS (7300);
9317 case 7400: return GET_LOOPS (7400);
9318 case 7500: return GET_LOOPS (7500);
9319 case 7600: return GET_LOOPS (7600);
9320 case 7700: return GET_LOOPS (7700);
9321 case 7800: return GET_LOOPS (7800);
9322 case 7900: return GET_LOOPS (7900);
9323 case 8000: return GET_LOOPS (8000);
9324 case 8100: return GET_LOOPS (8100);
9325 case 8200: return GET_LOOPS (8200);
9326 case 8300: return GET_LOOPS (8300);
9327 case 8400: return GET_LOOPS (8400);
9328 case 8500: return GET_LOOPS (8500);
9329 case 8600: return GET_LOOPS (8600);
9330 case 8700: return GET_LOOPS (8700);
9331 case 8800: return GET_LOOPS (8800);
9332 case 8900: return GET_LOOPS (8900);
9333 case 9000: return GET_LOOPS (9000);
9334 case 9100: return GET_LOOPS (9100);
9335 case 9200: return GET_LOOPS (9200);
9336 case 9300: return GET_LOOPS (9300);
9337 case 9400: return GET_LOOPS (9400);
9338 case 9500: return GET_LOOPS (9500);
9339 case 9600: return GET_LOOPS (9600);
9340 case 9700: return GET_LOOPS (9700);
9341 case 9710: return GET_LOOPS (9710);
9342 case 9720: return GET_LOOPS (9720);
9343 case 9800: return GET_LOOPS (9800);
9344 case 9810: return GET_LOOPS (9810);
9345 case 9820: return GET_LOOPS (9820);
9346 case 9900: return GET_LOOPS (9900);
9347 case 10000: return GET_LOOPS (10000);
9348 case 10100: return GET_LOOPS (10100);
9349 case 10200: return GET_LOOPS (10200);
9350 case 10300: return GET_LOOPS (10300);
9351 case 10400: return GET_LOOPS (10400);
9352 case 10410: return GET_LOOPS (10410);
9353 case 10420: return GET_LOOPS (10420);
9354 case 10500: return GET_LOOPS (10500);
9355 case 10600: return GET_LOOPS (10600);
9356 case 10700: return GET_LOOPS (10700);
9357 case 10800: return GET_LOOPS (10800);
9358 case 10900: return GET_LOOPS (10900);
9359 case 11000: return GET_LOOPS (11000);
9360 case 11100: return GET_LOOPS (11100);
9361 case 11200: return GET_LOOPS (11200);
9362 case 11300: return GET_LOOPS (11300);
9363 case 11400: return GET_LOOPS (11400);
9364 case 11500: return GET_LOOPS (11500);
9365 case 11600: return GET_LOOPS (11600);
9366 case 11700: return GET_LOOPS (11700);
9367 case 11800: return GET_LOOPS (11800);
9368 case 11900: return GET_LOOPS (11900);
9369 case 12000: return GET_LOOPS (12000);
9370 case 12100: return GET_LOOPS (12100);
9371 case 12200: return GET_LOOPS (12200);
9372 case 12300: return GET_LOOPS (12300);
9373 case 12400: return GET_LOOPS (12400);
9374 case 12500: return GET_LOOPS (12500);
9375 case 12600: return GET_LOOPS (12600);
9376 case 12700: return GET_LOOPS (12700);
9377 case 12800: return GET_LOOPS (12800);
9378 case 12900: return GET_LOOPS (12900);
9379 case 13000: return GET_LOOPS (13000);
9389 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9391 u8 tmp
[256] = { 0 };
9393 if (salt_len
> sizeof (tmp
))
9398 memcpy (tmp
, in
, salt_len
);
9400 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9402 if ((salt_len
% 2) == 0)
9404 u32 new_salt_len
= salt_len
/ 2;
9406 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9411 tmp
[i
] = hex_convert (p1
) << 0;
9412 tmp
[i
] |= hex_convert (p0
) << 4;
9415 salt_len
= new_salt_len
;
9422 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9424 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9427 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9429 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9433 u32
*tmp_uint
= (u32
*) tmp
;
9435 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9436 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9437 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9438 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9439 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9440 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9441 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9442 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9443 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9444 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9446 salt_len
= salt_len
* 2;
9454 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9456 lowercase (tmp
, salt_len
);
9459 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9461 uppercase (tmp
, salt_len
);
9466 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9471 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9476 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9478 u32
*tmp_uint
= (uint
*) tmp
;
9484 for (u32 i
= 0; i
< max
; i
++)
9486 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9489 // Important: we may need to increase the length of memcpy since
9490 // we don't want to "loose" some swapped bytes (could happen if
9491 // they do not perfectly fit in the 4-byte blocks)
9492 // Memcpy does always copy the bytes in the BE order, but since
9493 // we swapped them, some important bytes could be in positions
9494 // we normally skip with the original len
9496 if (len
% 4) len
+= 4 - (len
% 4);
9499 memcpy (out
, tmp
, len
);
9504 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9506 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9508 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9510 u32
*digest
= (u32
*) hash_buf
->digest
;
9512 salt_t
*salt
= hash_buf
->salt
;
9514 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9516 char *iter_pos
= input_buf
+ 4;
9518 salt
->salt_iter
= 1 << atoi (iter_pos
);
9520 char *salt_pos
= strchr (iter_pos
, '$');
9522 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9528 salt
->salt_len
= salt_len
;
9530 u8 tmp_buf
[100] = { 0 };
9532 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9534 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9536 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9538 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9539 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9540 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9541 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9543 char *hash_pos
= salt_pos
+ 22;
9545 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9547 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9549 memcpy (digest
, tmp_buf
, 24);
9551 digest
[0] = byte_swap_32 (digest
[0]);
9552 digest
[1] = byte_swap_32 (digest
[1]);
9553 digest
[2] = byte_swap_32 (digest
[2]);
9554 digest
[3] = byte_swap_32 (digest
[3]);
9555 digest
[4] = byte_swap_32 (digest
[4]);
9556 digest
[5] = byte_swap_32 (digest
[5]);
9558 digest
[5] &= ~0xff; // its just 23 not 24 !
9563 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9565 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9567 u32
*digest
= (u32
*) hash_buf
->digest
;
9569 u8 tmp_buf
[100] = { 0 };
9571 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9573 memcpy (digest
, tmp_buf
, 32);
9575 digest
[0] = byte_swap_32 (digest
[0]);
9576 digest
[1] = byte_swap_32 (digest
[1]);
9577 digest
[2] = byte_swap_32 (digest
[2]);
9578 digest
[3] = byte_swap_32 (digest
[3]);
9579 digest
[4] = byte_swap_32 (digest
[4]);
9580 digest
[5] = byte_swap_32 (digest
[5]);
9581 digest
[6] = byte_swap_32 (digest
[6]);
9582 digest
[7] = byte_swap_32 (digest
[7]);
9584 digest
[0] -= SHA256M_A
;
9585 digest
[1] -= SHA256M_B
;
9586 digest
[2] -= SHA256M_C
;
9587 digest
[3] -= SHA256M_D
;
9588 digest
[4] -= SHA256M_E
;
9589 digest
[5] -= SHA256M_F
;
9590 digest
[6] -= SHA256M_G
;
9591 digest
[7] -= SHA256M_H
;
9596 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9598 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9600 u32
*digest
= (u32
*) hash_buf
->digest
;
9602 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9603 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9605 digest
[0] = byte_swap_32 (digest
[0]);
9606 digest
[1] = byte_swap_32 (digest
[1]);
9610 IP (digest
[0], digest
[1], tt
);
9612 digest
[0] = digest
[0];
9613 digest
[1] = digest
[1];
9620 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9622 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9624 u32
*digest
= (u32
*) hash_buf
->digest
;
9626 salt_t
*salt
= hash_buf
->salt
;
9628 char *hash_pos
= input_buf
+ 8;
9630 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9631 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9632 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9633 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9634 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9636 digest
[0] -= SHA1M_A
;
9637 digest
[1] -= SHA1M_B
;
9638 digest
[2] -= SHA1M_C
;
9639 digest
[3] -= SHA1M_D
;
9640 digest
[4] -= SHA1M_E
;
9644 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9646 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9648 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9650 salt
->salt_len
= salt_len
;
9655 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9657 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9659 u64
*digest
= (u64
*) hash_buf
->digest
;
9661 salt_t
*salt
= hash_buf
->salt
;
9663 char *hash_pos
= input_buf
+ 8;
9665 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9666 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9667 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9668 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9669 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9670 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9671 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9672 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9674 digest
[0] -= SHA512M_A
;
9675 digest
[1] -= SHA512M_B
;
9676 digest
[2] -= SHA512M_C
;
9677 digest
[3] -= SHA512M_D
;
9678 digest
[4] -= SHA512M_E
;
9679 digest
[5] -= SHA512M_F
;
9680 digest
[6] -= SHA512M_G
;
9681 digest
[7] -= SHA512M_H
;
9685 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9687 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9689 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9691 salt
->salt_len
= salt_len
;
9696 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9698 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9700 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9704 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9707 u32
*digest
= (u32
*) hash_buf
->digest
;
9709 salt_t
*salt
= hash_buf
->salt
;
9711 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9712 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9713 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9714 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9716 digest
[0] = byte_swap_32 (digest
[0]);
9717 digest
[1] = byte_swap_32 (digest
[1]);
9718 digest
[2] = byte_swap_32 (digest
[2]);
9719 digest
[3] = byte_swap_32 (digest
[3]);
9721 digest
[0] -= MD5M_A
;
9722 digest
[1] -= MD5M_B
;
9723 digest
[2] -= MD5M_C
;
9724 digest
[3] -= MD5M_D
;
9726 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9728 uint salt_len
= input_len
- 32 - 1;
9730 char *salt_buf
= input_buf
+ 32 + 1;
9732 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9734 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9736 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9738 salt
->salt_len
= salt_len
;
9743 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9745 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9747 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9751 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9756 char clean_input_buf
[32] = { 0 };
9758 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9759 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9761 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9765 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9771 clean_input_buf
[k
] = input_buf
[i
];
9779 u32
*digest
= (u32
*) hash_buf
->digest
;
9781 salt_t
*salt
= hash_buf
->salt
;
9783 u32 a
, b
, c
, d
, e
, f
;
9785 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9786 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9787 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9788 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9789 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9790 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9792 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9793 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9795 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9796 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9797 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9798 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9799 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9800 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9802 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9803 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9805 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9806 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9807 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9808 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9809 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9810 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9812 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9813 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9815 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9816 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9817 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9818 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9819 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9820 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9822 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9823 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9825 digest
[0] = byte_swap_32 (digest
[0]);
9826 digest
[1] = byte_swap_32 (digest
[1]);
9827 digest
[2] = byte_swap_32 (digest
[2]);
9828 digest
[3] = byte_swap_32 (digest
[3]);
9830 digest
[0] -= MD5M_A
;
9831 digest
[1] -= MD5M_B
;
9832 digest
[2] -= MD5M_C
;
9833 digest
[3] -= MD5M_D
;
9835 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9837 uint salt_len
= input_len
- 30 - 1;
9839 char *salt_buf
= input_buf
+ 30 + 1;
9841 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9843 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9845 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9846 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9848 salt
->salt_len
= salt_len
;
9850 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9852 salt
->salt_len
+= 22;
9857 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9859 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9861 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9865 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9868 u32
*digest
= (u32
*) hash_buf
->digest
;
9870 salt_t
*salt
= hash_buf
->salt
;
9872 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9873 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9874 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9875 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9876 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9878 digest
[0] -= SHA1M_A
;
9879 digest
[1] -= SHA1M_B
;
9880 digest
[2] -= SHA1M_C
;
9881 digest
[3] -= SHA1M_D
;
9882 digest
[4] -= SHA1M_E
;
9884 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9886 uint salt_len
= input_len
- 40 - 1;
9888 char *salt_buf
= input_buf
+ 40 + 1;
9890 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9892 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9894 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9896 salt
->salt_len
= salt_len
;
9901 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9903 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9905 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9909 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9912 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9914 char *iter_pos
= input_buf
+ 6;
9916 salt_t
*salt
= hash_buf
->salt
;
9918 uint iter
= atoi (iter_pos
);
9925 salt
->salt_iter
= iter
- 1;
9927 char *salt_pos
= strchr (iter_pos
, '#');
9929 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9933 char *digest_pos
= strchr (salt_pos
, '#');
9935 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9939 uint salt_len
= digest_pos
- salt_pos
- 1;
9941 u32
*digest
= (u32
*) hash_buf
->digest
;
9943 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9944 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9945 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9946 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9948 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9950 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9952 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9954 salt
->salt_len
= salt_len
;
9959 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9961 u32
*digest
= (u32
*) hash_buf
->digest
;
9963 salt_t
*salt
= hash_buf
->salt
;
9965 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9969 memcpy (&in
, input_buf
, input_len
);
9971 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9973 memcpy (digest
, in
.keymic
, 16);
9976 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9977 The phrase "Pairwise key expansion"
9978 Access Point Address (referred to as Authenticator Address AA)
9979 Supplicant Address (referred to as Supplicant Address SA)
9980 Access Point Nonce (referred to as Authenticator Anonce)
9981 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9984 uint salt_len
= strlen (in
.essid
);
9986 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9988 salt
->salt_len
= salt_len
;
9990 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9992 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9994 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9996 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9998 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9999 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10003 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10004 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10007 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10009 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10010 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10014 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10015 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10018 for (int i
= 0; i
< 25; i
++)
10020 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10023 wpa
->keyver
= in
.keyver
;
10025 if (wpa
->keyver
> 255)
10027 log_info ("ATTENTION!");
10028 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10029 log_info (" This could be due to a recent aircrack-ng bug.");
10030 log_info (" The key version was automatically reset to a reasonable value.");
10033 wpa
->keyver
&= 0xff;
10036 wpa
->eapol_size
= in
.eapol_size
;
10038 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10040 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10042 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10044 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10046 if (wpa
->keyver
== 1)
10052 digest
[0] = byte_swap_32 (digest
[0]);
10053 digest
[1] = byte_swap_32 (digest
[1]);
10054 digest
[2] = byte_swap_32 (digest
[2]);
10055 digest
[3] = byte_swap_32 (digest
[3]);
10057 for (int i
= 0; i
< 64; i
++)
10059 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10063 salt
->salt_buf
[10] = digest
[1];
10064 salt
->salt_buf
[11] = digest
[2];
10066 return (PARSER_OK
);
10069 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10071 u32
*digest
= (u32
*) hash_buf
->digest
;
10073 salt_t
*salt
= hash_buf
->salt
;
10075 if (input_len
== 0)
10077 log_error ("Password Safe v2 container not specified");
10082 FILE *fp
= fopen (input_buf
, "rb");
10086 log_error ("%s: %s", input_buf
, strerror (errno
));
10093 memset (&buf
, 0, sizeof (psafe2_hdr
));
10095 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10099 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10101 salt
->salt_buf
[0] = buf
.random
[0];
10102 salt
->salt_buf
[1] = buf
.random
[1];
10104 salt
->salt_len
= 8;
10105 salt
->salt_iter
= 1000;
10107 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10108 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10109 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10110 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10111 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10113 return (PARSER_OK
);
10116 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10118 u32
*digest
= (u32
*) hash_buf
->digest
;
10120 salt_t
*salt
= hash_buf
->salt
;
10122 if (input_len
== 0)
10124 log_error (".psafe3 not specified");
10129 FILE *fp
= fopen (input_buf
, "rb");
10133 log_error ("%s: %s", input_buf
, strerror (errno
));
10140 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10144 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10146 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10148 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10150 salt
->salt_iter
= in
.iterations
+ 1;
10152 salt
->salt_buf
[0] = in
.salt_buf
[0];
10153 salt
->salt_buf
[1] = in
.salt_buf
[1];
10154 salt
->salt_buf
[2] = in
.salt_buf
[2];
10155 salt
->salt_buf
[3] = in
.salt_buf
[3];
10156 salt
->salt_buf
[4] = in
.salt_buf
[4];
10157 salt
->salt_buf
[5] = in
.salt_buf
[5];
10158 salt
->salt_buf
[6] = in
.salt_buf
[6];
10159 salt
->salt_buf
[7] = in
.salt_buf
[7];
10161 salt
->salt_len
= 32;
10163 digest
[0] = in
.hash_buf
[0];
10164 digest
[1] = in
.hash_buf
[1];
10165 digest
[2] = in
.hash_buf
[2];
10166 digest
[3] = in
.hash_buf
[3];
10167 digest
[4] = in
.hash_buf
[4];
10168 digest
[5] = in
.hash_buf
[5];
10169 digest
[6] = in
.hash_buf
[6];
10170 digest
[7] = in
.hash_buf
[7];
10172 digest
[0] = byte_swap_32 (digest
[0]);
10173 digest
[1] = byte_swap_32 (digest
[1]);
10174 digest
[2] = byte_swap_32 (digest
[2]);
10175 digest
[3] = byte_swap_32 (digest
[3]);
10176 digest
[4] = byte_swap_32 (digest
[4]);
10177 digest
[5] = byte_swap_32 (digest
[5]);
10178 digest
[6] = byte_swap_32 (digest
[6]);
10179 digest
[7] = byte_swap_32 (digest
[7]);
10181 return (PARSER_OK
);
10184 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10186 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10188 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10190 u32
*digest
= (u32
*) hash_buf
->digest
;
10192 salt_t
*salt
= hash_buf
->salt
;
10194 char *iter_pos
= input_buf
+ 3;
10196 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10198 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10200 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10202 salt
->salt_iter
= salt_iter
;
10204 char *salt_pos
= iter_pos
+ 1;
10208 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10210 salt
->salt_len
= salt_len
;
10212 char *hash_pos
= salt_pos
+ salt_len
;
10214 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10216 return (PARSER_OK
);
10219 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10221 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10223 u32
*digest
= (u32
*) hash_buf
->digest
;
10225 salt_t
*salt
= hash_buf
->salt
;
10227 char *salt_pos
= input_buf
+ 3;
10229 uint iterations_len
= 0;
10231 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10235 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10237 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10238 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10242 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10246 iterations_len
+= 8;
10250 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10253 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10255 char *hash_pos
= strchr (salt_pos
, '$');
10257 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10259 uint salt_len
= hash_pos
- salt_pos
;
10261 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10263 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10265 salt
->salt_len
= salt_len
;
10269 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10271 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10273 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10275 return (PARSER_OK
);
10278 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10280 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10282 u32
*digest
= (u32
*) hash_buf
->digest
;
10284 salt_t
*salt
= hash_buf
->salt
;
10286 char *salt_pos
= input_buf
+ 6;
10288 uint iterations_len
= 0;
10290 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10294 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10296 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10297 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10301 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10305 iterations_len
+= 8;
10309 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10312 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10314 char *hash_pos
= strchr (salt_pos
, '$');
10316 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10318 uint salt_len
= hash_pos
- salt_pos
;
10320 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10322 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10324 salt
->salt_len
= salt_len
;
10328 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10330 return (PARSER_OK
);
10333 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10335 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10337 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10339 u32
*digest
= (u32
*) hash_buf
->digest
;
10341 salt_t
*salt
= hash_buf
->salt
;
10343 char *salt_pos
= input_buf
+ 14;
10345 char *hash_pos
= strchr (salt_pos
, '*');
10347 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10351 uint salt_len
= hash_pos
- salt_pos
- 1;
10353 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10355 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10357 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10359 salt
->salt_len
= salt_len
;
10361 u8 tmp_buf
[100] = { 0 };
10363 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10365 memcpy (digest
, tmp_buf
, 20);
10367 digest
[0] = byte_swap_32 (digest
[0]);
10368 digest
[1] = byte_swap_32 (digest
[1]);
10369 digest
[2] = byte_swap_32 (digest
[2]);
10370 digest
[3] = byte_swap_32 (digest
[3]);
10371 digest
[4] = byte_swap_32 (digest
[4]);
10373 digest
[0] -= SHA1M_A
;
10374 digest
[1] -= SHA1M_B
;
10375 digest
[2] -= SHA1M_C
;
10376 digest
[3] -= SHA1M_D
;
10377 digest
[4] -= SHA1M_E
;
10379 return (PARSER_OK
);
10382 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10384 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10386 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10388 if (c12
& 3) return (PARSER_HASH_VALUE
);
10390 u32
*digest
= (u32
*) hash_buf
->digest
;
10392 salt_t
*salt
= hash_buf
->salt
;
10394 // for ascii_digest
10395 salt
->salt_sign
[0] = input_buf
[0];
10396 salt
->salt_sign
[1] = input_buf
[1];
10398 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10399 | itoa64_to_int (input_buf
[1]) << 6;
10401 salt
->salt_len
= 2;
10403 u8 tmp_buf
[100] = { 0 };
10405 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10407 memcpy (digest
, tmp_buf
, 8);
10411 IP (digest
[0], digest
[1], tt
);
10416 return (PARSER_OK
);
10419 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10421 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10423 u32
*digest
= (u32
*) hash_buf
->digest
;
10425 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10426 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10427 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10428 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10430 digest
[0] = byte_swap_32 (digest
[0]);
10431 digest
[1] = byte_swap_32 (digest
[1]);
10432 digest
[2] = byte_swap_32 (digest
[2]);
10433 digest
[3] = byte_swap_32 (digest
[3]);
10435 digest
[0] -= MD4M_A
;
10436 digest
[1] -= MD4M_B
;
10437 digest
[2] -= MD4M_C
;
10438 digest
[3] -= MD4M_D
;
10440 return (PARSER_OK
);
10443 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10445 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10447 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10451 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10454 u32
*digest
= (u32
*) hash_buf
->digest
;
10456 salt_t
*salt
= hash_buf
->salt
;
10458 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10459 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10460 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10461 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10463 digest
[0] = byte_swap_32 (digest
[0]);
10464 digest
[1] = byte_swap_32 (digest
[1]);
10465 digest
[2] = byte_swap_32 (digest
[2]);
10466 digest
[3] = byte_swap_32 (digest
[3]);
10468 digest
[0] -= MD4M_A
;
10469 digest
[1] -= MD4M_B
;
10470 digest
[2] -= MD4M_C
;
10471 digest
[3] -= MD4M_D
;
10473 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10475 uint salt_len
= input_len
- 32 - 1;
10477 char *salt_buf
= input_buf
+ 32 + 1;
10479 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10481 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10483 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10485 salt
->salt_len
= salt_len
;
10487 return (PARSER_OK
);
10490 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10492 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10494 u32
*digest
= (u32
*) hash_buf
->digest
;
10496 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10497 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10498 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10499 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10501 digest
[0] = byte_swap_32 (digest
[0]);
10502 digest
[1] = byte_swap_32 (digest
[1]);
10503 digest
[2] = byte_swap_32 (digest
[2]);
10504 digest
[3] = byte_swap_32 (digest
[3]);
10506 digest
[0] -= MD5M_A
;
10507 digest
[1] -= MD5M_B
;
10508 digest
[2] -= MD5M_C
;
10509 digest
[3] -= MD5M_D
;
10511 return (PARSER_OK
);
10514 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10516 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10518 u32
*digest
= (u32
*) hash_buf
->digest
;
10520 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10521 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10525 digest
[0] = byte_swap_32 (digest
[0]);
10526 digest
[1] = byte_swap_32 (digest
[1]);
10528 return (PARSER_OK
);
10531 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10533 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10535 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10539 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10542 u32
*digest
= (u32
*) hash_buf
->digest
;
10544 salt_t
*salt
= hash_buf
->salt
;
10546 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10547 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10548 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10549 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10551 digest
[0] = byte_swap_32 (digest
[0]);
10552 digest
[1] = byte_swap_32 (digest
[1]);
10553 digest
[2] = byte_swap_32 (digest
[2]);
10554 digest
[3] = byte_swap_32 (digest
[3]);
10556 digest
[0] -= MD5M_A
;
10557 digest
[1] -= MD5M_B
;
10558 digest
[2] -= MD5M_C
;
10559 digest
[3] -= MD5M_D
;
10561 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10563 uint salt_len
= input_len
- 32 - 1;
10565 char *salt_buf
= input_buf
+ 32 + 1;
10567 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10569 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10571 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10573 salt
->salt_len
= salt_len
;
10575 return (PARSER_OK
);
10578 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10580 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10582 u32
*digest
= (u32
*) hash_buf
->digest
;
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 return (PARSER_OK
);
10614 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10616 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10618 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10622 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10625 u32
*digest
= (u32
*) hash_buf
->digest
;
10627 salt_t
*salt
= hash_buf
->salt
;
10629 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10630 | itoa64_to_int (input_buf
[ 1]) << 6
10631 | itoa64_to_int (input_buf
[ 2]) << 12
10632 | itoa64_to_int (input_buf
[ 3]) << 18;
10633 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10634 | itoa64_to_int (input_buf
[ 5]) << 6
10635 | itoa64_to_int (input_buf
[ 6]) << 12
10636 | itoa64_to_int (input_buf
[ 7]) << 18;
10637 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10638 | itoa64_to_int (input_buf
[ 9]) << 6
10639 | itoa64_to_int (input_buf
[10]) << 12
10640 | itoa64_to_int (input_buf
[11]) << 18;
10641 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10642 | itoa64_to_int (input_buf
[13]) << 6
10643 | itoa64_to_int (input_buf
[14]) << 12
10644 | itoa64_to_int (input_buf
[15]) << 18;
10646 digest
[0] -= MD5M_A
;
10647 digest
[1] -= MD5M_B
;
10648 digest
[2] -= MD5M_C
;
10649 digest
[3] -= MD5M_D
;
10651 digest
[0] &= 0x00ffffff;
10652 digest
[1] &= 0x00ffffff;
10653 digest
[2] &= 0x00ffffff;
10654 digest
[3] &= 0x00ffffff;
10656 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10658 uint salt_len
= input_len
- 16 - 1;
10660 char *salt_buf
= input_buf
+ 16 + 1;
10662 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10664 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10666 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10668 salt
->salt_len
= salt_len
;
10670 return (PARSER_OK
);
10673 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10675 key
[0] = (nthash
[0] >> 0);
10676 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10677 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10678 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10679 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10680 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10681 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10682 key
[7] = (nthash
[6] << 1);
10694 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10696 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10698 u32
*digest
= (u32
*) hash_buf
->digest
;
10700 salt_t
*salt
= hash_buf
->salt
;
10702 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10708 char *user_pos
= input_buf
;
10710 char *unused_pos
= strchr (user_pos
, ':');
10712 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10714 uint user_len
= unused_pos
- user_pos
;
10716 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10720 char *domain_pos
= strchr (unused_pos
, ':');
10722 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10724 uint unused_len
= domain_pos
- unused_pos
;
10726 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10730 char *srvchall_pos
= strchr (domain_pos
, ':');
10732 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10734 uint domain_len
= srvchall_pos
- domain_pos
;
10736 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10740 char *hash_pos
= strchr (srvchall_pos
, ':');
10742 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10744 uint srvchall_len
= hash_pos
- srvchall_pos
;
10746 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10750 char *clichall_pos
= strchr (hash_pos
, ':');
10752 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10754 uint hash_len
= clichall_pos
- hash_pos
;
10756 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10760 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10762 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10765 * store some data for later use
10768 netntlm
->user_len
= user_len
* 2;
10769 netntlm
->domain_len
= domain_len
* 2;
10770 netntlm
->srvchall_len
= srvchall_len
/ 2;
10771 netntlm
->clichall_len
= clichall_len
/ 2;
10773 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10774 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10777 * handle username and domainname
10780 for (uint i
= 0; i
< user_len
; i
++)
10782 *userdomain_ptr
++ = user_pos
[i
];
10783 *userdomain_ptr
++ = 0;
10786 for (uint i
= 0; i
< domain_len
; i
++)
10788 *userdomain_ptr
++ = domain_pos
[i
];
10789 *userdomain_ptr
++ = 0;
10793 * handle server challenge encoding
10796 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10798 const char p0
= srvchall_pos
[i
+ 0];
10799 const char p1
= srvchall_pos
[i
+ 1];
10801 *chall_ptr
++ = hex_convert (p1
) << 0
10802 | hex_convert (p0
) << 4;
10806 * handle client challenge encoding
10809 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10811 const char p0
= clichall_pos
[i
+ 0];
10812 const char p1
= clichall_pos
[i
+ 1];
10814 *chall_ptr
++ = hex_convert (p1
) << 0
10815 | hex_convert (p0
) << 4;
10822 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10824 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10826 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10828 salt
->salt_len
= salt_len
;
10830 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10831 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10832 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10833 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10835 digest
[0] = byte_swap_32 (digest
[0]);
10836 digest
[1] = byte_swap_32 (digest
[1]);
10837 digest
[2] = byte_swap_32 (digest
[2]);
10838 digest
[3] = byte_swap_32 (digest
[3]);
10840 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10842 uint digest_tmp
[2] = { 0 };
10844 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10845 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10847 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10848 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10850 /* special case 2: ESS */
10852 if (srvchall_len
== 48)
10854 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10856 uint w
[16] = { 0 };
10858 w
[ 0] = netntlm
->chall_buf
[6];
10859 w
[ 1] = netntlm
->chall_buf
[7];
10860 w
[ 2] = netntlm
->chall_buf
[0];
10861 w
[ 3] = netntlm
->chall_buf
[1];
10865 uint dgst
[4] = { 0 };
10874 salt
->salt_buf
[0] = dgst
[0];
10875 salt
->salt_buf
[1] = dgst
[1];
10879 /* precompute netntlmv1 exploit start */
10881 for (uint i
= 0; i
< 0x10000; i
++)
10883 uint key_md4
[2] = { i
, 0 };
10884 uint key_des
[2] = { 0, 0 };
10886 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10888 uint Kc
[16] = { 0 };
10889 uint Kd
[16] = { 0 };
10891 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10893 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10895 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10897 if (data3
[0] != digest_tmp
[0]) continue;
10898 if (data3
[1] != digest_tmp
[1]) continue;
10900 salt
->salt_buf
[2] = i
;
10902 salt
->salt_len
= 24;
10907 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10908 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10910 /* precompute netntlmv1 exploit stop */
10914 IP (digest
[0], digest
[1], tt
);
10915 IP (digest
[2], digest
[3], tt
);
10917 digest
[0] = rotr32 (digest
[0], 29);
10918 digest
[1] = rotr32 (digest
[1], 29);
10919 digest
[2] = rotr32 (digest
[2], 29);
10920 digest
[3] = rotr32 (digest
[3], 29);
10922 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10924 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10925 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10927 return (PARSER_OK
);
10930 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10932 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10934 u32
*digest
= (u32
*) hash_buf
->digest
;
10936 salt_t
*salt
= hash_buf
->salt
;
10938 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10944 char *user_pos
= input_buf
;
10946 char *unused_pos
= strchr (user_pos
, ':');
10948 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10950 uint user_len
= unused_pos
- user_pos
;
10952 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10956 char *domain_pos
= strchr (unused_pos
, ':');
10958 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10960 uint unused_len
= domain_pos
- unused_pos
;
10962 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10966 char *srvchall_pos
= strchr (domain_pos
, ':');
10968 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10970 uint domain_len
= srvchall_pos
- domain_pos
;
10972 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10976 char *hash_pos
= strchr (srvchall_pos
, ':');
10978 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10980 uint srvchall_len
= hash_pos
- srvchall_pos
;
10982 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10986 char *clichall_pos
= strchr (hash_pos
, ':');
10988 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10990 uint hash_len
= clichall_pos
- hash_pos
;
10992 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10996 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10998 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11000 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11003 * store some data for later use
11006 netntlm
->user_len
= user_len
* 2;
11007 netntlm
->domain_len
= domain_len
* 2;
11008 netntlm
->srvchall_len
= srvchall_len
/ 2;
11009 netntlm
->clichall_len
= clichall_len
/ 2;
11011 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11012 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11015 * handle username and domainname
11018 for (uint i
= 0; i
< user_len
; i
++)
11020 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11021 *userdomain_ptr
++ = 0;
11024 for (uint i
= 0; i
< domain_len
; i
++)
11026 *userdomain_ptr
++ = domain_pos
[i
];
11027 *userdomain_ptr
++ = 0;
11030 *userdomain_ptr
++ = 0x80;
11033 * handle server challenge encoding
11036 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11038 const char p0
= srvchall_pos
[i
+ 0];
11039 const char p1
= srvchall_pos
[i
+ 1];
11041 *chall_ptr
++ = hex_convert (p1
) << 0
11042 | hex_convert (p0
) << 4;
11046 * handle client challenge encoding
11049 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11051 const char p0
= clichall_pos
[i
+ 0];
11052 const char p1
= clichall_pos
[i
+ 1];
11054 *chall_ptr
++ = hex_convert (p1
) << 0
11055 | hex_convert (p0
) << 4;
11058 *chall_ptr
++ = 0x80;
11061 * handle hash itself
11064 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11065 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11066 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11067 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11069 digest
[0] = byte_swap_32 (digest
[0]);
11070 digest
[1] = byte_swap_32 (digest
[1]);
11071 digest
[2] = byte_swap_32 (digest
[2]);
11072 digest
[3] = byte_swap_32 (digest
[3]);
11075 * reuse challange data as salt_buf, its the buffer that is most likely unique
11078 salt
->salt_buf
[0] = 0;
11079 salt
->salt_buf
[1] = 0;
11080 salt
->salt_buf
[2] = 0;
11081 salt
->salt_buf
[3] = 0;
11082 salt
->salt_buf
[4] = 0;
11083 salt
->salt_buf
[5] = 0;
11084 salt
->salt_buf
[6] = 0;
11085 salt
->salt_buf
[7] = 0;
11089 uptr
= (uint
*) netntlm
->userdomain_buf
;
11091 for (uint i
= 0; i
< 16; i
+= 16)
11093 md5_64 (uptr
, salt
->salt_buf
);
11096 uptr
= (uint
*) netntlm
->chall_buf
;
11098 for (uint i
= 0; i
< 256; i
+= 16)
11100 md5_64 (uptr
, salt
->salt_buf
);
11103 salt
->salt_len
= 16;
11105 return (PARSER_OK
);
11108 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11110 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11112 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11116 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11119 u32
*digest
= (u32
*) hash_buf
->digest
;
11121 salt_t
*salt
= hash_buf
->salt
;
11123 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11124 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11125 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11126 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11128 digest
[0] = byte_swap_32 (digest
[0]);
11129 digest
[1] = byte_swap_32 (digest
[1]);
11130 digest
[2] = byte_swap_32 (digest
[2]);
11131 digest
[3] = byte_swap_32 (digest
[3]);
11133 digest
[0] -= MD5M_A
;
11134 digest
[1] -= MD5M_B
;
11135 digest
[2] -= MD5M_C
;
11136 digest
[3] -= MD5M_D
;
11138 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11140 uint salt_len
= input_len
- 32 - 1;
11142 char *salt_buf
= input_buf
+ 32 + 1;
11144 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11146 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11148 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11150 salt
->salt_len
= salt_len
;
11152 return (PARSER_OK
);
11155 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11157 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11159 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11163 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11166 u32
*digest
= (u32
*) hash_buf
->digest
;
11168 salt_t
*salt
= hash_buf
->salt
;
11170 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11171 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11172 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11173 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11175 digest
[0] = byte_swap_32 (digest
[0]);
11176 digest
[1] = byte_swap_32 (digest
[1]);
11177 digest
[2] = byte_swap_32 (digest
[2]);
11178 digest
[3] = byte_swap_32 (digest
[3]);
11180 digest
[0] -= MD5M_A
;
11181 digest
[1] -= MD5M_B
;
11182 digest
[2] -= MD5M_C
;
11183 digest
[3] -= MD5M_D
;
11185 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11187 uint salt_len
= input_len
- 32 - 1;
11189 char *salt_buf
= input_buf
+ 32 + 1;
11191 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11193 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11195 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11197 salt
->salt_len
= salt_len
;
11199 return (PARSER_OK
);
11202 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11204 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11206 u32
*digest
= (u32
*) hash_buf
->digest
;
11208 salt_t
*salt
= hash_buf
->salt
;
11210 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11211 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11212 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11213 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11215 digest
[0] = byte_swap_32 (digest
[0]);
11216 digest
[1] = byte_swap_32 (digest
[1]);
11217 digest
[2] = byte_swap_32 (digest
[2]);
11218 digest
[3] = byte_swap_32 (digest
[3]);
11220 digest
[0] -= MD5M_A
;
11221 digest
[1] -= MD5M_B
;
11222 digest
[2] -= MD5M_C
;
11223 digest
[3] -= MD5M_D
;
11226 * This is a virtual salt. While the algorithm is basically not salted
11227 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11228 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11231 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11233 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11235 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11237 salt
->salt_len
= salt_len
;
11239 return (PARSER_OK
);
11242 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11244 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11246 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11250 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11253 u32
*digest
= (u32
*) hash_buf
->digest
;
11255 salt_t
*salt
= hash_buf
->salt
;
11257 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11258 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11259 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11260 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11262 digest
[0] = byte_swap_32 (digest
[0]);
11263 digest
[1] = byte_swap_32 (digest
[1]);
11264 digest
[2] = byte_swap_32 (digest
[2]);
11265 digest
[3] = byte_swap_32 (digest
[3]);
11267 digest
[0] -= MD5M_A
;
11268 digest
[1] -= MD5M_B
;
11269 digest
[2] -= MD5M_C
;
11270 digest
[3] -= MD5M_D
;
11272 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11274 uint salt_len
= input_len
- 32 - 1;
11276 char *salt_buf
= input_buf
+ 32 + 1;
11278 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11280 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11282 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11284 salt
->salt_len
= salt_len
;
11286 return (PARSER_OK
);
11289 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11291 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11293 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11297 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11300 u32
*digest
= (u32
*) hash_buf
->digest
;
11302 salt_t
*salt
= hash_buf
->salt
;
11304 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11305 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11306 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11307 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11309 digest
[0] = byte_swap_32 (digest
[0]);
11310 digest
[1] = byte_swap_32 (digest
[1]);
11311 digest
[2] = byte_swap_32 (digest
[2]);
11312 digest
[3] = byte_swap_32 (digest
[3]);
11314 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11316 uint salt_len
= input_len
- 32 - 1;
11318 char *salt_buf
= input_buf
+ 32 + 1;
11320 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11322 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11324 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11326 salt
->salt_len
= salt_len
;
11328 return (PARSER_OK
);
11331 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11333 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11335 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11339 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11342 u32
*digest
= (u32
*) hash_buf
->digest
;
11344 salt_t
*salt
= hash_buf
->salt
;
11346 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11347 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11348 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11349 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11351 digest
[0] = byte_swap_32 (digest
[0]);
11352 digest
[1] = byte_swap_32 (digest
[1]);
11353 digest
[2] = byte_swap_32 (digest
[2]);
11354 digest
[3] = byte_swap_32 (digest
[3]);
11356 digest
[0] -= MD4M_A
;
11357 digest
[1] -= MD4M_B
;
11358 digest
[2] -= MD4M_C
;
11359 digest
[3] -= MD4M_D
;
11361 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11363 uint salt_len
= input_len
- 32 - 1;
11365 char *salt_buf
= input_buf
+ 32 + 1;
11367 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11369 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11371 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11373 salt
->salt_len
= salt_len
;
11375 return (PARSER_OK
);
11378 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11380 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11382 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11386 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11389 u32
*digest
= (u32
*) hash_buf
->digest
;
11391 salt_t
*salt
= hash_buf
->salt
;
11393 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11394 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11395 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11396 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11398 digest
[0] = byte_swap_32 (digest
[0]);
11399 digest
[1] = byte_swap_32 (digest
[1]);
11400 digest
[2] = byte_swap_32 (digest
[2]);
11401 digest
[3] = byte_swap_32 (digest
[3]);
11403 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11405 uint salt_len
= input_len
- 32 - 1;
11407 char *salt_buf
= input_buf
+ 32 + 1;
11409 uint salt_pc_block
[16] = { 0 };
11411 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11413 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11415 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11417 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11419 salt_pc_block
[14] = salt_len
* 8;
11421 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11423 md5_64 (salt_pc_block
, salt_pc_digest
);
11425 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11426 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11427 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11428 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11430 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11432 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11434 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11436 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11437 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11438 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11439 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11441 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11443 return (PARSER_OK
);
11446 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11448 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11450 u32
*digest
= (u32
*) hash_buf
->digest
;
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 return (PARSER_OK
);
11467 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11469 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11471 u32
*digest
= (u32
*) hash_buf
->digest
;
11473 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11474 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11475 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11476 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11477 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11479 return (PARSER_OK
);
11482 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11484 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11486 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11490 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11493 u32
*digest
= (u32
*) hash_buf
->digest
;
11495 salt_t
*salt
= hash_buf
->salt
;
11497 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11498 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11499 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11500 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11501 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11503 digest
[0] -= SHA1M_A
;
11504 digest
[1] -= SHA1M_B
;
11505 digest
[2] -= SHA1M_C
;
11506 digest
[3] -= SHA1M_D
;
11507 digest
[4] -= SHA1M_E
;
11509 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11511 uint salt_len
= input_len
- 40 - 1;
11513 char *salt_buf
= input_buf
+ 40 + 1;
11515 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11517 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11519 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11521 salt
->salt_len
= salt_len
;
11523 return (PARSER_OK
);
11526 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11528 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11530 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11532 u32
*digest
= (u32
*) hash_buf
->digest
;
11534 u8 tmp_buf
[100] = { 0 };
11536 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11538 memcpy (digest
, tmp_buf
, 20);
11540 digest
[0] = byte_swap_32 (digest
[0]);
11541 digest
[1] = byte_swap_32 (digest
[1]);
11542 digest
[2] = byte_swap_32 (digest
[2]);
11543 digest
[3] = byte_swap_32 (digest
[3]);
11544 digest
[4] = byte_swap_32 (digest
[4]);
11546 digest
[0] -= SHA1M_A
;
11547 digest
[1] -= SHA1M_B
;
11548 digest
[2] -= SHA1M_C
;
11549 digest
[3] -= SHA1M_D
;
11550 digest
[4] -= SHA1M_E
;
11552 return (PARSER_OK
);
11555 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11557 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11559 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11561 u32
*digest
= (u32
*) hash_buf
->digest
;
11563 salt_t
*salt
= hash_buf
->salt
;
11565 u8 tmp_buf
[100] = { 0 };
11567 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11569 memcpy (digest
, tmp_buf
, 20);
11571 salt
->salt_len
= tmp_len
- 20;
11573 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11575 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11577 char *ptr
= (char *) salt
->salt_buf
;
11579 ptr
[salt
->salt_len
] = 0x80;
11582 digest
[0] = byte_swap_32 (digest
[0]);
11583 digest
[1] = byte_swap_32 (digest
[1]);
11584 digest
[2] = byte_swap_32 (digest
[2]);
11585 digest
[3] = byte_swap_32 (digest
[3]);
11586 digest
[4] = byte_swap_32 (digest
[4]);
11588 digest
[0] -= SHA1M_A
;
11589 digest
[1] -= SHA1M_B
;
11590 digest
[2] -= SHA1M_C
;
11591 digest
[3] -= SHA1M_D
;
11592 digest
[4] -= SHA1M_E
;
11594 return (PARSER_OK
);
11597 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11599 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11601 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11603 u32
*digest
= (u32
*) hash_buf
->digest
;
11605 salt_t
*salt
= hash_buf
->salt
;
11607 char *salt_buf
= input_buf
+ 6;
11611 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11613 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11615 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11617 salt
->salt_len
= salt_len
;
11619 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11621 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11622 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11623 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11624 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11625 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11627 digest
[0] -= SHA1M_A
;
11628 digest
[1] -= SHA1M_B
;
11629 digest
[2] -= SHA1M_C
;
11630 digest
[3] -= SHA1M_D
;
11631 digest
[4] -= SHA1M_E
;
11633 return (PARSER_OK
);
11636 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11638 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11640 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11642 u32
*digest
= (u32
*) hash_buf
->digest
;
11644 salt_t
*salt
= hash_buf
->salt
;
11646 char *salt_buf
= input_buf
+ 6;
11650 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11652 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11654 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11656 salt
->salt_len
= salt_len
;
11658 char *hash_pos
= input_buf
+ 6 + 8;
11660 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11661 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11662 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11663 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11664 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11666 digest
[0] -= SHA1M_A
;
11667 digest
[1] -= SHA1M_B
;
11668 digest
[2] -= SHA1M_C
;
11669 digest
[3] -= SHA1M_D
;
11670 digest
[4] -= SHA1M_E
;
11672 return (PARSER_OK
);
11675 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11677 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11679 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11681 u64
*digest
= (u64
*) hash_buf
->digest
;
11683 salt_t
*salt
= hash_buf
->salt
;
11685 char *salt_buf
= input_buf
+ 6;
11689 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11691 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11693 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11695 salt
->salt_len
= salt_len
;
11697 char *hash_pos
= input_buf
+ 6 + 8;
11699 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11700 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11701 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11702 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11703 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11704 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11705 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11706 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11708 digest
[0] -= SHA512M_A
;
11709 digest
[1] -= SHA512M_B
;
11710 digest
[2] -= SHA512M_C
;
11711 digest
[3] -= SHA512M_D
;
11712 digest
[4] -= SHA512M_E
;
11713 digest
[5] -= SHA512M_F
;
11714 digest
[6] -= SHA512M_G
;
11715 digest
[7] -= SHA512M_H
;
11717 return (PARSER_OK
);
11720 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11722 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11724 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11728 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11731 u32
*digest
= (u32
*) hash_buf
->digest
;
11733 salt_t
*salt
= hash_buf
->salt
;
11735 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11736 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11740 digest
[0] = byte_swap_32 (digest
[0]);
11741 digest
[1] = byte_swap_32 (digest
[1]);
11743 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11745 uint salt_len
= input_len
- 16 - 1;
11747 char *salt_buf
= input_buf
+ 16 + 1;
11749 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11751 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11753 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11755 salt
->salt_len
= salt_len
;
11757 return (PARSER_OK
);
11760 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11762 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11764 u32
*digest
= (u32
*) hash_buf
->digest
;
11766 salt_t
*salt
= hash_buf
->salt
;
11768 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11769 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11770 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11771 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11772 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11774 digest
[0] -= SHA1M_A
;
11775 digest
[1] -= SHA1M_B
;
11776 digest
[2] -= SHA1M_C
;
11777 digest
[3] -= SHA1M_D
;
11778 digest
[4] -= SHA1M_E
;
11780 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11782 uint salt_len
= input_len
- 40 - 1;
11784 char *salt_buf
= input_buf
+ 40 + 1;
11786 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11788 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11790 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11792 salt
->salt_len
= salt_len
;
11794 return (PARSER_OK
);
11797 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11799 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11801 u32
*digest
= (u32
*) hash_buf
->digest
;
11803 salt_t
*salt
= hash_buf
->salt
;
11805 char *hash_pos
= input_buf
;
11807 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11808 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11809 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11810 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11811 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11812 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11813 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11814 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11815 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11816 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11817 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11818 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11819 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11820 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11821 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11822 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11824 char *salt_pos
= input_buf
+ 128;
11826 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11827 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11828 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11829 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11831 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11832 salt
->salt_len
= 16;
11834 return (PARSER_OK
);
11837 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11839 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11841 u32
*digest
= (u32
*) hash_buf
->digest
;
11843 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11844 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11845 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11846 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11847 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11848 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11849 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11850 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11852 digest
[0] -= SHA256M_A
;
11853 digest
[1] -= SHA256M_B
;
11854 digest
[2] -= SHA256M_C
;
11855 digest
[3] -= SHA256M_D
;
11856 digest
[4] -= SHA256M_E
;
11857 digest
[5] -= SHA256M_F
;
11858 digest
[6] -= SHA256M_G
;
11859 digest
[7] -= SHA256M_H
;
11861 return (PARSER_OK
);
11864 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11866 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11868 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11872 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11875 u32
*digest
= (u32
*) hash_buf
->digest
;
11877 salt_t
*salt
= hash_buf
->salt
;
11879 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11880 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11881 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11882 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11883 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11884 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11885 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11886 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11888 digest
[0] -= SHA256M_A
;
11889 digest
[1] -= SHA256M_B
;
11890 digest
[2] -= SHA256M_C
;
11891 digest
[3] -= SHA256M_D
;
11892 digest
[4] -= SHA256M_E
;
11893 digest
[5] -= SHA256M_F
;
11894 digest
[6] -= SHA256M_G
;
11895 digest
[7] -= SHA256M_H
;
11897 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11899 uint salt_len
= input_len
- 64 - 1;
11901 char *salt_buf
= input_buf
+ 64 + 1;
11903 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11905 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11907 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11909 salt
->salt_len
= salt_len
;
11911 return (PARSER_OK
);
11914 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11916 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11918 u64
*digest
= (u64
*) hash_buf
->digest
;
11920 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11921 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11922 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11923 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11924 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11925 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11929 digest
[0] -= SHA384M_A
;
11930 digest
[1] -= SHA384M_B
;
11931 digest
[2] -= SHA384M_C
;
11932 digest
[3] -= SHA384M_D
;
11933 digest
[4] -= SHA384M_E
;
11934 digest
[5] -= SHA384M_F
;
11938 return (PARSER_OK
);
11941 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11943 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11945 u64
*digest
= (u64
*) hash_buf
->digest
;
11947 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11948 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11949 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11950 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11951 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11952 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11953 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11954 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11956 digest
[0] -= SHA512M_A
;
11957 digest
[1] -= SHA512M_B
;
11958 digest
[2] -= SHA512M_C
;
11959 digest
[3] -= SHA512M_D
;
11960 digest
[4] -= SHA512M_E
;
11961 digest
[5] -= SHA512M_F
;
11962 digest
[6] -= SHA512M_G
;
11963 digest
[7] -= SHA512M_H
;
11965 return (PARSER_OK
);
11968 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11970 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11972 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11976 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11979 u64
*digest
= (u64
*) hash_buf
->digest
;
11981 salt_t
*salt
= hash_buf
->salt
;
11983 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11984 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11985 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11986 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11987 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11988 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11989 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11990 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11992 digest
[0] -= SHA512M_A
;
11993 digest
[1] -= SHA512M_B
;
11994 digest
[2] -= SHA512M_C
;
11995 digest
[3] -= SHA512M_D
;
11996 digest
[4] -= SHA512M_E
;
11997 digest
[5] -= SHA512M_F
;
11998 digest
[6] -= SHA512M_G
;
11999 digest
[7] -= SHA512M_H
;
12001 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12003 uint salt_len
= input_len
- 128 - 1;
12005 char *salt_buf
= input_buf
+ 128 + 1;
12007 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12009 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12011 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12013 salt
->salt_len
= salt_len
;
12015 return (PARSER_OK
);
12018 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12020 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12022 u64
*digest
= (u64
*) hash_buf
->digest
;
12024 salt_t
*salt
= hash_buf
->salt
;
12026 char *salt_pos
= input_buf
+ 3;
12028 uint iterations_len
= 0;
12030 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12034 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12036 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12037 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12041 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12045 iterations_len
+= 8;
12049 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12052 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12054 char *hash_pos
= strchr (salt_pos
, '$');
12056 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12058 uint salt_len
= hash_pos
- salt_pos
;
12060 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12062 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12064 salt
->salt_len
= salt_len
;
12068 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12070 return (PARSER_OK
);
12073 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12075 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12077 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12079 u64
*digest
= (u64
*) hash_buf
->digest
;
12081 salt_t
*salt
= hash_buf
->salt
;
12083 uint keccak_mdlen
= input_len
/ 2;
12085 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12087 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12089 digest
[i
] = byte_swap_64 (digest
[i
]);
12092 salt
->keccak_mdlen
= keccak_mdlen
;
12094 return (PARSER_OK
);
12097 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12099 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12101 u32
*digest
= (u32
*) hash_buf
->digest
;
12103 salt_t
*salt
= hash_buf
->salt
;
12105 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12108 * Parse that strange long line
12113 size_t in_len
[9] = { 0 };
12115 in_off
[0] = strtok (input_buf
, ":");
12117 in_len
[0] = strlen (in_off
[0]);
12121 for (i
= 1; i
< 9; i
++)
12123 in_off
[i
] = strtok (NULL
, ":");
12125 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12127 in_len
[i
] = strlen (in_off
[i
]);
12130 char *ptr
= (char *) ikepsk
->msg_buf
;
12132 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12133 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12134 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12135 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12136 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12137 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12141 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12143 ptr
= (char *) ikepsk
->nr_buf
;
12145 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12146 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12150 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12153 * Store to database
12158 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12159 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12160 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12161 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12163 digest
[0] = byte_swap_32 (digest
[0]);
12164 digest
[1] = byte_swap_32 (digest
[1]);
12165 digest
[2] = byte_swap_32 (digest
[2]);
12166 digest
[3] = byte_swap_32 (digest
[3]);
12168 salt
->salt_len
= 32;
12170 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12171 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12172 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12173 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12174 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12175 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12176 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12177 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12179 return (PARSER_OK
);
12182 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12184 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12186 u32
*digest
= (u32
*) hash_buf
->digest
;
12188 salt_t
*salt
= hash_buf
->salt
;
12190 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12193 * Parse that strange long line
12198 size_t in_len
[9] = { 0 };
12200 in_off
[0] = strtok (input_buf
, ":");
12202 in_len
[0] = strlen (in_off
[0]);
12206 for (i
= 1; i
< 9; i
++)
12208 in_off
[i
] = strtok (NULL
, ":");
12210 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12212 in_len
[i
] = strlen (in_off
[i
]);
12215 char *ptr
= (char *) ikepsk
->msg_buf
;
12217 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12218 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12219 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12220 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12221 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12222 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12226 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12228 ptr
= (char *) ikepsk
->nr_buf
;
12230 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12231 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12235 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12238 * Store to database
12243 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12244 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12245 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12246 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12247 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12249 salt
->salt_len
= 32;
12251 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12252 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12253 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12254 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12255 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12256 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12257 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12258 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12260 return (PARSER_OK
);
12263 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12265 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12267 u32
*digest
= (u32
*) hash_buf
->digest
;
12269 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12270 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12271 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12272 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12273 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12275 digest
[0] = byte_swap_32 (digest
[0]);
12276 digest
[1] = byte_swap_32 (digest
[1]);
12277 digest
[2] = byte_swap_32 (digest
[2]);
12278 digest
[3] = byte_swap_32 (digest
[3]);
12279 digest
[4] = byte_swap_32 (digest
[4]);
12281 return (PARSER_OK
);
12284 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12286 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12288 u32
*digest
= (u32
*) hash_buf
->digest
;
12290 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12291 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12292 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12293 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12294 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12295 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12296 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12297 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12298 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12299 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12300 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12301 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12302 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12303 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12304 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12305 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12307 return (PARSER_OK
);
12310 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12312 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12314 u32
*digest
= (u32
*) hash_buf
->digest
;
12316 salt_t
*salt
= hash_buf
->salt
;
12318 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12319 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12320 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12321 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12322 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12324 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12326 uint salt_len
= input_len
- 40 - 1;
12328 char *salt_buf
= input_buf
+ 40 + 1;
12330 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12332 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12334 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12336 salt
->salt_len
= salt_len
;
12338 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12340 return (PARSER_OK
);
12343 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12345 u32
*digest
= (u32
*) hash_buf
->digest
;
12347 salt_t
*salt
= hash_buf
->salt
;
12349 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12351 if (input_len
== 0)
12353 log_error ("TrueCrypt container not specified");
12358 FILE *fp
= fopen (input_buf
, "rb");
12362 log_error ("%s: %s", input_buf
, strerror (errno
));
12367 char buf
[512] = { 0 };
12369 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12373 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12375 memcpy (tc
->salt_buf
, buf
, 64);
12377 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12379 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12381 salt
->salt_len
= 4;
12383 salt
->salt_iter
= 1000 - 1;
12385 digest
[0] = tc
->data_buf
[0];
12387 return (PARSER_OK
);
12390 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12392 u32
*digest
= (u32
*) hash_buf
->digest
;
12394 salt_t
*salt
= hash_buf
->salt
;
12396 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12398 if (input_len
== 0)
12400 log_error ("TrueCrypt container not specified");
12405 FILE *fp
= fopen (input_buf
, "rb");
12409 log_error ("%s: %s", input_buf
, strerror (errno
));
12414 char buf
[512] = { 0 };
12416 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12420 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12422 memcpy (tc
->salt_buf
, buf
, 64);
12424 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12426 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12428 salt
->salt_len
= 4;
12430 salt
->salt_iter
= 2000 - 1;
12432 digest
[0] = tc
->data_buf
[0];
12434 return (PARSER_OK
);
12437 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12439 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12441 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12443 u32
*digest
= (u32
*) hash_buf
->digest
;
12445 salt_t
*salt
= hash_buf
->salt
;
12447 char *salt_pos
= input_buf
+ 6;
12449 char *hash_pos
= strchr (salt_pos
, '$');
12451 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12453 uint salt_len
= hash_pos
- salt_pos
;
12455 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12457 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12459 salt
->salt_len
= salt_len
;
12461 salt
->salt_iter
= 1000;
12465 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12467 return (PARSER_OK
);
12470 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12472 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12474 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12476 u32
*digest
= (u32
*) hash_buf
->digest
;
12478 salt_t
*salt
= hash_buf
->salt
;
12480 char *iter_pos
= input_buf
+ 7;
12482 char *salt_pos
= strchr (iter_pos
, '$');
12484 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12488 char *hash_pos
= strchr (salt_pos
, '$');
12490 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12492 uint salt_len
= hash_pos
- salt_pos
;
12494 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12496 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12498 salt
->salt_len
= salt_len
;
12500 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12502 salt
->salt_sign
[0] = atoi (salt_iter
);
12504 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12508 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12510 digest
[0] = byte_swap_32 (digest
[0]);
12511 digest
[1] = byte_swap_32 (digest
[1]);
12512 digest
[2] = byte_swap_32 (digest
[2]);
12513 digest
[3] = byte_swap_32 (digest
[3]);
12514 digest
[4] = byte_swap_32 (digest
[4]);
12516 return (PARSER_OK
);
12519 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12521 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12523 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12525 u32
*digest
= (u32
*) hash_buf
->digest
;
12527 salt_t
*salt
= hash_buf
->salt
;
12529 char *iter_pos
= input_buf
+ 9;
12531 char *salt_pos
= strchr (iter_pos
, '$');
12533 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12537 char *hash_pos
= strchr (salt_pos
, '$');
12539 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12541 uint salt_len
= hash_pos
- salt_pos
;
12543 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12545 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12547 salt
->salt_len
= salt_len
;
12549 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12551 salt
->salt_sign
[0] = atoi (salt_iter
);
12553 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12557 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12559 digest
[0] = byte_swap_32 (digest
[0]);
12560 digest
[1] = byte_swap_32 (digest
[1]);
12561 digest
[2] = byte_swap_32 (digest
[2]);
12562 digest
[3] = byte_swap_32 (digest
[3]);
12563 digest
[4] = byte_swap_32 (digest
[4]);
12564 digest
[5] = byte_swap_32 (digest
[5]);
12565 digest
[6] = byte_swap_32 (digest
[6]);
12566 digest
[7] = byte_swap_32 (digest
[7]);
12568 return (PARSER_OK
);
12571 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12573 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12575 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12577 u64
*digest
= (u64
*) hash_buf
->digest
;
12579 salt_t
*salt
= hash_buf
->salt
;
12581 char *iter_pos
= input_buf
+ 9;
12583 char *salt_pos
= strchr (iter_pos
, '$');
12585 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12589 char *hash_pos
= strchr (salt_pos
, '$');
12591 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12593 uint salt_len
= hash_pos
- salt_pos
;
12595 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12597 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12599 salt
->salt_len
= salt_len
;
12601 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12603 salt
->salt_sign
[0] = atoi (salt_iter
);
12605 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12609 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12611 digest
[0] = byte_swap_64 (digest
[0]);
12612 digest
[1] = byte_swap_64 (digest
[1]);
12613 digest
[2] = byte_swap_64 (digest
[2]);
12614 digest
[3] = byte_swap_64 (digest
[3]);
12615 digest
[4] = byte_swap_64 (digest
[4]);
12616 digest
[5] = byte_swap_64 (digest
[5]);
12617 digest
[6] = byte_swap_64 (digest
[6]);
12618 digest
[7] = byte_swap_64 (digest
[7]);
12620 return (PARSER_OK
);
12623 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12625 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12627 u32
*digest
= (u32
*) hash_buf
->digest
;
12629 salt_t
*salt
= hash_buf
->salt
;
12631 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12637 char *iterations_pos
= input_buf
;
12639 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12641 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12643 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12645 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12649 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12651 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12653 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12655 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12657 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12659 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12664 * pbkdf2 iterations
12667 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12670 * handle salt encoding
12673 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12675 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12677 const char p0
= saltbuf_pos
[i
+ 0];
12678 const char p1
= saltbuf_pos
[i
+ 1];
12680 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12681 | hex_convert (p0
) << 4;
12684 salt
->salt_len
= saltbuf_len
/ 2;
12687 * handle cipher encoding
12690 uint
*tmp
= (uint
*) mymalloc (32);
12692 char *cipherbuf_ptr
= (char *) tmp
;
12694 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12696 const char p0
= cipherbuf_pos
[i
+ 0];
12697 const char p1
= cipherbuf_pos
[i
+ 1];
12699 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12700 | hex_convert (p0
) << 4;
12703 // iv is stored at salt_buf 4 (length 16)
12704 // data is stored at salt_buf 8 (length 16)
12706 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12707 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12708 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12709 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12711 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12712 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12713 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12714 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12718 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12720 const char p0
= cipherbuf_pos
[j
+ 0];
12721 const char p1
= cipherbuf_pos
[j
+ 1];
12723 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12724 | hex_convert (p0
) << 4;
12731 digest
[0] = 0x10101010;
12732 digest
[1] = 0x10101010;
12733 digest
[2] = 0x10101010;
12734 digest
[3] = 0x10101010;
12736 return (PARSER_OK
);
12739 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12741 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12743 u32
*digest
= (u32
*) hash_buf
->digest
;
12745 salt_t
*salt
= hash_buf
->salt
;
12747 char *hashbuf_pos
= input_buf
;
12749 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12751 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12753 uint hash_len
= iterations_pos
- hashbuf_pos
;
12755 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12759 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12761 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12763 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12767 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12769 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12771 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12773 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12775 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12777 salt
->salt_len
= salt_len
;
12779 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12781 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12782 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12783 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12784 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12786 return (PARSER_OK
);
12789 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12791 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12793 u32
*digest
= (u32
*) hash_buf
->digest
;
12795 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12796 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12797 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12798 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12799 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12800 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12801 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12802 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12804 digest
[0] = byte_swap_32 (digest
[0]);
12805 digest
[1] = byte_swap_32 (digest
[1]);
12806 digest
[2] = byte_swap_32 (digest
[2]);
12807 digest
[3] = byte_swap_32 (digest
[3]);
12808 digest
[4] = byte_swap_32 (digest
[4]);
12809 digest
[5] = byte_swap_32 (digest
[5]);
12810 digest
[6] = byte_swap_32 (digest
[6]);
12811 digest
[7] = byte_swap_32 (digest
[7]);
12813 return (PARSER_OK
);
12816 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12818 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12820 u32
*digest
= (u32
*) hash_buf
->digest
;
12822 salt_t
*salt
= hash_buf
->salt
;
12824 char *salt_pos
= input_buf
+ 3;
12826 uint iterations_len
= 0;
12828 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12832 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12834 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12835 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12839 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12843 iterations_len
+= 8;
12847 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12850 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12852 char *hash_pos
= strchr (salt_pos
, '$');
12854 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12856 uint salt_len
= hash_pos
- salt_pos
;
12858 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12860 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12862 salt
->salt_len
= salt_len
;
12866 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12868 return (PARSER_OK
);
12871 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12873 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12875 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12877 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12879 u64
*digest
= (u64
*) hash_buf
->digest
;
12881 salt_t
*salt
= hash_buf
->salt
;
12883 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12885 char *iter_pos
= input_buf
+ 4;
12887 char *salt_pos
= strchr (iter_pos
, '$');
12889 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12893 char *hash_pos
= strchr (salt_pos
, '$');
12895 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12897 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12901 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12902 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12903 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12904 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12905 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12906 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12907 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12908 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12910 uint salt_len
= hash_pos
- salt_pos
- 1;
12912 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12914 salt
->salt_len
= salt_len
/ 2;
12916 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12917 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12918 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12919 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12920 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12921 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12922 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12923 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12925 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12926 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12927 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12928 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12929 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12930 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12931 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12932 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12933 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12934 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12936 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12938 salt
->salt_iter
= atoi (iter_pos
) - 1;
12940 return (PARSER_OK
);
12943 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12945 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12947 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12949 u32
*digest
= (u32
*) hash_buf
->digest
;
12951 salt_t
*salt
= hash_buf
->salt
;
12953 char *salt_pos
= input_buf
+ 14;
12955 char *hash_pos
= strchr (salt_pos
, '*');
12957 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12961 uint salt_len
= hash_pos
- salt_pos
- 1;
12963 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12965 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12967 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12969 salt
->salt_len
= salt_len
;
12971 u8 tmp_buf
[100] = { 0 };
12973 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
12975 memcpy (digest
, tmp_buf
, 32);
12977 digest
[0] = byte_swap_32 (digest
[0]);
12978 digest
[1] = byte_swap_32 (digest
[1]);
12979 digest
[2] = byte_swap_32 (digest
[2]);
12980 digest
[3] = byte_swap_32 (digest
[3]);
12981 digest
[4] = byte_swap_32 (digest
[4]);
12982 digest
[5] = byte_swap_32 (digest
[5]);
12983 digest
[6] = byte_swap_32 (digest
[6]);
12984 digest
[7] = byte_swap_32 (digest
[7]);
12986 digest
[0] -= SHA256M_A
;
12987 digest
[1] -= SHA256M_B
;
12988 digest
[2] -= SHA256M_C
;
12989 digest
[3] -= SHA256M_D
;
12990 digest
[4] -= SHA256M_E
;
12991 digest
[5] -= SHA256M_F
;
12992 digest
[6] -= SHA256M_G
;
12993 digest
[7] -= SHA256M_H
;
12995 return (PARSER_OK
);
12998 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13000 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13002 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13004 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13006 u64
*digest
= (u64
*) hash_buf
->digest
;
13008 salt_t
*salt
= hash_buf
->salt
;
13010 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13012 char *iter_pos
= input_buf
+ 19;
13014 char *salt_pos
= strchr (iter_pos
, '.');
13016 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13020 char *hash_pos
= strchr (salt_pos
, '.');
13022 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13024 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13028 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13029 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13030 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13031 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13032 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13033 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13034 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13035 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13037 uint salt_len
= hash_pos
- salt_pos
- 1;
13041 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13045 for (i
= 0; i
< salt_len
; i
++)
13047 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13050 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13051 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13053 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13055 salt
->salt_len
= salt_len
;
13057 salt
->salt_iter
= atoi (iter_pos
) - 1;
13059 return (PARSER_OK
);
13062 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13064 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13066 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13068 u64
*digest
= (u64
*) hash_buf
->digest
;
13070 salt_t
*salt
= hash_buf
->salt
;
13072 u8 tmp_buf
[120] = { 0 };
13074 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13076 memcpy (digest
, tmp_buf
, 64);
13078 digest
[0] = byte_swap_64 (digest
[0]);
13079 digest
[1] = byte_swap_64 (digest
[1]);
13080 digest
[2] = byte_swap_64 (digest
[2]);
13081 digest
[3] = byte_swap_64 (digest
[3]);
13082 digest
[4] = byte_swap_64 (digest
[4]);
13083 digest
[5] = byte_swap_64 (digest
[5]);
13084 digest
[6] = byte_swap_64 (digest
[6]);
13085 digest
[7] = byte_swap_64 (digest
[7]);
13087 digest
[0] -= SHA512M_A
;
13088 digest
[1] -= SHA512M_B
;
13089 digest
[2] -= SHA512M_C
;
13090 digest
[3] -= SHA512M_D
;
13091 digest
[4] -= SHA512M_E
;
13092 digest
[5] -= SHA512M_F
;
13093 digest
[6] -= SHA512M_G
;
13094 digest
[7] -= SHA512M_H
;
13096 salt
->salt_len
= tmp_len
- 64;
13098 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13100 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13102 char *ptr
= (char *) salt
->salt_buf
;
13104 ptr
[salt
->salt_len
] = 0x80;
13107 return (PARSER_OK
);
13110 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13112 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13114 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13118 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13121 u32
*digest
= (u32
*) hash_buf
->digest
;
13123 salt_t
*salt
= hash_buf
->salt
;
13125 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13126 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13127 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13128 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13130 digest
[0] = byte_swap_32 (digest
[0]);
13131 digest
[1] = byte_swap_32 (digest
[1]);
13132 digest
[2] = byte_swap_32 (digest
[2]);
13133 digest
[3] = byte_swap_32 (digest
[3]);
13135 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13137 uint salt_len
= input_len
- 32 - 1;
13139 char *salt_buf
= input_buf
+ 32 + 1;
13141 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13143 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13145 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13147 salt
->salt_len
= salt_len
;
13149 return (PARSER_OK
);
13152 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13154 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13156 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13160 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13163 u32
*digest
= (u32
*) hash_buf
->digest
;
13165 salt_t
*salt
= hash_buf
->salt
;
13167 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13168 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13169 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13170 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13171 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13173 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13175 uint salt_len
= input_len
- 40 - 1;
13177 char *salt_buf
= input_buf
+ 40 + 1;
13179 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13181 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13183 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13185 salt
->salt_len
= salt_len
;
13187 return (PARSER_OK
);
13190 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13192 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13194 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13198 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13201 u32
*digest
= (u32
*) hash_buf
->digest
;
13203 salt_t
*salt
= hash_buf
->salt
;
13205 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13206 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13207 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13208 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13209 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13210 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13211 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13212 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13214 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13216 uint salt_len
= input_len
- 64 - 1;
13218 char *salt_buf
= input_buf
+ 64 + 1;
13220 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13222 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13224 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13226 salt
->salt_len
= salt_len
;
13228 return (PARSER_OK
);
13231 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13233 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13235 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13239 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13242 u64
*digest
= (u64
*) hash_buf
->digest
;
13244 salt_t
*salt
= hash_buf
->salt
;
13246 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13247 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13248 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13249 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13250 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13251 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13252 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13253 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13255 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13257 uint salt_len
= input_len
- 128 - 1;
13259 char *salt_buf
= input_buf
+ 128 + 1;
13261 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13263 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13265 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13267 salt
->salt_len
= salt_len
;
13269 return (PARSER_OK
);
13272 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13274 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13276 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13278 u32
*digest
= (u32
*) hash_buf
->digest
;
13280 salt_t
*salt
= hash_buf
->salt
;
13282 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13288 char *user_pos
= input_buf
+ 10 + 1;
13290 char *realm_pos
= strchr (user_pos
, '$');
13292 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13294 uint user_len
= realm_pos
- user_pos
;
13296 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13300 char *salt_pos
= strchr (realm_pos
, '$');
13302 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13304 uint realm_len
= salt_pos
- realm_pos
;
13306 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13310 char *data_pos
= strchr (salt_pos
, '$');
13312 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13314 uint salt_len
= data_pos
- salt_pos
;
13316 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13320 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13322 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13328 memcpy (krb5pa
->user
, user_pos
, user_len
);
13329 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13330 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13332 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13334 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13336 const char p0
= data_pos
[i
+ 0];
13337 const char p1
= data_pos
[i
+ 1];
13339 *timestamp_ptr
++ = hex_convert (p1
) << 0
13340 | hex_convert (p0
) << 4;
13343 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13345 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13347 const char p0
= data_pos
[i
+ 0];
13348 const char p1
= data_pos
[i
+ 1];
13350 *checksum_ptr
++ = hex_convert (p1
) << 0
13351 | hex_convert (p0
) << 4;
13355 * copy some data to generic buffers to make sorting happy
13358 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13359 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13360 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13361 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13362 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13363 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13364 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13365 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13366 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13368 salt
->salt_len
= 36;
13370 digest
[0] = krb5pa
->checksum
[0];
13371 digest
[1] = krb5pa
->checksum
[1];
13372 digest
[2] = krb5pa
->checksum
[2];
13373 digest
[3] = krb5pa
->checksum
[3];
13375 return (PARSER_OK
);
13378 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13380 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13382 u32
*digest
= (u32
*) hash_buf
->digest
;
13384 salt_t
*salt
= hash_buf
->salt
;
13390 char *salt_pos
= input_buf
;
13392 char *hash_pos
= strchr (salt_pos
, '$');
13394 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13396 uint salt_len
= hash_pos
- salt_pos
;
13398 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13402 uint hash_len
= input_len
- 1 - salt_len
;
13404 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13412 for (uint i
= 0; i
< salt_len
; i
++)
13414 if (salt_pos
[i
] == ' ') continue;
13419 // SAP user names cannot be longer than 12 characters
13420 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13422 // SAP user name cannot start with ! or ?
13423 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13429 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13431 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13433 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13435 salt
->salt_len
= salt_len
;
13437 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13438 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13442 digest
[0] = byte_swap_32 (digest
[0]);
13443 digest
[1] = byte_swap_32 (digest
[1]);
13445 return (PARSER_OK
);
13448 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13450 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13452 u32
*digest
= (u32
*) hash_buf
->digest
;
13454 salt_t
*salt
= hash_buf
->salt
;
13460 char *salt_pos
= input_buf
;
13462 char *hash_pos
= strchr (salt_pos
, '$');
13464 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13466 uint salt_len
= hash_pos
- salt_pos
;
13468 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13472 uint hash_len
= input_len
- 1 - salt_len
;
13474 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13482 for (uint i
= 0; i
< salt_len
; i
++)
13484 if (salt_pos
[i
] == ' ') continue;
13489 // SAP user names cannot be longer than 12 characters
13490 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13491 // so far nobody complained so we stay with this because it helps in optimization
13492 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13494 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13496 // SAP user name cannot start with ! or ?
13497 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13503 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13505 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13507 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13509 salt
->salt_len
= salt_len
;
13511 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13512 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13513 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13514 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13515 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13517 return (PARSER_OK
);
13520 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13522 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13524 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13526 u64
*digest
= (u64
*) hash_buf
->digest
;
13528 salt_t
*salt
= hash_buf
->salt
;
13530 char *iter_pos
= input_buf
+ 3;
13532 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13534 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13536 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13538 salt
->salt_iter
= salt_iter
;
13540 char *salt_pos
= iter_pos
+ 1;
13544 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13546 salt
->salt_len
= salt_len
;
13548 char *hash_pos
= salt_pos
+ salt_len
;
13550 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13554 char *tmp
= (char *) salt
->salt_buf_pc
;
13556 tmp
[0] = hash_pos
[42];
13560 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13561 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13562 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13563 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13569 return (PARSER_OK
);
13572 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13574 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13576 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13578 u32
*digest
= (u32
*) hash_buf
->digest
;
13580 salt_t
*salt
= hash_buf
->salt
;
13582 char *salt_buf
= input_buf
+ 6;
13584 uint salt_len
= 16;
13586 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13588 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13590 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13592 salt
->salt_len
= salt_len
;
13594 char *hash_pos
= input_buf
+ 6 + 16;
13596 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13597 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13598 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13599 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13600 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13601 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13602 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13603 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13605 return (PARSER_OK
);
13608 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13610 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13612 u32
*digest
= (u32
*) hash_buf
->digest
;
13614 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13615 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13619 return (PARSER_OK
);
13622 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13624 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13626 u32
*digest
= (u32
*) hash_buf
->digest
;
13628 salt_t
*salt
= hash_buf
->salt
;
13630 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13632 char *saltbuf_pos
= input_buf
;
13634 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13636 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13638 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13640 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13641 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13643 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13647 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13649 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13651 char *salt_ptr
= (char *) saltbuf_pos
;
13652 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13657 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13659 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13662 rakp_ptr
[j
] = 0x80;
13664 rakp
->salt_len
= j
;
13666 for (i
= 0; i
< 64; i
++)
13668 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13671 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13672 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13673 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13674 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13675 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13676 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13677 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13678 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13680 salt
->salt_len
= 32; // muss min. 32 haben
13682 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13683 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13684 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13685 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13686 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13688 return (PARSER_OK
);
13691 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13693 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13695 u32
*digest
= (u32
*) hash_buf
->digest
;
13697 salt_t
*salt
= hash_buf
->salt
;
13699 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13701 char *salt_pos
= input_buf
+ 1;
13703 memcpy (salt
->salt_buf
, salt_pos
, 8);
13705 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13706 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13708 salt
->salt_len
= 8;
13710 char *hash_pos
= salt_pos
+ 8;
13712 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13713 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13714 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13715 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13716 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13718 digest
[0] -= SHA1M_A
;
13719 digest
[1] -= SHA1M_B
;
13720 digest
[2] -= SHA1M_C
;
13721 digest
[3] -= SHA1M_D
;
13722 digest
[4] -= SHA1M_E
;
13724 return (PARSER_OK
);
13727 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13729 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13731 u32
*digest
= (u32
*) hash_buf
->digest
;
13733 salt_t
*salt
= hash_buf
->salt
;
13735 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13736 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13737 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13738 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13740 digest
[0] = byte_swap_32 (digest
[0]);
13741 digest
[1] = byte_swap_32 (digest
[1]);
13742 digest
[2] = byte_swap_32 (digest
[2]);
13743 digest
[3] = byte_swap_32 (digest
[3]);
13745 digest
[0] -= MD5M_A
;
13746 digest
[1] -= MD5M_B
;
13747 digest
[2] -= MD5M_C
;
13748 digest
[3] -= MD5M_D
;
13750 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13752 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13754 u32
*salt_buf
= salt
->salt_buf
;
13756 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13757 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13758 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13759 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13761 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13762 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13763 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13764 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13766 salt
->salt_len
= 16 + 1;
13768 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13770 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13772 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13774 return (PARSER_OK
);
13777 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13779 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13781 u32
*digest
= (u32
*) hash_buf
->digest
;
13783 salt_t
*salt
= hash_buf
->salt
;
13785 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13791 char *hashbuf_pos
= input_buf
;
13793 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13795 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13797 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13799 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13803 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13805 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13807 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13809 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13813 char *databuf_pos
= strchr (iteration_pos
, ':');
13815 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13817 const uint iteration_len
= databuf_pos
- iteration_pos
;
13819 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13820 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13822 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13824 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13825 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13831 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13832 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13833 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13834 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13835 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13836 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13837 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13838 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13842 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13844 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13846 const char p0
= saltbuf_pos
[i
+ 0];
13847 const char p1
= saltbuf_pos
[i
+ 1];
13849 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13850 | hex_convert (p0
) << 4;
13853 salt
->salt_buf
[4] = 0x01000000;
13854 salt
->salt_buf
[5] = 0x80;
13856 salt
->salt_len
= saltbuf_len
/ 2;
13860 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13864 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13866 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13868 const char p0
= databuf_pos
[i
+ 0];
13869 const char p1
= databuf_pos
[i
+ 1];
13871 *databuf_ptr
++ = hex_convert (p1
) << 0
13872 | hex_convert (p0
) << 4;
13875 *databuf_ptr
++ = 0x80;
13877 for (uint i
= 0; i
< 512; i
++)
13879 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13882 cloudkey
->data_len
= databuf_len
/ 2;
13884 return (PARSER_OK
);
13887 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13889 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13891 u32
*digest
= (u32
*) hash_buf
->digest
;
13893 salt_t
*salt
= hash_buf
->salt
;
13899 char *hashbuf_pos
= input_buf
;
13901 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13903 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13905 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13907 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13911 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13913 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13915 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13917 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13919 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13923 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13925 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13927 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13929 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13931 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13935 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13937 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13938 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13940 // ok, the plan for this algorithm is the following:
13941 // we have 2 salts here, the domain-name and a random salt
13942 // while both are used in the initial transformation,
13943 // only the random salt is used in the following iterations
13944 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13945 // and one that includes only the real salt (stored into salt_buf[]).
13946 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13948 u8 tmp_buf
[100] = { 0 };
13950 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
13952 memcpy (digest
, tmp_buf
, 20);
13954 digest
[0] = byte_swap_32 (digest
[0]);
13955 digest
[1] = byte_swap_32 (digest
[1]);
13956 digest
[2] = byte_swap_32 (digest
[2]);
13957 digest
[3] = byte_swap_32 (digest
[3]);
13958 digest
[4] = byte_swap_32 (digest
[4]);
13962 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13964 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13966 char *len_ptr
= NULL
;
13968 for (uint i
= 0; i
< domainbuf_len
; i
++)
13970 if (salt_buf_pc_ptr
[i
] == '.')
13972 len_ptr
= &salt_buf_pc_ptr
[i
];
13982 salt
->salt_buf_pc
[7] = domainbuf_len
;
13986 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13988 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13990 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13992 salt
->salt_len
= salt_len
;
13996 salt
->salt_iter
= atoi (iteration_pos
);
13998 return (PARSER_OK
);
14001 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14003 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14005 u32
*digest
= (u32
*) hash_buf
->digest
;
14007 salt_t
*salt
= hash_buf
->salt
;
14009 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14010 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14011 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14012 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14013 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14015 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14017 uint salt_len
= input_len
- 40 - 1;
14019 char *salt_buf
= input_buf
+ 40 + 1;
14021 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14023 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14025 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14027 salt
->salt_len
= salt_len
;
14029 return (PARSER_OK
);
14032 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14034 const u8 ascii_to_ebcdic
[] =
14036 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14037 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14038 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14039 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14040 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14041 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14042 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14043 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14044 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14045 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14046 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14047 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14048 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14049 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14050 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14051 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14054 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14056 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14058 u32
*digest
= (u32
*) hash_buf
->digest
;
14060 salt_t
*salt
= hash_buf
->salt
;
14062 char *salt_pos
= input_buf
+ 6 + 1;
14064 char *digest_pos
= strchr (salt_pos
, '*');
14066 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14068 uint salt_len
= digest_pos
- salt_pos
;
14070 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14072 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14074 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14078 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14079 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14081 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14083 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14085 salt
->salt_len
= salt_len
;
14087 for (uint i
= 0; i
< salt_len
; i
++)
14089 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14091 for (uint i
= salt_len
; i
< 8; i
++)
14093 salt_buf_pc_ptr
[i
] = 0x40;
14098 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14100 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14101 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14103 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14104 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14106 digest
[0] = byte_swap_32 (digest
[0]);
14107 digest
[1] = byte_swap_32 (digest
[1]);
14109 IP (digest
[0], digest
[1], tt
);
14111 digest
[0] = rotr32 (digest
[0], 29);
14112 digest
[1] = rotr32 (digest
[1], 29);
14116 return (PARSER_OK
);
14119 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14121 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14123 u32
*digest
= (u32
*) hash_buf
->digest
;
14125 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14126 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14127 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14128 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14130 digest
[0] = byte_swap_32 (digest
[0]);
14131 digest
[1] = byte_swap_32 (digest
[1]);
14132 digest
[2] = byte_swap_32 (digest
[2]);
14133 digest
[3] = byte_swap_32 (digest
[3]);
14135 return (PARSER_OK
);
14138 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14140 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14142 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14144 u32
*digest
= (u32
*) hash_buf
->digest
;
14146 salt_t
*salt
= hash_buf
->salt
;
14148 u8 tmp_buf
[120] = { 0 };
14150 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14152 tmp_buf
[3] += -4; // dont ask!
14154 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14156 salt
->salt_len
= 5;
14158 memcpy (digest
, tmp_buf
+ 5, 9);
14160 // yes, only 9 byte are needed to crack, but 10 to display
14162 salt
->salt_buf_pc
[7] = input_buf
[20];
14164 return (PARSER_OK
);
14167 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14169 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14171 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14173 u32
*digest
= (u32
*) hash_buf
->digest
;
14175 salt_t
*salt
= hash_buf
->salt
;
14177 u8 tmp_buf
[120] = { 0 };
14179 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14181 tmp_buf
[3] += -4; // dont ask!
14185 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14187 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)
14191 char tmp_iter_buf
[11] = { 0 };
14193 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14195 tmp_iter_buf
[10] = 0;
14197 salt
->salt_iter
= atoi (tmp_iter_buf
);
14199 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14201 return (PARSER_SALT_ITERATION
);
14204 salt
->salt_iter
--; // first round in init
14206 // 2 additional bytes for display only
14208 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14209 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14213 memcpy (digest
, tmp_buf
+ 28, 8);
14215 digest
[0] = byte_swap_32 (digest
[0]);
14216 digest
[1] = byte_swap_32 (digest
[1]);
14220 return (PARSER_OK
);
14223 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14225 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14227 u32
*digest
= (u32
*) hash_buf
->digest
;
14229 salt_t
*salt
= hash_buf
->salt
;
14231 char *salt_buf_pos
= input_buf
;
14233 char *hash_buf_pos
= salt_buf_pos
+ 6;
14235 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14236 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14237 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14238 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14239 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14240 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14241 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14242 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14244 digest
[0] -= SHA256M_A
;
14245 digest
[1] -= SHA256M_B
;
14246 digest
[2] -= SHA256M_C
;
14247 digest
[3] -= SHA256M_D
;
14248 digest
[4] -= SHA256M_E
;
14249 digest
[5] -= SHA256M_F
;
14250 digest
[6] -= SHA256M_G
;
14251 digest
[7] -= SHA256M_H
;
14253 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14255 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14257 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14259 salt
->salt_len
= salt_len
;
14261 return (PARSER_OK
);
14264 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14266 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14268 u32
*digest
= (u32
*) hash_buf
->digest
;
14270 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14272 salt_t
*salt
= hash_buf
->salt
;
14274 char *salt_buf
= input_buf
+ 6;
14276 char *digest_buf
= strchr (salt_buf
, '$');
14278 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14280 uint salt_len
= digest_buf
- salt_buf
;
14282 digest_buf
++; // skip the '$' symbol
14284 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14286 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14288 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14290 salt
->salt_len
= salt_len
;
14292 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14293 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14294 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14295 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14297 digest
[0] = byte_swap_32 (digest
[0]);
14298 digest
[1] = byte_swap_32 (digest
[1]);
14299 digest
[2] = byte_swap_32 (digest
[2]);
14300 digest
[3] = byte_swap_32 (digest
[3]);
14302 digest
[0] -= MD5M_A
;
14303 digest
[1] -= MD5M_B
;
14304 digest
[2] -= MD5M_C
;
14305 digest
[3] -= MD5M_D
;
14307 return (PARSER_OK
);
14310 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14312 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14314 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14316 u32
*digest
= (u32
*) hash_buf
->digest
;
14318 salt_t
*salt
= hash_buf
->salt
;
14320 char *salt_buf
= input_buf
+ 3;
14322 char *digest_buf
= strchr (salt_buf
, '$');
14324 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14326 uint salt_len
= digest_buf
- salt_buf
;
14328 digest_buf
++; // skip the '$' symbol
14330 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14332 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14334 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14336 salt_buf_ptr
[salt_len
] = 0x2d;
14338 salt
->salt_len
= salt_len
+ 1;
14340 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14341 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14342 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14343 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14345 digest
[0] = byte_swap_32 (digest
[0]);
14346 digest
[1] = byte_swap_32 (digest
[1]);
14347 digest
[2] = byte_swap_32 (digest
[2]);
14348 digest
[3] = byte_swap_32 (digest
[3]);
14350 digest
[0] -= MD5M_A
;
14351 digest
[1] -= MD5M_B
;
14352 digest
[2] -= MD5M_C
;
14353 digest
[3] -= MD5M_D
;
14355 return (PARSER_OK
);
14358 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14360 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14362 u32
*digest
= (u32
*) hash_buf
->digest
;
14364 u8 tmp_buf
[100] = { 0 };
14366 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14368 memcpy (digest
, tmp_buf
, 20);
14370 digest
[0] = byte_swap_32 (digest
[0]);
14371 digest
[1] = byte_swap_32 (digest
[1]);
14372 digest
[2] = byte_swap_32 (digest
[2]);
14373 digest
[3] = byte_swap_32 (digest
[3]);
14374 digest
[4] = byte_swap_32 (digest
[4]);
14376 digest
[0] -= SHA1M_A
;
14377 digest
[1] -= SHA1M_B
;
14378 digest
[2] -= SHA1M_C
;
14379 digest
[3] -= SHA1M_D
;
14380 digest
[4] -= SHA1M_E
;
14382 return (PARSER_OK
);
14385 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14387 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14389 u32
*digest
= (u32
*) hash_buf
->digest
;
14391 salt_t
*salt
= hash_buf
->salt
;
14393 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14394 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14395 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14396 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14398 digest
[0] = byte_swap_32 (digest
[0]);
14399 digest
[1] = byte_swap_32 (digest
[1]);
14400 digest
[2] = byte_swap_32 (digest
[2]);
14401 digest
[3] = byte_swap_32 (digest
[3]);
14403 digest
[0] -= MD5M_A
;
14404 digest
[1] -= MD5M_B
;
14405 digest
[2] -= MD5M_C
;
14406 digest
[3] -= MD5M_D
;
14408 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14410 uint salt_len
= input_len
- 32 - 1;
14412 char *salt_buf
= input_buf
+ 32 + 1;
14414 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14416 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14418 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14421 * add static "salt" part
14424 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14428 salt
->salt_len
= salt_len
;
14430 return (PARSER_OK
);
14433 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14435 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14437 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14439 u32
*digest
= (u32
*) hash_buf
->digest
;
14441 salt_t
*salt
= hash_buf
->salt
;
14443 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14449 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14451 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14453 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14455 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14457 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14461 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14463 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14465 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14467 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14471 char *keybuf_pos
= strchr (keylen_pos
, '$');
14473 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14475 uint keylen_len
= keybuf_pos
- keylen_pos
;
14477 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14481 char *databuf_pos
= strchr (keybuf_pos
, '$');
14483 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14485 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14487 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14491 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14493 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14499 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14500 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14501 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14502 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14504 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14505 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14506 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14507 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14509 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14510 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14511 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14512 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14514 salt
->salt_len
= 16;
14515 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14517 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14519 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14522 return (PARSER_OK
);
14525 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14527 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14529 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14531 u32
*digest
= (u32
*) hash_buf
->digest
;
14533 salt_t
*salt
= hash_buf
->salt
;
14539 // first is the N salt parameter
14541 char *N_pos
= input_buf
+ 6;
14543 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14547 salt
->scrypt_N
= atoi (N_pos
);
14551 char *r_pos
= strchr (N_pos
, ':');
14553 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14557 salt
->scrypt_r
= atoi (r_pos
);
14561 char *p_pos
= strchr (r_pos
, ':');
14563 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14567 salt
->scrypt_p
= atoi (p_pos
);
14571 char *saltbuf_pos
= strchr (p_pos
, ':');
14573 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14577 char *hash_pos
= strchr (saltbuf_pos
, ':');
14579 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14585 u8 tmp_buf
[33] = { 0 };
14587 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14589 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14591 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14593 salt
->salt_len
= tmp_len
;
14594 salt
->salt_iter
= 1;
14596 // digest - base64 decode
14598 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14600 tmp_len
= input_len
- (hash_pos
- input_buf
);
14602 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14604 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14606 memcpy (digest
, tmp_buf
, 32);
14608 return (PARSER_OK
);
14611 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14613 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14615 u32
*digest
= (u32
*) hash_buf
->digest
;
14617 salt_t
*salt
= hash_buf
->salt
;
14623 char decrypted
[76] = { 0 }; // iv + hash
14625 juniper_decrypt_hash (input_buf
, decrypted
);
14627 char *md5crypt_hash
= decrypted
+ 12;
14629 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14631 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14633 char *salt_pos
= md5crypt_hash
+ 3;
14635 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14637 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14639 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14643 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14645 return (PARSER_OK
);
14648 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14650 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14652 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14654 u32
*digest
= (u32
*) hash_buf
->digest
;
14656 salt_t
*salt
= hash_buf
->salt
;
14658 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14664 // first is *raw* salt
14666 char *salt_pos
= input_buf
+ 3;
14668 char *hash_pos
= strchr (salt_pos
, '$');
14670 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14672 uint salt_len
= hash_pos
- salt_pos
;
14674 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14678 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14680 memcpy (salt_buf_ptr
, salt_pos
, 14);
14682 salt_buf_ptr
[17] = 0x01;
14683 salt_buf_ptr
[18] = 0x80;
14685 // add some stuff to normal salt to make sorted happy
14687 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14688 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14689 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14690 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14692 salt
->salt_len
= salt_len
;
14693 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14695 // base64 decode hash
14697 u8 tmp_buf
[100] = { 0 };
14699 uint hash_len
= input_len
- 3 - salt_len
- 1;
14701 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14703 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14705 memcpy (digest
, tmp_buf
, 32);
14707 digest
[0] = byte_swap_32 (digest
[0]);
14708 digest
[1] = byte_swap_32 (digest
[1]);
14709 digest
[2] = byte_swap_32 (digest
[2]);
14710 digest
[3] = byte_swap_32 (digest
[3]);
14711 digest
[4] = byte_swap_32 (digest
[4]);
14712 digest
[5] = byte_swap_32 (digest
[5]);
14713 digest
[6] = byte_swap_32 (digest
[6]);
14714 digest
[7] = byte_swap_32 (digest
[7]);
14716 return (PARSER_OK
);
14719 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14721 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14723 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14725 u32
*digest
= (u32
*) hash_buf
->digest
;
14727 salt_t
*salt
= hash_buf
->salt
;
14733 // first is *raw* salt
14735 char *salt_pos
= input_buf
+ 3;
14737 char *hash_pos
= strchr (salt_pos
, '$');
14739 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14741 uint salt_len
= hash_pos
- salt_pos
;
14743 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14745 salt
->salt_len
= salt_len
;
14748 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14750 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14751 salt_buf_ptr
[salt_len
] = 0;
14753 // base64 decode hash
14755 u8 tmp_buf
[100] = { 0 };
14757 uint hash_len
= input_len
- 3 - salt_len
- 1;
14759 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14761 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14763 memcpy (digest
, tmp_buf
, 32);
14766 salt
->scrypt_N
= 16384;
14767 salt
->scrypt_r
= 1;
14768 salt
->scrypt_p
= 1;
14769 salt
->salt_iter
= 1;
14771 return (PARSER_OK
);
14774 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14776 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14778 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14780 u32
*digest
= (u32
*) hash_buf
->digest
;
14782 salt_t
*salt
= hash_buf
->salt
;
14784 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14790 char *version_pos
= input_buf
+ 8 + 1;
14792 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14794 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14796 u32 version_len
= verifierHashSize_pos
- version_pos
;
14798 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14800 verifierHashSize_pos
++;
14802 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14804 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14806 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14808 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14812 char *saltSize_pos
= strchr (keySize_pos
, '*');
14814 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14816 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14818 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14822 char *osalt_pos
= strchr (saltSize_pos
, '*');
14824 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14826 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14828 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14832 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14834 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14836 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14838 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14840 encryptedVerifier_pos
++;
14842 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14844 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14846 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14848 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14850 encryptedVerifierHash_pos
++;
14852 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;
14854 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14856 const uint version
= atoi (version_pos
);
14858 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14860 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14862 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14864 const uint keySize
= atoi (keySize_pos
);
14866 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14868 office2007
->keySize
= keySize
;
14870 const uint saltSize
= atoi (saltSize_pos
);
14872 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14878 salt
->salt_len
= 16;
14879 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14881 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14882 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14883 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14884 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14890 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14891 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14892 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14893 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14895 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14896 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14897 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14898 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14899 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14905 digest
[0] = office2007
->encryptedVerifierHash
[0];
14906 digest
[1] = office2007
->encryptedVerifierHash
[1];
14907 digest
[2] = office2007
->encryptedVerifierHash
[2];
14908 digest
[3] = office2007
->encryptedVerifierHash
[3];
14910 return (PARSER_OK
);
14913 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14915 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14917 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14919 u32
*digest
= (u32
*) hash_buf
->digest
;
14921 salt_t
*salt
= hash_buf
->salt
;
14923 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14929 char *version_pos
= input_buf
+ 8 + 1;
14931 char *spinCount_pos
= strchr (version_pos
, '*');
14933 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14935 u32 version_len
= spinCount_pos
- version_pos
;
14937 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14941 char *keySize_pos
= strchr (spinCount_pos
, '*');
14943 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14945 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
14947 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14951 char *saltSize_pos
= strchr (keySize_pos
, '*');
14953 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14955 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14957 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14961 char *osalt_pos
= strchr (saltSize_pos
, '*');
14963 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14965 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14967 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14971 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14973 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14975 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14977 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14979 encryptedVerifier_pos
++;
14981 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14983 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14985 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14987 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14989 encryptedVerifierHash_pos
++;
14991 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;
14993 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14995 const uint version
= atoi (version_pos
);
14997 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14999 const uint spinCount
= atoi (spinCount_pos
);
15001 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15003 const uint keySize
= atoi (keySize_pos
);
15005 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15007 const uint saltSize
= atoi (saltSize_pos
);
15009 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15015 salt
->salt_len
= 16;
15016 salt
->salt_iter
= spinCount
;
15018 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15019 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15020 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15021 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15027 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15028 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15029 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15030 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15032 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15033 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15034 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15035 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15036 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15037 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15038 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15039 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15045 digest
[0] = office2010
->encryptedVerifierHash
[0];
15046 digest
[1] = office2010
->encryptedVerifierHash
[1];
15047 digest
[2] = office2010
->encryptedVerifierHash
[2];
15048 digest
[3] = office2010
->encryptedVerifierHash
[3];
15050 return (PARSER_OK
);
15053 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15055 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15057 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15059 u32
*digest
= (u32
*) hash_buf
->digest
;
15061 salt_t
*salt
= hash_buf
->salt
;
15063 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15069 char *version_pos
= input_buf
+ 8 + 1;
15071 char *spinCount_pos
= strchr (version_pos
, '*');
15073 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15075 u32 version_len
= spinCount_pos
- version_pos
;
15077 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15081 char *keySize_pos
= strchr (spinCount_pos
, '*');
15083 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15085 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15087 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15091 char *saltSize_pos
= strchr (keySize_pos
, '*');
15093 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15095 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15097 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15101 char *osalt_pos
= strchr (saltSize_pos
, '*');
15103 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15105 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15107 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15111 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15113 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15115 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15117 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15119 encryptedVerifier_pos
++;
15121 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15123 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15125 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15127 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15129 encryptedVerifierHash_pos
++;
15131 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;
15133 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15135 const uint version
= atoi (version_pos
);
15137 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15139 const uint spinCount
= atoi (spinCount_pos
);
15141 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15143 const uint keySize
= atoi (keySize_pos
);
15145 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15147 const uint saltSize
= atoi (saltSize_pos
);
15149 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15155 salt
->salt_len
= 16;
15156 salt
->salt_iter
= spinCount
;
15158 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15159 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15160 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15161 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15167 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15168 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15169 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15170 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15172 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15173 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15174 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15175 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15176 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15177 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15178 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15179 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15185 digest
[0] = office2013
->encryptedVerifierHash
[0];
15186 digest
[1] = office2013
->encryptedVerifierHash
[1];
15187 digest
[2] = office2013
->encryptedVerifierHash
[2];
15188 digest
[3] = office2013
->encryptedVerifierHash
[3];
15190 return (PARSER_OK
);
15193 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15195 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15197 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15199 u32
*digest
= (u32
*) hash_buf
->digest
;
15201 salt_t
*salt
= hash_buf
->salt
;
15203 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15209 char *version_pos
= input_buf
+ 11;
15211 char *osalt_pos
= strchr (version_pos
, '*');
15213 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15215 u32 version_len
= osalt_pos
- version_pos
;
15217 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15221 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15223 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15225 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15227 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15229 encryptedVerifier_pos
++;
15231 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15233 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15235 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15237 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15239 encryptedVerifierHash_pos
++;
15241 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15243 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15245 const uint version
= *version_pos
- 0x30;
15247 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15253 oldoffice01
->version
= version
;
15255 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15256 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15257 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15258 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15260 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15261 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15262 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15263 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15265 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15266 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15267 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15268 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15270 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15271 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15272 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15273 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15279 salt
->salt_len
= 16;
15281 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15282 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15283 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15284 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15286 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15287 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15288 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15289 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15291 // this is a workaround as office produces multiple documents with the same salt
15293 salt
->salt_len
+= 32;
15295 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15296 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15297 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15298 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15299 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15300 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15301 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15302 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15308 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15309 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15310 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15311 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15313 return (PARSER_OK
);
15316 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15318 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15321 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15323 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15325 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15327 u32
*digest
= (u32
*) hash_buf
->digest
;
15329 salt_t
*salt
= hash_buf
->salt
;
15331 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15337 char *version_pos
= input_buf
+ 11;
15339 char *osalt_pos
= strchr (version_pos
, '*');
15341 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15343 u32 version_len
= osalt_pos
- version_pos
;
15345 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15349 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15351 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15353 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15355 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15357 encryptedVerifier_pos
++;
15359 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15361 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15363 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15365 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15367 encryptedVerifierHash_pos
++;
15369 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15371 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15373 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15375 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15379 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15381 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15383 const uint version
= *version_pos
- 0x30;
15385 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15391 oldoffice01
->version
= version
;
15393 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15394 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15395 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15396 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15398 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15399 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15400 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15401 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15403 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15404 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15405 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15406 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15408 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15409 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15410 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15411 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15413 oldoffice01
->rc4key
[1] = 0;
15414 oldoffice01
->rc4key
[0] = 0;
15416 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15417 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15418 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15419 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15420 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15421 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15422 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15423 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15424 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15425 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15427 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15428 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15434 salt
->salt_len
= 16;
15436 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15437 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15438 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15439 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15441 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15442 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15443 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15444 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15446 // this is a workaround as office produces multiple documents with the same salt
15448 salt
->salt_len
+= 32;
15450 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15451 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15452 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15453 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15454 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15455 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15456 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15457 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15463 digest
[0] = oldoffice01
->rc4key
[0];
15464 digest
[1] = oldoffice01
->rc4key
[1];
15468 return (PARSER_OK
);
15471 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15473 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15475 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15477 u32
*digest
= (u32
*) hash_buf
->digest
;
15479 salt_t
*salt
= hash_buf
->salt
;
15481 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15487 char *version_pos
= input_buf
+ 11;
15489 char *osalt_pos
= strchr (version_pos
, '*');
15491 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15493 u32 version_len
= osalt_pos
- version_pos
;
15495 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15499 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15501 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15503 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15505 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15507 encryptedVerifier_pos
++;
15509 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15511 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15513 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15515 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15517 encryptedVerifierHash_pos
++;
15519 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15521 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15523 const uint version
= *version_pos
- 0x30;
15525 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15531 oldoffice34
->version
= version
;
15533 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15534 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15535 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15536 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15538 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15539 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15540 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15541 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15543 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15544 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15545 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15546 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15547 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15549 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15550 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15551 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15552 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15553 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15559 salt
->salt_len
= 16;
15561 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15562 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15563 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15564 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15566 // this is a workaround as office produces multiple documents with the same salt
15568 salt
->salt_len
+= 32;
15570 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15571 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15572 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15573 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15574 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15575 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15576 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15577 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15583 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15584 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15585 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15586 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15588 return (PARSER_OK
);
15591 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15593 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15595 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15598 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15600 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15602 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15604 u32
*digest
= (u32
*) hash_buf
->digest
;
15606 salt_t
*salt
= hash_buf
->salt
;
15608 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15614 char *version_pos
= input_buf
+ 11;
15616 char *osalt_pos
= strchr (version_pos
, '*');
15618 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15620 u32 version_len
= osalt_pos
- version_pos
;
15622 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15626 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15628 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15630 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15632 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15634 encryptedVerifier_pos
++;
15636 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15638 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15640 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15642 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15644 encryptedVerifierHash_pos
++;
15646 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15648 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15650 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15652 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15656 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15658 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15660 const uint version
= *version_pos
- 0x30;
15662 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15668 oldoffice34
->version
= version
;
15670 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15671 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15672 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15673 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15675 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15676 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15677 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15678 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15680 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15681 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15682 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15683 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15684 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15686 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15687 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15688 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15689 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15690 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15692 oldoffice34
->rc4key
[1] = 0;
15693 oldoffice34
->rc4key
[0] = 0;
15695 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15696 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15697 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15698 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15699 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15700 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15701 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15702 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15703 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15704 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15706 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15707 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15713 salt
->salt_len
= 16;
15715 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15716 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15717 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15718 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15720 // this is a workaround as office produces multiple documents with the same salt
15722 salt
->salt_len
+= 32;
15724 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15725 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15726 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15727 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15728 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15729 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15730 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15731 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15737 digest
[0] = oldoffice34
->rc4key
[0];
15738 digest
[1] = oldoffice34
->rc4key
[1];
15742 return (PARSER_OK
);
15745 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15747 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15749 u32
*digest
= (u32
*) hash_buf
->digest
;
15751 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15752 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15753 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15754 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15756 digest
[0] = byte_swap_32 (digest
[0]);
15757 digest
[1] = byte_swap_32 (digest
[1]);
15758 digest
[2] = byte_swap_32 (digest
[2]);
15759 digest
[3] = byte_swap_32 (digest
[3]);
15761 return (PARSER_OK
);
15764 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15766 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15768 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15770 u32
*digest
= (u32
*) hash_buf
->digest
;
15772 salt_t
*salt
= hash_buf
->salt
;
15774 char *signature_pos
= input_buf
;
15776 char *salt_pos
= strchr (signature_pos
, '$');
15778 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15780 u32 signature_len
= salt_pos
- signature_pos
;
15782 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15786 char *hash_pos
= strchr (salt_pos
, '$');
15788 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15790 u32 salt_len
= hash_pos
- salt_pos
;
15792 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15796 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15798 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15800 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15801 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15802 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15803 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15804 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15806 digest
[0] -= SHA1M_A
;
15807 digest
[1] -= SHA1M_B
;
15808 digest
[2] -= SHA1M_C
;
15809 digest
[3] -= SHA1M_D
;
15810 digest
[4] -= SHA1M_E
;
15812 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15814 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15816 salt
->salt_len
= salt_len
;
15818 return (PARSER_OK
);
15821 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15823 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15825 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15827 u32
*digest
= (u32
*) hash_buf
->digest
;
15829 salt_t
*salt
= hash_buf
->salt
;
15831 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15837 char *iter_pos
= input_buf
+ 14;
15839 const int iter
= atoi (iter_pos
);
15841 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15843 salt
->salt_iter
= iter
- 1;
15845 char *salt_pos
= strchr (iter_pos
, '$');
15847 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15851 char *hash_pos
= strchr (salt_pos
, '$');
15853 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15855 const uint salt_len
= hash_pos
- salt_pos
;
15859 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15861 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15863 salt
->salt_len
= salt_len
;
15865 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15866 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15868 // add some stuff to normal salt to make sorted happy
15870 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15871 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15872 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15873 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15874 salt
->salt_buf
[4] = salt
->salt_iter
;
15876 // base64 decode hash
15878 u8 tmp_buf
[100] = { 0 };
15880 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15882 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15884 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15886 memcpy (digest
, tmp_buf
, 32);
15888 digest
[0] = byte_swap_32 (digest
[0]);
15889 digest
[1] = byte_swap_32 (digest
[1]);
15890 digest
[2] = byte_swap_32 (digest
[2]);
15891 digest
[3] = byte_swap_32 (digest
[3]);
15892 digest
[4] = byte_swap_32 (digest
[4]);
15893 digest
[5] = byte_swap_32 (digest
[5]);
15894 digest
[6] = byte_swap_32 (digest
[6]);
15895 digest
[7] = byte_swap_32 (digest
[7]);
15897 return (PARSER_OK
);
15900 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15902 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15904 u32
*digest
= (u32
*) hash_buf
->digest
;
15906 salt_t
*salt
= hash_buf
->salt
;
15908 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15909 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15913 digest
[0] = byte_swap_32 (digest
[0]);
15914 digest
[1] = byte_swap_32 (digest
[1]);
15916 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15917 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15918 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15920 char iter_c
= input_buf
[17];
15921 char iter_d
= input_buf
[19];
15923 // atm only defaults, let's see if there's more request
15924 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15925 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15927 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15929 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15930 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15931 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15932 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15934 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15935 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15936 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15937 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15939 salt
->salt_len
= 16;
15941 return (PARSER_OK
);
15944 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15946 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15948 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15950 u32
*digest
= (u32
*) hash_buf
->digest
;
15952 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15954 salt_t
*salt
= hash_buf
->salt
;
15956 char *salt_pos
= input_buf
+ 10;
15958 char *hash_pos
= strchr (salt_pos
, '$');
15960 uint salt_len
= hash_pos
- salt_pos
;
15962 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15966 uint hash_len
= input_len
- 10 - salt_len
- 1;
15968 // base64 decode salt
15970 u8 tmp_buf
[100] = { 0 };
15972 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
15974 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15976 tmp_buf
[salt_len
] = 0x80;
15978 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15980 salt
->salt_len
= salt_len
;
15982 // base64 decode salt
15984 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15986 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15988 uint user_len
= hash_len
- 32;
15990 const u8
*tmp_hash
= tmp_buf
+ user_len
;
15992 user_len
--; // skip the trailing space
15994 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
15995 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
15996 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
15997 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
15999 digest
[0] = byte_swap_32 (digest
[0]);
16000 digest
[1] = byte_swap_32 (digest
[1]);
16001 digest
[2] = byte_swap_32 (digest
[2]);
16002 digest
[3] = byte_swap_32 (digest
[3]);
16004 // store username for host only (output hash if cracked)
16006 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16007 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16009 return (PARSER_OK
);
16012 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16014 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16016 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16018 u32
*digest
= (u32
*) hash_buf
->digest
;
16020 salt_t
*salt
= hash_buf
->salt
;
16022 char *iter_pos
= input_buf
+ 10;
16024 u32 iter
= atoi (iter_pos
);
16028 return (PARSER_SALT_ITERATION
);
16031 iter
--; // first iteration is special
16033 salt
->salt_iter
= iter
;
16035 char *base64_pos
= strchr (iter_pos
, '}');
16037 if (base64_pos
== NULL
)
16039 return (PARSER_SIGNATURE_UNMATCHED
);
16044 // base64 decode salt
16046 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16048 u8 tmp_buf
[100] = { 0 };
16050 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16052 if (decoded_len
< 24)
16054 return (PARSER_SALT_LENGTH
);
16059 uint salt_len
= decoded_len
- 20;
16061 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16062 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16064 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16066 salt
->salt_len
= salt_len
;
16070 u32
*digest_ptr
= (u32
*) tmp_buf
;
16072 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16073 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16074 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16075 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16076 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16078 return (PARSER_OK
);
16081 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16083 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16085 u32
*digest
= (u32
*) hash_buf
->digest
;
16087 salt_t
*salt
= hash_buf
->salt
;
16089 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16090 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16091 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16092 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16093 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16095 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16097 uint salt_len
= input_len
- 40 - 1;
16099 char *salt_buf
= input_buf
+ 40 + 1;
16101 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16103 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16105 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16107 salt
->salt_len
= salt_len
;
16109 return (PARSER_OK
);
16112 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16114 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16116 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16118 u32
*digest
= (u32
*) hash_buf
->digest
;
16120 salt_t
*salt
= hash_buf
->salt
;
16122 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16128 char *V_pos
= input_buf
+ 5;
16130 char *R_pos
= strchr (V_pos
, '*');
16132 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16134 u32 V_len
= R_pos
- V_pos
;
16138 char *bits_pos
= strchr (R_pos
, '*');
16140 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16142 u32 R_len
= bits_pos
- R_pos
;
16146 char *P_pos
= strchr (bits_pos
, '*');
16148 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16150 u32 bits_len
= P_pos
- bits_pos
;
16154 char *enc_md_pos
= strchr (P_pos
, '*');
16156 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16158 u32 P_len
= enc_md_pos
- P_pos
;
16162 char *id_len_pos
= strchr (enc_md_pos
, '*');
16164 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16166 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16170 char *id_buf_pos
= strchr (id_len_pos
, '*');
16172 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16174 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16178 char *u_len_pos
= strchr (id_buf_pos
, '*');
16180 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16182 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16184 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16188 char *u_buf_pos
= strchr (u_len_pos
, '*');
16190 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16192 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16196 char *o_len_pos
= strchr (u_buf_pos
, '*');
16198 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16200 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16202 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16206 char *o_buf_pos
= strchr (o_len_pos
, '*');
16208 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16210 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16214 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;
16216 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16220 const int V
= atoi (V_pos
);
16221 const int R
= atoi (R_pos
);
16222 const int P
= atoi (P_pos
);
16224 if (V
!= 1) return (PARSER_SALT_VALUE
);
16225 if (R
!= 2) return (PARSER_SALT_VALUE
);
16227 const int enc_md
= atoi (enc_md_pos
);
16229 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16231 const int id_len
= atoi (id_len_pos
);
16232 const int u_len
= atoi (u_len_pos
);
16233 const int o_len
= atoi (o_len_pos
);
16235 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16236 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16237 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16239 const int bits
= atoi (bits_pos
);
16241 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16243 // copy data to esalt
16249 pdf
->enc_md
= enc_md
;
16251 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16252 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16253 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16254 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16255 pdf
->id_len
= id_len
;
16257 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16258 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16259 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16260 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16261 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16262 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16263 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16264 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16265 pdf
->u_len
= u_len
;
16267 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16268 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16269 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16270 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16271 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16272 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16273 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16274 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16275 pdf
->o_len
= o_len
;
16277 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16278 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16279 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16280 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16282 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16283 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16284 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16285 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16286 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16287 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16288 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16289 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16291 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16292 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16293 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16294 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16295 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16296 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16297 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16298 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16300 // we use ID for salt, maybe needs to change, we will see...
16302 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16303 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16304 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16305 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16306 salt
->salt_len
= pdf
->id_len
;
16308 digest
[0] = pdf
->u_buf
[0];
16309 digest
[1] = pdf
->u_buf
[1];
16310 digest
[2] = pdf
->u_buf
[2];
16311 digest
[3] = pdf
->u_buf
[3];
16313 return (PARSER_OK
);
16316 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16318 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16321 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16323 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16325 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16327 u32
*digest
= (u32
*) hash_buf
->digest
;
16329 salt_t
*salt
= hash_buf
->salt
;
16331 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16337 char *V_pos
= input_buf
+ 5;
16339 char *R_pos
= strchr (V_pos
, '*');
16341 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16343 u32 V_len
= R_pos
- V_pos
;
16347 char *bits_pos
= strchr (R_pos
, '*');
16349 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16351 u32 R_len
= bits_pos
- R_pos
;
16355 char *P_pos
= strchr (bits_pos
, '*');
16357 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16359 u32 bits_len
= P_pos
- bits_pos
;
16363 char *enc_md_pos
= strchr (P_pos
, '*');
16365 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16367 u32 P_len
= enc_md_pos
- P_pos
;
16371 char *id_len_pos
= strchr (enc_md_pos
, '*');
16373 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16375 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16379 char *id_buf_pos
= strchr (id_len_pos
, '*');
16381 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16383 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16387 char *u_len_pos
= strchr (id_buf_pos
, '*');
16389 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16391 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16393 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16397 char *u_buf_pos
= strchr (u_len_pos
, '*');
16399 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16401 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16405 char *o_len_pos
= strchr (u_buf_pos
, '*');
16407 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16409 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16411 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16415 char *o_buf_pos
= strchr (o_len_pos
, '*');
16417 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16419 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16423 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16425 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16427 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16429 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16433 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;
16435 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16439 const int V
= atoi (V_pos
);
16440 const int R
= atoi (R_pos
);
16441 const int P
= atoi (P_pos
);
16443 if (V
!= 1) return (PARSER_SALT_VALUE
);
16444 if (R
!= 2) return (PARSER_SALT_VALUE
);
16446 const int enc_md
= atoi (enc_md_pos
);
16448 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16450 const int id_len
= atoi (id_len_pos
);
16451 const int u_len
= atoi (u_len_pos
);
16452 const int o_len
= atoi (o_len_pos
);
16454 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16455 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16456 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16458 const int bits
= atoi (bits_pos
);
16460 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16462 // copy data to esalt
16468 pdf
->enc_md
= enc_md
;
16470 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16471 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16472 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16473 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16474 pdf
->id_len
= id_len
;
16476 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16477 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16478 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16479 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16480 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16481 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16482 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16483 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16484 pdf
->u_len
= u_len
;
16486 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16487 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16488 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16489 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16490 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16491 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16492 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16493 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16494 pdf
->o_len
= o_len
;
16496 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16497 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16498 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16499 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16501 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16502 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16503 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16504 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16505 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16506 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16507 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16508 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16510 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16511 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16512 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16513 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16514 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16515 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16516 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16517 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16519 pdf
->rc4key
[1] = 0;
16520 pdf
->rc4key
[0] = 0;
16522 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16523 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16524 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16525 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16526 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16527 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16528 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16529 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16530 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16531 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16533 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16534 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16536 // we use ID for salt, maybe needs to change, we will see...
16538 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16539 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16540 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16541 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16542 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16543 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16544 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16545 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16546 salt
->salt_len
= pdf
->id_len
+ 16;
16548 digest
[0] = pdf
->rc4key
[0];
16549 digest
[1] = pdf
->rc4key
[1];
16553 return (PARSER_OK
);
16556 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16558 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16560 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16562 u32
*digest
= (u32
*) hash_buf
->digest
;
16564 salt_t
*salt
= hash_buf
->salt
;
16566 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16572 char *V_pos
= input_buf
+ 5;
16574 char *R_pos
= strchr (V_pos
, '*');
16576 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16578 u32 V_len
= R_pos
- V_pos
;
16582 char *bits_pos
= strchr (R_pos
, '*');
16584 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16586 u32 R_len
= bits_pos
- R_pos
;
16590 char *P_pos
= strchr (bits_pos
, '*');
16592 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16594 u32 bits_len
= P_pos
- bits_pos
;
16598 char *enc_md_pos
= strchr (P_pos
, '*');
16600 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16602 u32 P_len
= enc_md_pos
- P_pos
;
16606 char *id_len_pos
= strchr (enc_md_pos
, '*');
16608 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16610 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16614 char *id_buf_pos
= strchr (id_len_pos
, '*');
16616 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16618 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16622 char *u_len_pos
= strchr (id_buf_pos
, '*');
16624 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16626 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16628 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16632 char *u_buf_pos
= strchr (u_len_pos
, '*');
16634 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16636 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16640 char *o_len_pos
= strchr (u_buf_pos
, '*');
16642 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16644 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16646 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16650 char *o_buf_pos
= strchr (o_len_pos
, '*');
16652 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16654 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16658 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;
16660 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16664 const int V
= atoi (V_pos
);
16665 const int R
= atoi (R_pos
);
16666 const int P
= atoi (P_pos
);
16670 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16671 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16673 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16675 const int id_len
= atoi (id_len_pos
);
16676 const int u_len
= atoi (u_len_pos
);
16677 const int o_len
= atoi (o_len_pos
);
16679 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16681 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16682 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16684 const int bits
= atoi (bits_pos
);
16686 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16692 enc_md
= atoi (enc_md_pos
);
16695 // copy data to esalt
16701 pdf
->enc_md
= enc_md
;
16703 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16704 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16705 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16706 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16710 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16711 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16712 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16713 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16716 pdf
->id_len
= id_len
;
16718 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16719 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16720 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16721 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16722 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16723 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16724 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16725 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16726 pdf
->u_len
= u_len
;
16728 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16729 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16730 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16731 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16732 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16733 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16734 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16735 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16736 pdf
->o_len
= o_len
;
16738 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16739 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16740 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16741 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16745 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16746 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16747 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16748 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16751 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16752 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16753 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16754 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16755 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16756 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16757 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16758 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16760 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16761 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16762 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16763 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16764 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16765 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16766 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16767 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16769 // precompute rc4 data for later use
16785 uint salt_pc_block
[32] = { 0 };
16787 char *salt_pc_ptr
= (char *) salt_pc_block
;
16789 memcpy (salt_pc_ptr
, padding
, 32);
16790 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16792 uint salt_pc_digest
[4] = { 0 };
16794 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16796 pdf
->rc4data
[0] = salt_pc_digest
[0];
16797 pdf
->rc4data
[1] = salt_pc_digest
[1];
16799 // we use ID for salt, maybe needs to change, we will see...
16801 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16802 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16803 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16804 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16805 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16806 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16807 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16808 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16809 salt
->salt_len
= pdf
->id_len
+ 16;
16811 salt
->salt_iter
= ROUNDS_PDF14
;
16813 digest
[0] = pdf
->u_buf
[0];
16814 digest
[1] = pdf
->u_buf
[1];
16818 return (PARSER_OK
);
16821 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16823 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16825 if (ret
!= PARSER_OK
)
16830 u32
*digest
= (u32
*) hash_buf
->digest
;
16832 salt_t
*salt
= hash_buf
->salt
;
16834 digest
[0] -= SHA256M_A
;
16835 digest
[1] -= SHA256M_B
;
16836 digest
[2] -= SHA256M_C
;
16837 digest
[3] -= SHA256M_D
;
16838 digest
[4] -= SHA256M_E
;
16839 digest
[5] -= SHA256M_F
;
16840 digest
[6] -= SHA256M_G
;
16841 digest
[7] -= SHA256M_H
;
16843 salt
->salt_buf
[2] = 0x80;
16845 return (PARSER_OK
);
16848 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16850 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16852 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16854 u32
*digest
= (u32
*) hash_buf
->digest
;
16856 salt_t
*salt
= hash_buf
->salt
;
16858 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16864 char *V_pos
= input_buf
+ 5;
16866 char *R_pos
= strchr (V_pos
, '*');
16868 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16870 u32 V_len
= R_pos
- V_pos
;
16874 char *bits_pos
= strchr (R_pos
, '*');
16876 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16878 u32 R_len
= bits_pos
- R_pos
;
16882 char *P_pos
= strchr (bits_pos
, '*');
16884 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16886 u32 bits_len
= P_pos
- bits_pos
;
16890 char *enc_md_pos
= strchr (P_pos
, '*');
16892 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16894 u32 P_len
= enc_md_pos
- P_pos
;
16898 char *id_len_pos
= strchr (enc_md_pos
, '*');
16900 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16902 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16906 char *id_buf_pos
= strchr (id_len_pos
, '*');
16908 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16910 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16914 char *u_len_pos
= strchr (id_buf_pos
, '*');
16916 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16918 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16922 char *u_buf_pos
= strchr (u_len_pos
, '*');
16924 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16926 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16930 char *o_len_pos
= strchr (u_buf_pos
, '*');
16932 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16934 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16938 char *o_buf_pos
= strchr (o_len_pos
, '*');
16940 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16942 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16946 char *last
= strchr (o_buf_pos
, '*');
16948 if (last
== NULL
) last
= input_buf
+ input_len
;
16950 u32 o_buf_len
= last
- o_buf_pos
;
16954 const int V
= atoi (V_pos
);
16955 const int R
= atoi (R_pos
);
16959 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16960 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16962 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16964 const int bits
= atoi (bits_pos
);
16966 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16968 int enc_md
= atoi (enc_md_pos
);
16970 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16972 const uint id_len
= atoi (id_len_pos
);
16973 const uint u_len
= atoi (u_len_pos
);
16974 const uint o_len
= atoi (o_len_pos
);
16976 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16977 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16978 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16979 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16980 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16981 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16982 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16983 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16985 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16986 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16987 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16989 // copy data to esalt
16991 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16993 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16995 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
16998 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16999 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17001 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17002 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17004 salt
->salt_len
= 8;
17005 salt
->salt_iter
= ROUNDS_PDF17L8
;
17007 digest
[0] = pdf
->u_buf
[0];
17008 digest
[1] = pdf
->u_buf
[1];
17009 digest
[2] = pdf
->u_buf
[2];
17010 digest
[3] = pdf
->u_buf
[3];
17011 digest
[4] = pdf
->u_buf
[4];
17012 digest
[5] = pdf
->u_buf
[5];
17013 digest
[6] = pdf
->u_buf
[6];
17014 digest
[7] = pdf
->u_buf
[7];
17016 return (PARSER_OK
);
17019 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17021 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17023 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17025 u32
*digest
= (u32
*) hash_buf
->digest
;
17027 salt_t
*salt
= hash_buf
->salt
;
17029 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17037 char *iter_pos
= input_buf
+ 7;
17039 u32 iter
= atoi (iter_pos
);
17041 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17042 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17044 // first is *raw* salt
17046 char *salt_pos
= strchr (iter_pos
, ':');
17048 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17052 char *hash_pos
= strchr (salt_pos
, ':');
17054 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17056 u32 salt_len
= hash_pos
- salt_pos
;
17058 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17062 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17064 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17068 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17070 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17072 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17074 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17075 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17077 salt
->salt_len
= salt_len
;
17078 salt
->salt_iter
= iter
- 1;
17082 u8 tmp_buf
[100] = { 0 };
17084 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17086 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17088 memcpy (digest
, tmp_buf
, 16);
17090 digest
[0] = byte_swap_32 (digest
[0]);
17091 digest
[1] = byte_swap_32 (digest
[1]);
17092 digest
[2] = byte_swap_32 (digest
[2]);
17093 digest
[3] = byte_swap_32 (digest
[3]);
17095 // add some stuff to normal salt to make sorted happy
17097 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17098 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17099 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17100 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17101 salt
->salt_buf
[4] = salt
->salt_iter
;
17103 return (PARSER_OK
);
17106 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17108 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17110 u32
*digest
= (u32
*) hash_buf
->digest
;
17112 salt_t
*salt
= hash_buf
->salt
;
17114 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17115 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17116 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17117 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17119 digest
[0] = byte_swap_32 (digest
[0]);
17120 digest
[1] = byte_swap_32 (digest
[1]);
17121 digest
[2] = byte_swap_32 (digest
[2]);
17122 digest
[3] = byte_swap_32 (digest
[3]);
17124 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17126 uint salt_len
= input_len
- 32 - 1;
17128 char *salt_buf
= input_buf
+ 32 + 1;
17130 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17132 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17134 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17136 salt
->salt_len
= salt_len
;
17138 return (PARSER_OK
);
17141 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17143 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17145 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17147 u32
*digest
= (u32
*) hash_buf
->digest
;
17149 salt_t
*salt
= hash_buf
->salt
;
17151 char *user_pos
= input_buf
+ 10;
17153 char *salt_pos
= strchr (user_pos
, '*');
17155 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17159 char *hash_pos
= strchr (salt_pos
, '*');
17163 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17165 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17167 uint user_len
= salt_pos
- user_pos
- 1;
17169 uint salt_len
= hash_pos
- salt_pos
- 1;
17171 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17177 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17178 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17179 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17180 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17182 digest
[0] = byte_swap_32 (digest
[0]);
17183 digest
[1] = byte_swap_32 (digest
[1]);
17184 digest
[2] = byte_swap_32 (digest
[2]);
17185 digest
[3] = byte_swap_32 (digest
[3]);
17187 digest
[0] -= MD5M_A
;
17188 digest
[1] -= MD5M_B
;
17189 digest
[2] -= MD5M_C
;
17190 digest
[3] -= MD5M_D
;
17196 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17198 // first 4 bytes are the "challenge"
17200 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17201 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17202 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17203 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17205 // append the user name
17207 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17209 salt
->salt_len
= 4 + user_len
;
17211 return (PARSER_OK
);
17214 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17216 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17218 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17220 u32
*digest
= (u32
*) hash_buf
->digest
;
17222 salt_t
*salt
= hash_buf
->salt
;
17224 char *salt_pos
= input_buf
+ 9;
17226 char *hash_pos
= strchr (salt_pos
, '*');
17228 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17232 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17234 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17236 uint salt_len
= hash_pos
- salt_pos
- 1;
17238 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17244 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17245 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17246 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17247 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17248 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17254 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17256 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17258 salt
->salt_len
= salt_len
;
17260 return (PARSER_OK
);
17263 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17265 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17267 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17269 u32
*digest
= (u32
*) hash_buf
->digest
;
17271 salt_t
*salt
= hash_buf
->salt
;
17273 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17279 char *cry_master_len_pos
= input_buf
+ 9;
17281 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17283 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17285 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17287 cry_master_buf_pos
++;
17289 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17291 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17293 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17295 cry_salt_len_pos
++;
17297 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17299 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17301 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17303 cry_salt_buf_pos
++;
17305 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17307 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17309 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17313 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17315 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17317 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17321 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17323 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17325 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17329 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17331 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17333 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17335 public_key_len_pos
++;
17337 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17339 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17341 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17343 public_key_buf_pos
++;
17345 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;
17347 const uint cry_master_len
= atoi (cry_master_len_pos
);
17348 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17349 const uint ckey_len
= atoi (ckey_len_pos
);
17350 const uint public_key_len
= atoi (public_key_len_pos
);
17352 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17353 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17354 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17355 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17357 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17359 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17361 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17364 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17366 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17368 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17371 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17373 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17375 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17378 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17379 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17380 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17383 * store digest (should be unique enought, hopefully)
17386 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17387 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17388 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17389 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17395 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17397 const uint cry_rounds
= atoi (cry_rounds_pos
);
17399 salt
->salt_iter
= cry_rounds
- 1;
17401 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17403 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17405 salt
->salt_len
= salt_len
;
17407 return (PARSER_OK
);
17410 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17412 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17414 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17416 u32
*digest
= (u32
*) hash_buf
->digest
;
17418 salt_t
*salt
= hash_buf
->salt
;
17420 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17422 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17424 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17426 memcpy (temp_input_buf
, input_buf
, input_len
);
17430 char *URI_server_pos
= temp_input_buf
+ 6;
17432 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17434 if (URI_client_pos
== NULL
)
17436 myfree (temp_input_buf
);
17438 return (PARSER_SEPARATOR_UNMATCHED
);
17441 URI_client_pos
[0] = 0;
17444 uint URI_server_len
= strlen (URI_server_pos
);
17446 if (URI_server_len
> 512)
17448 myfree (temp_input_buf
);
17450 return (PARSER_SALT_LENGTH
);
17455 char *user_pos
= strchr (URI_client_pos
, '*');
17457 if (user_pos
== NULL
)
17459 myfree (temp_input_buf
);
17461 return (PARSER_SEPARATOR_UNMATCHED
);
17467 uint URI_client_len
= strlen (URI_client_pos
);
17469 if (URI_client_len
> 512)
17471 myfree (temp_input_buf
);
17473 return (PARSER_SALT_LENGTH
);
17478 char *realm_pos
= strchr (user_pos
, '*');
17480 if (realm_pos
== NULL
)
17482 myfree (temp_input_buf
);
17484 return (PARSER_SEPARATOR_UNMATCHED
);
17490 uint user_len
= strlen (user_pos
);
17492 if (user_len
> 116)
17494 myfree (temp_input_buf
);
17496 return (PARSER_SALT_LENGTH
);
17501 char *method_pos
= strchr (realm_pos
, '*');
17503 if (method_pos
== NULL
)
17505 myfree (temp_input_buf
);
17507 return (PARSER_SEPARATOR_UNMATCHED
);
17513 uint realm_len
= strlen (realm_pos
);
17515 if (realm_len
> 116)
17517 myfree (temp_input_buf
);
17519 return (PARSER_SALT_LENGTH
);
17524 char *URI_prefix_pos
= strchr (method_pos
, '*');
17526 if (URI_prefix_pos
== NULL
)
17528 myfree (temp_input_buf
);
17530 return (PARSER_SEPARATOR_UNMATCHED
);
17533 URI_prefix_pos
[0] = 0;
17536 uint method_len
= strlen (method_pos
);
17538 if (method_len
> 246)
17540 myfree (temp_input_buf
);
17542 return (PARSER_SALT_LENGTH
);
17547 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17549 if (URI_resource_pos
== NULL
)
17551 myfree (temp_input_buf
);
17553 return (PARSER_SEPARATOR_UNMATCHED
);
17556 URI_resource_pos
[0] = 0;
17557 URI_resource_pos
++;
17559 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17561 if (URI_prefix_len
> 245)
17563 myfree (temp_input_buf
);
17565 return (PARSER_SALT_LENGTH
);
17570 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17572 if (URI_suffix_pos
== NULL
)
17574 myfree (temp_input_buf
);
17576 return (PARSER_SEPARATOR_UNMATCHED
);
17579 URI_suffix_pos
[0] = 0;
17582 uint URI_resource_len
= strlen (URI_resource_pos
);
17584 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17586 myfree (temp_input_buf
);
17588 return (PARSER_SALT_LENGTH
);
17593 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17595 if (nonce_pos
== NULL
)
17597 myfree (temp_input_buf
);
17599 return (PARSER_SEPARATOR_UNMATCHED
);
17605 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17607 if (URI_suffix_len
> 245)
17609 myfree (temp_input_buf
);
17611 return (PARSER_SALT_LENGTH
);
17616 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17618 if (nonce_client_pos
== NULL
)
17620 myfree (temp_input_buf
);
17622 return (PARSER_SEPARATOR_UNMATCHED
);
17625 nonce_client_pos
[0] = 0;
17626 nonce_client_pos
++;
17628 uint nonce_len
= strlen (nonce_pos
);
17630 if (nonce_len
< 1 || nonce_len
> 50)
17632 myfree (temp_input_buf
);
17634 return (PARSER_SALT_LENGTH
);
17639 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17641 if (nonce_count_pos
== NULL
)
17643 myfree (temp_input_buf
);
17645 return (PARSER_SEPARATOR_UNMATCHED
);
17648 nonce_count_pos
[0] = 0;
17651 uint nonce_client_len
= strlen (nonce_client_pos
);
17653 if (nonce_client_len
> 50)
17655 myfree (temp_input_buf
);
17657 return (PARSER_SALT_LENGTH
);
17662 char *qop_pos
= strchr (nonce_count_pos
, '*');
17664 if (qop_pos
== NULL
)
17666 myfree (temp_input_buf
);
17668 return (PARSER_SEPARATOR_UNMATCHED
);
17674 uint nonce_count_len
= strlen (nonce_count_pos
);
17676 if (nonce_count_len
> 50)
17678 myfree (temp_input_buf
);
17680 return (PARSER_SALT_LENGTH
);
17685 char *directive_pos
= strchr (qop_pos
, '*');
17687 if (directive_pos
== NULL
)
17689 myfree (temp_input_buf
);
17691 return (PARSER_SEPARATOR_UNMATCHED
);
17694 directive_pos
[0] = 0;
17697 uint qop_len
= strlen (qop_pos
);
17701 myfree (temp_input_buf
);
17703 return (PARSER_SALT_LENGTH
);
17708 char *digest_pos
= strchr (directive_pos
, '*');
17710 if (digest_pos
== NULL
)
17712 myfree (temp_input_buf
);
17714 return (PARSER_SEPARATOR_UNMATCHED
);
17720 uint directive_len
= strlen (directive_pos
);
17722 if (directive_len
!= 3)
17724 myfree (temp_input_buf
);
17726 return (PARSER_SALT_LENGTH
);
17729 if (memcmp (directive_pos
, "MD5", 3))
17731 log_info ("ERROR: only the MD5 directive is currently supported\n");
17733 myfree (temp_input_buf
);
17735 return (PARSER_SIP_AUTH_DIRECTIVE
);
17739 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17744 uint md5_max_len
= 4 * 64;
17746 uint md5_remaining_len
= md5_max_len
;
17748 uint tmp_md5_buf
[64] = { 0 };
17750 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17752 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17754 md5_len
+= method_len
+ 1;
17755 tmp_md5_ptr
+= method_len
+ 1;
17757 if (URI_prefix_len
> 0)
17759 md5_remaining_len
= md5_max_len
- md5_len
;
17761 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17763 md5_len
+= URI_prefix_len
+ 1;
17764 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17767 md5_remaining_len
= md5_max_len
- md5_len
;
17769 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17771 md5_len
+= URI_resource_len
;
17772 tmp_md5_ptr
+= URI_resource_len
;
17774 if (URI_suffix_len
> 0)
17776 md5_remaining_len
= md5_max_len
- md5_len
;
17778 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17780 md5_len
+= 1 + URI_suffix_len
;
17783 uint tmp_digest
[4] = { 0 };
17785 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17787 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17788 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17789 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17790 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17796 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17798 uint esalt_len
= 0;
17800 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17802 // there are 2 possibilities for the esalt:
17804 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17806 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17808 if (esalt_len
> max_esalt_len
)
17810 myfree (temp_input_buf
);
17812 return (PARSER_SALT_LENGTH
);
17815 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17827 esalt_len
= 1 + nonce_len
+ 1 + 32;
17829 if (esalt_len
> max_esalt_len
)
17831 myfree (temp_input_buf
);
17833 return (PARSER_SALT_LENGTH
);
17836 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17844 // add 0x80 to esalt
17846 esalt_buf_ptr
[esalt_len
] = 0x80;
17848 sip
->esalt_len
= esalt_len
;
17854 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17856 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17858 uint max_salt_len
= 119;
17860 if (salt_len
> max_salt_len
)
17862 myfree (temp_input_buf
);
17864 return (PARSER_SALT_LENGTH
);
17867 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17869 sip
->salt_len
= salt_len
;
17872 * fake salt (for sorting)
17875 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17879 uint fake_salt_len
= salt_len
;
17881 if (fake_salt_len
> max_salt_len
)
17883 fake_salt_len
= max_salt_len
;
17886 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17888 salt
->salt_len
= fake_salt_len
;
17894 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17895 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17896 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17897 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17899 digest
[0] = byte_swap_32 (digest
[0]);
17900 digest
[1] = byte_swap_32 (digest
[1]);
17901 digest
[2] = byte_swap_32 (digest
[2]);
17902 digest
[3] = byte_swap_32 (digest
[3]);
17904 myfree (temp_input_buf
);
17906 return (PARSER_OK
);
17909 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17911 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17913 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17915 u32
*digest
= (u32
*) hash_buf
->digest
;
17917 salt_t
*salt
= hash_buf
->salt
;
17921 char *digest_pos
= input_buf
;
17923 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17930 char *salt_buf
= input_buf
+ 8 + 1;
17934 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17936 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17938 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17940 salt
->salt_len
= salt_len
;
17942 return (PARSER_OK
);
17945 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17947 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17949 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17951 u32
*digest
= (u32
*) hash_buf
->digest
;
17953 salt_t
*salt
= hash_buf
->salt
;
17955 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17961 char *p_buf_pos
= input_buf
+ 4;
17963 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17965 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17967 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17969 NumCyclesPower_pos
++;
17971 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17973 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17975 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17979 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17981 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17983 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
17987 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17989 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17991 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17995 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17997 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17999 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18003 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18005 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18007 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18011 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18013 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18015 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18019 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18021 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18023 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18027 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18029 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18031 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18035 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;
18037 const uint iter
= atoi (NumCyclesPower_pos
);
18038 const uint crc
= atoi (crc_buf_pos
);
18039 const uint p_buf
= atoi (p_buf_pos
);
18040 const uint salt_len
= atoi (salt_len_pos
);
18041 const uint iv_len
= atoi (iv_len_pos
);
18042 const uint unpack_size
= atoi (unpack_size_pos
);
18043 const uint data_len
= atoi (data_len_pos
);
18049 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18050 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18052 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18054 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18056 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18062 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18063 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18064 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18065 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18067 seven_zip
->iv_len
= iv_len
;
18069 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18071 seven_zip
->salt_len
= 0;
18073 seven_zip
->crc
= crc
;
18075 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18077 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18079 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18082 seven_zip
->data_len
= data_len
;
18084 seven_zip
->unpack_size
= unpack_size
;
18088 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18089 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18090 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18091 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18093 salt
->salt_len
= 16;
18095 salt
->salt_sign
[0] = iter
;
18097 salt
->salt_iter
= 1 << iter
;
18108 return (PARSER_OK
);
18111 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18113 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18115 u32
*digest
= (u32
*) hash_buf
->digest
;
18117 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18118 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18119 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18120 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18121 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18122 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18123 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18124 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18126 digest
[0] = byte_swap_32 (digest
[0]);
18127 digest
[1] = byte_swap_32 (digest
[1]);
18128 digest
[2] = byte_swap_32 (digest
[2]);
18129 digest
[3] = byte_swap_32 (digest
[3]);
18130 digest
[4] = byte_swap_32 (digest
[4]);
18131 digest
[5] = byte_swap_32 (digest
[5]);
18132 digest
[6] = byte_swap_32 (digest
[6]);
18133 digest
[7] = byte_swap_32 (digest
[7]);
18135 return (PARSER_OK
);
18138 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18140 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18142 u32
*digest
= (u32
*) hash_buf
->digest
;
18144 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18145 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18146 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18147 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18148 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18149 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18150 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18151 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18152 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18153 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18154 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18155 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18156 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18157 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18158 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18159 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18161 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18162 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18163 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18164 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18165 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18166 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18167 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18168 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18169 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18170 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18171 digest
[10] = byte_swap_32 (digest
[10]);
18172 digest
[11] = byte_swap_32 (digest
[11]);
18173 digest
[12] = byte_swap_32 (digest
[12]);
18174 digest
[13] = byte_swap_32 (digest
[13]);
18175 digest
[14] = byte_swap_32 (digest
[14]);
18176 digest
[15] = byte_swap_32 (digest
[15]);
18178 return (PARSER_OK
);
18181 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18183 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18185 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18187 u32
*digest
= (u32
*) hash_buf
->digest
;
18189 salt_t
*salt
= hash_buf
->salt
;
18191 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18199 char *iter_pos
= input_buf
+ 4;
18201 u32 iter
= atoi (iter_pos
);
18203 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18204 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18206 // first is *raw* salt
18208 char *salt_pos
= strchr (iter_pos
, ':');
18210 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18214 char *hash_pos
= strchr (salt_pos
, ':');
18216 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18218 u32 salt_len
= hash_pos
- salt_pos
;
18220 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18224 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18226 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18230 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18232 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18234 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18236 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18237 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18239 salt
->salt_len
= salt_len
;
18240 salt
->salt_iter
= iter
- 1;
18244 u8 tmp_buf
[100] = { 0 };
18246 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18248 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18250 memcpy (digest
, tmp_buf
, 16);
18252 // add some stuff to normal salt to make sorted happy
18254 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18255 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18256 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18257 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18258 salt
->salt_buf
[4] = salt
->salt_iter
;
18260 return (PARSER_OK
);
18263 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18265 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18267 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18269 u32
*digest
= (u32
*) hash_buf
->digest
;
18271 salt_t
*salt
= hash_buf
->salt
;
18273 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18281 char *iter_pos
= input_buf
+ 5;
18283 u32 iter
= atoi (iter_pos
);
18285 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18286 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18288 // first is *raw* salt
18290 char *salt_pos
= strchr (iter_pos
, ':');
18292 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18296 char *hash_pos
= strchr (salt_pos
, ':');
18298 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18300 u32 salt_len
= hash_pos
- salt_pos
;
18302 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18306 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18308 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18312 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18314 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18316 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18318 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18319 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18321 salt
->salt_len
= salt_len
;
18322 salt
->salt_iter
= iter
- 1;
18326 u8 tmp_buf
[100] = { 0 };
18328 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18330 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18332 memcpy (digest
, tmp_buf
, 16);
18334 digest
[0] = byte_swap_32 (digest
[0]);
18335 digest
[1] = byte_swap_32 (digest
[1]);
18336 digest
[2] = byte_swap_32 (digest
[2]);
18337 digest
[3] = byte_swap_32 (digest
[3]);
18339 // add some stuff to normal salt to make sorted happy
18341 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18342 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18343 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18344 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18345 salt
->salt_buf
[4] = salt
->salt_iter
;
18347 return (PARSER_OK
);
18350 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18352 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18354 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18356 u64
*digest
= (u64
*) hash_buf
->digest
;
18358 salt_t
*salt
= hash_buf
->salt
;
18360 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18368 char *iter_pos
= input_buf
+ 7;
18370 u32 iter
= atoi (iter_pos
);
18372 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18373 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18375 // first is *raw* salt
18377 char *salt_pos
= strchr (iter_pos
, ':');
18379 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18383 char *hash_pos
= strchr (salt_pos
, ':');
18385 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18387 u32 salt_len
= hash_pos
- salt_pos
;
18389 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18393 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18395 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18399 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18401 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18403 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18405 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18406 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18408 salt
->salt_len
= salt_len
;
18409 salt
->salt_iter
= iter
- 1;
18413 u8 tmp_buf
[100] = { 0 };
18415 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18417 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18419 memcpy (digest
, tmp_buf
, 64);
18421 digest
[0] = byte_swap_64 (digest
[0]);
18422 digest
[1] = byte_swap_64 (digest
[1]);
18423 digest
[2] = byte_swap_64 (digest
[2]);
18424 digest
[3] = byte_swap_64 (digest
[3]);
18425 digest
[4] = byte_swap_64 (digest
[4]);
18426 digest
[5] = byte_swap_64 (digest
[5]);
18427 digest
[6] = byte_swap_64 (digest
[6]);
18428 digest
[7] = byte_swap_64 (digest
[7]);
18430 // add some stuff to normal salt to make sorted happy
18432 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18433 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18434 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18435 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18436 salt
->salt_buf
[4] = salt
->salt_iter
;
18438 return (PARSER_OK
);
18441 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18443 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18445 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18447 uint
*digest
= (uint
*) hash_buf
->digest
;
18449 salt_t
*salt
= hash_buf
->salt
;
18455 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18457 char *hash_pos
= strchr (salt_pos
, '$');
18459 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18461 u32 salt_len
= hash_pos
- salt_pos
;
18463 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18467 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18469 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18473 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18474 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18492 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18493 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18495 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18496 salt
->salt_len
= 8;
18498 return (PARSER_OK
);
18501 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18503 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18505 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18507 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18509 if (c19
& 3) return (PARSER_HASH_VALUE
);
18511 salt_t
*salt
= hash_buf
->salt
;
18513 u32
*digest
= (u32
*) hash_buf
->digest
;
18517 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18518 | itoa64_to_int (input_buf
[2]) << 6
18519 | itoa64_to_int (input_buf
[3]) << 12
18520 | itoa64_to_int (input_buf
[4]) << 18;
18524 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18525 | itoa64_to_int (input_buf
[6]) << 6
18526 | itoa64_to_int (input_buf
[7]) << 12
18527 | itoa64_to_int (input_buf
[8]) << 18;
18529 salt
->salt_len
= 4;
18531 u8 tmp_buf
[100] = { 0 };
18533 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18535 memcpy (digest
, tmp_buf
, 8);
18539 IP (digest
[0], digest
[1], tt
);
18541 digest
[0] = rotr32 (digest
[0], 31);
18542 digest
[1] = rotr32 (digest
[1], 31);
18546 return (PARSER_OK
);
18549 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18551 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18553 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18555 u32
*digest
= (u32
*) hash_buf
->digest
;
18557 salt_t
*salt
= hash_buf
->salt
;
18563 char *type_pos
= input_buf
+ 6 + 1;
18565 char *salt_pos
= strchr (type_pos
, '*');
18567 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18569 u32 type_len
= salt_pos
- type_pos
;
18571 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18575 char *crypted_pos
= strchr (salt_pos
, '*');
18577 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18579 u32 salt_len
= crypted_pos
- salt_pos
;
18581 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18585 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18587 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18593 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18594 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18596 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18597 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18599 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18600 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18601 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18602 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18604 salt
->salt_len
= 24;
18605 salt
->salt_iter
= ROUNDS_RAR3
;
18607 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18608 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18610 digest
[0] = 0xc43d7b00;
18611 digest
[1] = 0x40070000;
18615 return (PARSER_OK
);
18618 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18620 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18622 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18624 u32
*digest
= (u32
*) hash_buf
->digest
;
18626 salt_t
*salt
= hash_buf
->salt
;
18628 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18634 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18636 char *param1_pos
= strchr (param0_pos
, '$');
18638 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18640 u32 param0_len
= param1_pos
- param0_pos
;
18644 char *param2_pos
= strchr (param1_pos
, '$');
18646 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18648 u32 param1_len
= param2_pos
- param1_pos
;
18652 char *param3_pos
= strchr (param2_pos
, '$');
18654 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18656 u32 param2_len
= param3_pos
- param2_pos
;
18660 char *param4_pos
= strchr (param3_pos
, '$');
18662 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18664 u32 param3_len
= param4_pos
- param3_pos
;
18668 char *param5_pos
= strchr (param4_pos
, '$');
18670 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18672 u32 param4_len
= param5_pos
- param4_pos
;
18676 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18678 char *salt_buf
= param1_pos
;
18679 char *iv
= param3_pos
;
18680 char *pswcheck
= param5_pos
;
18682 const uint salt_len
= atoi (param0_pos
);
18683 const uint iterations
= atoi (param2_pos
);
18684 const uint pswcheck_len
= atoi (param4_pos
);
18690 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18691 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18692 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18694 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18695 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18696 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18702 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18703 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18704 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18705 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18707 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18708 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18709 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18710 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18712 salt
->salt_len
= 16;
18714 salt
->salt_sign
[0] = iterations
;
18716 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18722 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18723 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18727 return (PARSER_OK
);
18730 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18732 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18734 u32
*digest
= (u32
*) hash_buf
->digest
;
18736 salt_t
*salt
= hash_buf
->salt
;
18738 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18739 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18740 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18741 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18742 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18743 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18744 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18745 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18747 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18749 uint salt_len
= input_len
- 64 - 1;
18751 char *salt_buf
= input_buf
+ 64 + 1;
18753 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18755 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18757 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18759 salt
->salt_len
= salt_len
;
18762 * we can precompute the first sha256 transform
18765 uint w
[16] = { 0 };
18767 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18768 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18769 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18770 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18771 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18772 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18773 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18774 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18775 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18776 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18777 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18778 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18779 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18780 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18781 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18782 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18784 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
18786 sha256_64 (w
, pc256
);
18788 salt
->salt_buf_pc
[0] = pc256
[0];
18789 salt
->salt_buf_pc
[1] = pc256
[1];
18790 salt
->salt_buf_pc
[2] = pc256
[2];
18791 salt
->salt_buf_pc
[3] = pc256
[3];
18792 salt
->salt_buf_pc
[4] = pc256
[4];
18793 salt
->salt_buf_pc
[5] = pc256
[5];
18794 salt
->salt_buf_pc
[6] = pc256
[6];
18795 salt
->salt_buf_pc
[7] = pc256
[7];
18797 digest
[0] -= pc256
[0];
18798 digest
[1] -= pc256
[1];
18799 digest
[2] -= pc256
[2];
18800 digest
[3] -= pc256
[3];
18801 digest
[4] -= pc256
[4];
18802 digest
[5] -= pc256
[5];
18803 digest
[6] -= pc256
[6];
18804 digest
[7] -= pc256
[7];
18806 return (PARSER_OK
);
18809 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18811 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18813 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18815 u32
*digest
= (u32
*) hash_buf
->digest
;
18817 salt_t
*salt
= hash_buf
->salt
;
18823 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18825 char *data_buf_pos
= strchr (data_len_pos
, '$');
18827 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18829 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18831 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18832 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18836 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18838 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18840 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18842 u32 data_len
= atoi (data_len_pos
);
18844 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18850 char *salt_pos
= data_buf_pos
;
18852 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18853 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18854 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
18855 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
18857 // this is actually the CT, which is also the hash later (if matched)
18859 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
18860 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
18861 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
18862 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
18864 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18866 salt
->salt_iter
= 10 - 1;
18872 digest
[0] = salt
->salt_buf
[4];
18873 digest
[1] = salt
->salt_buf
[5];
18874 digest
[2] = salt
->salt_buf
[6];
18875 digest
[3] = salt
->salt_buf
[7];
18877 return (PARSER_OK
);
18880 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18882 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18884 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18886 u32
*digest
= (u32
*) hash_buf
->digest
;
18888 salt_t
*salt
= hash_buf
->salt
;
18894 char *salt_pos
= input_buf
+ 11 + 1;
18896 char *iter_pos
= strchr (salt_pos
, ',');
18898 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18900 u32 salt_len
= iter_pos
- salt_pos
;
18902 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18906 char *hash_pos
= strchr (iter_pos
, ',');
18908 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18910 u32 iter_len
= hash_pos
- iter_pos
;
18912 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18916 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18918 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18924 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18925 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18926 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
18927 salt
->salt_buf
[3] = 0x00018000;
18929 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18930 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18931 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18932 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18934 salt
->salt_len
= salt_len
/ 2;
18936 salt
->salt_iter
= atoi (iter_pos
) - 1;
18942 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18943 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18944 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18945 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18946 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18947 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18948 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18949 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18951 return (PARSER_OK
);
18954 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18956 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
18958 u32
*digest
= (u32
*) hash_buf
->digest
;
18960 salt_t
*salt
= hash_buf
->salt
;
18966 char *hash_pos
= input_buf
+ 64;
18967 char *salt1_pos
= input_buf
+ 128;
18968 char *salt2_pos
= input_buf
;
18974 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
18975 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
18976 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
18977 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
18979 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
18980 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
18981 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
18982 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
18984 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
18985 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
18986 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
18987 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
18989 salt
->salt_len
= 48;
18991 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
18997 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18998 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18999 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19000 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19001 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19002 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19003 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19004 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19006 return (PARSER_OK
);
19010 * parallel running threads
19015 BOOL WINAPI
sigHandler_default (DWORD sig
)
19019 case CTRL_CLOSE_EVENT
:
19022 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19023 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19024 * function otherwise it is too late (e.g. after returning from this function)
19029 SetConsoleCtrlHandler (NULL
, TRUE
);
19036 case CTRL_LOGOFF_EVENT
:
19037 case CTRL_SHUTDOWN_EVENT
:
19041 SetConsoleCtrlHandler (NULL
, TRUE
);
19049 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19053 case CTRL_CLOSE_EVENT
:
19057 SetConsoleCtrlHandler (NULL
, TRUE
);
19064 case CTRL_LOGOFF_EVENT
:
19065 case CTRL_SHUTDOWN_EVENT
:
19069 SetConsoleCtrlHandler (NULL
, TRUE
);
19077 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19079 if (callback
== NULL
)
19081 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19085 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19091 void sigHandler_default (int sig
)
19095 signal (sig
, NULL
);
19098 void sigHandler_benchmark (int sig
)
19102 signal (sig
, NULL
);
19105 void hc_signal (void (callback
) (int))
19107 if (callback
== NULL
) callback
= SIG_DFL
;
19109 signal (SIGINT
, callback
);
19110 signal (SIGTERM
, callback
);
19111 signal (SIGABRT
, callback
);
19116 void status_display ();
19118 void *thread_keypress (void *p
)
19120 int benchmark
= *((int *) p
);
19122 uint quiet
= data
.quiet
;
19126 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19128 int ch
= tty_getchar();
19130 if (ch
== -1) break;
19132 if (ch
== 0) continue;
19138 hc_thread_mutex_lock (mux_display
);
19153 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19154 if (quiet
== 0) fflush (stdout
);
19166 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19167 if (quiet
== 0) fflush (stdout
);
19179 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19180 if (quiet
== 0) fflush (stdout
);
19192 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19193 if (quiet
== 0) fflush (stdout
);
19201 if (benchmark
== 1) break;
19203 stop_at_checkpoint ();
19207 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19208 if (quiet
== 0) fflush (stdout
);
19216 if (benchmark
== 1)
19228 hc_thread_mutex_unlock (mux_display
);
19240 bool class_num (const u8 c
)
19242 return ((c
>= '0') && (c
<= '9'));
19245 bool class_lower (const u8 c
)
19247 return ((c
>= 'a') && (c
<= 'z'));
19250 bool class_upper (const u8 c
)
19252 return ((c
>= 'A') && (c
<= 'Z'));
19255 bool class_alpha (const u8 c
)
19257 return (class_lower (c
) || class_upper (c
));
19260 int conv_ctoi (const u8 c
)
19266 else if (class_upper (c
))
19268 return c
- 'A' + 10;
19274 int conv_itoc (const u8 c
)
19282 return c
+ 'A' - 10;
19292 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19293 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19294 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19295 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19296 #define MAX_KERNEL_RULES 255
19297 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19298 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19299 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19301 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19302 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19303 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19304 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19306 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19311 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19313 switch (rule_buf
[rule_pos
])
19319 case RULE_OP_MANGLE_NOOP
:
19320 SET_NAME (rule
, rule_buf
[rule_pos
]);
19323 case RULE_OP_MANGLE_LREST
:
19324 SET_NAME (rule
, rule_buf
[rule_pos
]);
19327 case RULE_OP_MANGLE_UREST
:
19328 SET_NAME (rule
, rule_buf
[rule_pos
]);
19331 case RULE_OP_MANGLE_LREST_UFIRST
:
19332 SET_NAME (rule
, rule_buf
[rule_pos
]);
19335 case RULE_OP_MANGLE_UREST_LFIRST
:
19336 SET_NAME (rule
, rule_buf
[rule_pos
]);
19339 case RULE_OP_MANGLE_TREST
:
19340 SET_NAME (rule
, rule_buf
[rule_pos
]);
19343 case RULE_OP_MANGLE_TOGGLE_AT
:
19344 SET_NAME (rule
, rule_buf
[rule_pos
]);
19345 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19348 case RULE_OP_MANGLE_REVERSE
:
19349 SET_NAME (rule
, rule_buf
[rule_pos
]);
19352 case RULE_OP_MANGLE_DUPEWORD
:
19353 SET_NAME (rule
, rule_buf
[rule_pos
]);
19356 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19357 SET_NAME (rule
, rule_buf
[rule_pos
]);
19358 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19361 case RULE_OP_MANGLE_REFLECT
:
19362 SET_NAME (rule
, rule_buf
[rule_pos
]);
19365 case RULE_OP_MANGLE_ROTATE_LEFT
:
19366 SET_NAME (rule
, rule_buf
[rule_pos
]);
19369 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19370 SET_NAME (rule
, rule_buf
[rule_pos
]);
19373 case RULE_OP_MANGLE_APPEND
:
19374 SET_NAME (rule
, rule_buf
[rule_pos
]);
19375 SET_P0 (rule
, rule_buf
[rule_pos
]);
19378 case RULE_OP_MANGLE_PREPEND
:
19379 SET_NAME (rule
, rule_buf
[rule_pos
]);
19380 SET_P0 (rule
, rule_buf
[rule_pos
]);
19383 case RULE_OP_MANGLE_DELETE_FIRST
:
19384 SET_NAME (rule
, rule_buf
[rule_pos
]);
19387 case RULE_OP_MANGLE_DELETE_LAST
:
19388 SET_NAME (rule
, rule_buf
[rule_pos
]);
19391 case RULE_OP_MANGLE_DELETE_AT
:
19392 SET_NAME (rule
, rule_buf
[rule_pos
]);
19393 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19396 case RULE_OP_MANGLE_EXTRACT
:
19397 SET_NAME (rule
, rule_buf
[rule_pos
]);
19398 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19399 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19402 case RULE_OP_MANGLE_OMIT
:
19403 SET_NAME (rule
, rule_buf
[rule_pos
]);
19404 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19405 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19408 case RULE_OP_MANGLE_INSERT
:
19409 SET_NAME (rule
, rule_buf
[rule_pos
]);
19410 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19411 SET_P1 (rule
, rule_buf
[rule_pos
]);
19414 case RULE_OP_MANGLE_OVERSTRIKE
:
19415 SET_NAME (rule
, rule_buf
[rule_pos
]);
19416 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19417 SET_P1 (rule
, rule_buf
[rule_pos
]);
19420 case RULE_OP_MANGLE_TRUNCATE_AT
:
19421 SET_NAME (rule
, rule_buf
[rule_pos
]);
19422 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19425 case RULE_OP_MANGLE_REPLACE
:
19426 SET_NAME (rule
, rule_buf
[rule_pos
]);
19427 SET_P0 (rule
, rule_buf
[rule_pos
]);
19428 SET_P1 (rule
, rule_buf
[rule_pos
]);
19431 case RULE_OP_MANGLE_PURGECHAR
:
19435 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19439 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19440 SET_NAME (rule
, rule_buf
[rule_pos
]);
19441 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19444 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19445 SET_NAME (rule
, rule_buf
[rule_pos
]);
19446 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19449 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19450 SET_NAME (rule
, rule_buf
[rule_pos
]);
19453 case RULE_OP_MANGLE_SWITCH_FIRST
:
19454 SET_NAME (rule
, rule_buf
[rule_pos
]);
19457 case RULE_OP_MANGLE_SWITCH_LAST
:
19458 SET_NAME (rule
, rule_buf
[rule_pos
]);
19461 case RULE_OP_MANGLE_SWITCH_AT
:
19462 SET_NAME (rule
, rule_buf
[rule_pos
]);
19463 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19464 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19467 case RULE_OP_MANGLE_CHR_SHIFTL
:
19468 SET_NAME (rule
, rule_buf
[rule_pos
]);
19469 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19472 case RULE_OP_MANGLE_CHR_SHIFTR
:
19473 SET_NAME (rule
, rule_buf
[rule_pos
]);
19474 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19477 case RULE_OP_MANGLE_CHR_INCR
:
19478 SET_NAME (rule
, rule_buf
[rule_pos
]);
19479 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19482 case RULE_OP_MANGLE_CHR_DECR
:
19483 SET_NAME (rule
, rule_buf
[rule_pos
]);
19484 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19487 case RULE_OP_MANGLE_REPLACE_NP1
:
19488 SET_NAME (rule
, rule_buf
[rule_pos
]);
19489 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19492 case RULE_OP_MANGLE_REPLACE_NM1
:
19493 SET_NAME (rule
, rule_buf
[rule_pos
]);
19494 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19497 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19498 SET_NAME (rule
, rule_buf
[rule_pos
]);
19499 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19502 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19503 SET_NAME (rule
, rule_buf
[rule_pos
]);
19504 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19507 case RULE_OP_MANGLE_TITLE
:
19508 SET_NAME (rule
, rule_buf
[rule_pos
]);
19517 if (rule_pos
< rule_len
) return (-1);
19522 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19526 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19530 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19534 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19538 case RULE_OP_MANGLE_NOOP
:
19539 rule_buf
[rule_pos
] = rule_cmd
;
19542 case RULE_OP_MANGLE_LREST
:
19543 rule_buf
[rule_pos
] = rule_cmd
;
19546 case RULE_OP_MANGLE_UREST
:
19547 rule_buf
[rule_pos
] = rule_cmd
;
19550 case RULE_OP_MANGLE_LREST_UFIRST
:
19551 rule_buf
[rule_pos
] = rule_cmd
;
19554 case RULE_OP_MANGLE_UREST_LFIRST
:
19555 rule_buf
[rule_pos
] = rule_cmd
;
19558 case RULE_OP_MANGLE_TREST
:
19559 rule_buf
[rule_pos
] = rule_cmd
;
19562 case RULE_OP_MANGLE_TOGGLE_AT
:
19563 rule_buf
[rule_pos
] = rule_cmd
;
19564 GET_P0_CONV (rule
);
19567 case RULE_OP_MANGLE_REVERSE
:
19568 rule_buf
[rule_pos
] = rule_cmd
;
19571 case RULE_OP_MANGLE_DUPEWORD
:
19572 rule_buf
[rule_pos
] = rule_cmd
;
19575 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19576 rule_buf
[rule_pos
] = rule_cmd
;
19577 GET_P0_CONV (rule
);
19580 case RULE_OP_MANGLE_REFLECT
:
19581 rule_buf
[rule_pos
] = rule_cmd
;
19584 case RULE_OP_MANGLE_ROTATE_LEFT
:
19585 rule_buf
[rule_pos
] = rule_cmd
;
19588 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19589 rule_buf
[rule_pos
] = rule_cmd
;
19592 case RULE_OP_MANGLE_APPEND
:
19593 rule_buf
[rule_pos
] = rule_cmd
;
19597 case RULE_OP_MANGLE_PREPEND
:
19598 rule_buf
[rule_pos
] = rule_cmd
;
19602 case RULE_OP_MANGLE_DELETE_FIRST
:
19603 rule_buf
[rule_pos
] = rule_cmd
;
19606 case RULE_OP_MANGLE_DELETE_LAST
:
19607 rule_buf
[rule_pos
] = rule_cmd
;
19610 case RULE_OP_MANGLE_DELETE_AT
:
19611 rule_buf
[rule_pos
] = rule_cmd
;
19612 GET_P0_CONV (rule
);
19615 case RULE_OP_MANGLE_EXTRACT
:
19616 rule_buf
[rule_pos
] = rule_cmd
;
19617 GET_P0_CONV (rule
);
19618 GET_P1_CONV (rule
);
19621 case RULE_OP_MANGLE_OMIT
:
19622 rule_buf
[rule_pos
] = rule_cmd
;
19623 GET_P0_CONV (rule
);
19624 GET_P1_CONV (rule
);
19627 case RULE_OP_MANGLE_INSERT
:
19628 rule_buf
[rule_pos
] = rule_cmd
;
19629 GET_P0_CONV (rule
);
19633 case RULE_OP_MANGLE_OVERSTRIKE
:
19634 rule_buf
[rule_pos
] = rule_cmd
;
19635 GET_P0_CONV (rule
);
19639 case RULE_OP_MANGLE_TRUNCATE_AT
:
19640 rule_buf
[rule_pos
] = rule_cmd
;
19641 GET_P0_CONV (rule
);
19644 case RULE_OP_MANGLE_REPLACE
:
19645 rule_buf
[rule_pos
] = rule_cmd
;
19650 case RULE_OP_MANGLE_PURGECHAR
:
19654 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19658 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19659 rule_buf
[rule_pos
] = rule_cmd
;
19660 GET_P0_CONV (rule
);
19663 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19664 rule_buf
[rule_pos
] = rule_cmd
;
19665 GET_P0_CONV (rule
);
19668 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19669 rule_buf
[rule_pos
] = rule_cmd
;
19672 case RULE_OP_MANGLE_SWITCH_FIRST
:
19673 rule_buf
[rule_pos
] = rule_cmd
;
19676 case RULE_OP_MANGLE_SWITCH_LAST
:
19677 rule_buf
[rule_pos
] = rule_cmd
;
19680 case RULE_OP_MANGLE_SWITCH_AT
:
19681 rule_buf
[rule_pos
] = rule_cmd
;
19682 GET_P0_CONV (rule
);
19683 GET_P1_CONV (rule
);
19686 case RULE_OP_MANGLE_CHR_SHIFTL
:
19687 rule_buf
[rule_pos
] = rule_cmd
;
19688 GET_P0_CONV (rule
);
19691 case RULE_OP_MANGLE_CHR_SHIFTR
:
19692 rule_buf
[rule_pos
] = rule_cmd
;
19693 GET_P0_CONV (rule
);
19696 case RULE_OP_MANGLE_CHR_INCR
:
19697 rule_buf
[rule_pos
] = rule_cmd
;
19698 GET_P0_CONV (rule
);
19701 case RULE_OP_MANGLE_CHR_DECR
:
19702 rule_buf
[rule_pos
] = rule_cmd
;
19703 GET_P0_CONV (rule
);
19706 case RULE_OP_MANGLE_REPLACE_NP1
:
19707 rule_buf
[rule_pos
] = rule_cmd
;
19708 GET_P0_CONV (rule
);
19711 case RULE_OP_MANGLE_REPLACE_NM1
:
19712 rule_buf
[rule_pos
] = rule_cmd
;
19713 GET_P0_CONV (rule
);
19716 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19717 rule_buf
[rule_pos
] = rule_cmd
;
19718 GET_P0_CONV (rule
);
19721 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19722 rule_buf
[rule_pos
] = rule_cmd
;
19723 GET_P0_CONV (rule
);
19726 case RULE_OP_MANGLE_TITLE
:
19727 rule_buf
[rule_pos
] = rule_cmd
;
19731 return rule_pos
- 1;
19749 * CPU rules : this is from hashcat sources, cpu based rules
19752 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19753 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19755 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19756 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19757 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19759 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19760 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19761 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19763 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19767 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19772 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19776 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19781 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19785 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19790 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19795 for (l
= 0; l
< arr_len
; l
++)
19797 r
= arr_len
- 1 - l
;
19801 MANGLE_SWITCH (arr
, l
, r
);
19807 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19809 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19811 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19813 return (arr_len
* 2);
19816 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19818 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19820 int orig_len
= arr_len
;
19824 for (i
= 0; i
< times
; i
++)
19826 memcpy (&arr
[arr_len
], arr
, orig_len
);
19828 arr_len
+= orig_len
;
19834 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19836 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19838 mangle_double (arr
, arr_len
);
19840 mangle_reverse (arr
+ arr_len
, arr_len
);
19842 return (arr_len
* 2);
19845 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19850 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19852 MANGLE_SWITCH (arr
, l
, r
);
19858 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19863 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19865 MANGLE_SWITCH (arr
, l
, r
);
19871 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19873 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19877 return (arr_len
+ 1);
19880 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19882 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19886 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19888 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19893 return (arr_len
+ 1);
19896 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19898 if (upos
>= arr_len
) return (arr_len
);
19902 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19904 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19907 return (arr_len
- 1);
19910 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19912 if (upos
>= arr_len
) return (arr_len
);
19914 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19918 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19920 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19926 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19928 if (upos
>= arr_len
) return (arr_len
);
19930 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19934 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19936 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19939 return (arr_len
- ulen
);
19942 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19944 if (upos
>= arr_len
) return (arr_len
);
19946 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19950 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19952 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19957 return (arr_len
+ 1);
19960 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
)
19962 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19964 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19966 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19968 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19970 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19972 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19974 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19976 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19978 return (arr_len
+ arr2_cpy
);
19981 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19983 if (upos
>= arr_len
) return (arr_len
);
19990 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19992 if (upos
>= arr_len
) return (arr_len
);
19994 memset (arr
+ upos
, 0, arr_len
- upos
);
19999 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20003 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20005 if (arr
[arr_pos
] != oldc
) continue;
20007 arr
[arr_pos
] = newc
;
20013 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20019 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20021 if (arr
[arr_pos
] == c
) continue;
20023 arr
[ret_len
] = arr
[arr_pos
];
20031 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20033 if (ulen
> arr_len
) return (arr_len
);
20035 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20037 char cs
[100] = { 0 };
20039 memcpy (cs
, arr
, ulen
);
20043 for (i
= 0; i
< ulen
; i
++)
20047 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20053 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20055 if (ulen
> arr_len
) return (arr_len
);
20057 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20059 int upos
= arr_len
- ulen
;
20063 for (i
= 0; i
< ulen
; i
++)
20065 char c
= arr
[upos
+ i
];
20067 arr_len
= mangle_append (arr
, arr_len
, c
);
20073 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20075 if ( arr_len
== 0) return (arr_len
);
20076 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20078 char c
= arr
[upos
];
20082 for (i
= 0; i
< ulen
; i
++)
20084 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20090 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20092 if ( arr_len
== 0) return (arr_len
);
20093 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20097 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20099 int new_pos
= arr_pos
* 2;
20101 arr
[new_pos
] = arr
[arr_pos
];
20103 arr
[new_pos
+ 1] = arr
[arr_pos
];
20106 return (arr_len
* 2);
20109 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20111 if (upos
>= arr_len
) return (arr_len
);
20112 if (upos2
>= arr_len
) return (arr_len
);
20114 MANGLE_SWITCH (arr
, upos
, upos2
);
20119 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20121 MANGLE_SWITCH (arr
, upos
, upos2
);
20126 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20128 if (upos
>= arr_len
) return (arr_len
);
20135 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20137 if (upos
>= arr_len
) return (arr_len
);
20144 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20146 if (upos
>= arr_len
) return (arr_len
);
20153 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20155 if (upos
>= arr_len
) return (arr_len
);
20162 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20164 int upper_next
= 1;
20168 for (pos
= 0; pos
< arr_len
; pos
++)
20170 if (arr
[pos
] == ' ')
20181 MANGLE_UPPER_AT (arr
, pos
);
20185 MANGLE_LOWER_AT (arr
, pos
);
20192 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20194 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20200 for (j
= 0; j
< rp_gen_num
; j
++)
20207 switch ((char) get_random_num (0, 9))
20210 r
= get_random_num (0, sizeof (grp_op_nop
));
20211 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20215 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20216 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20217 p1
= get_random_num (0, sizeof (grp_pos
));
20218 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20222 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20223 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20224 p1
= get_random_num (1, 6);
20225 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20229 r
= get_random_num (0, sizeof (grp_op_chr
));
20230 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20231 p1
= get_random_num (0x20, 0x7e);
20232 rule_buf
[rule_pos
++] = (char) p1
;
20236 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20237 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20238 p1
= get_random_num (0x20, 0x7e);
20239 rule_buf
[rule_pos
++] = (char) p1
;
20240 p2
= get_random_num (0x20, 0x7e);
20242 p2
= get_random_num (0x20, 0x7e);
20243 rule_buf
[rule_pos
++] = (char) p2
;
20247 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20248 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20249 p1
= get_random_num (0, sizeof (grp_pos
));
20250 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20251 p2
= get_random_num (0x20, 0x7e);
20252 rule_buf
[rule_pos
++] = (char) p2
;
20256 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20257 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20258 p1
= get_random_num (0, sizeof (grp_pos
));
20259 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20260 p2
= get_random_num (0, sizeof (grp_pos
));
20262 p2
= get_random_num (0, sizeof (grp_pos
));
20263 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20267 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20268 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20269 p1
= get_random_num (0, sizeof (grp_pos
));
20270 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20271 p2
= get_random_num (1, sizeof (grp_pos
));
20273 p2
= get_random_num (1, sizeof (grp_pos
));
20274 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20278 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20279 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20280 p1
= get_random_num (0, sizeof (grp_pos
));
20281 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20282 p2
= get_random_num (1, sizeof (grp_pos
));
20283 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20284 p3
= get_random_num (0, sizeof (grp_pos
));
20285 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20293 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20295 char mem
[BLOCK_SIZE
] = { 0 };
20297 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20299 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20301 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20303 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20305 int out_len
= in_len
;
20306 int mem_len
= in_len
;
20308 memcpy (out
, in
, out_len
);
20312 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20317 switch (rule
[rule_pos
])
20322 case RULE_OP_MANGLE_NOOP
:
20325 case RULE_OP_MANGLE_LREST
:
20326 out_len
= mangle_lrest (out
, out_len
);
20329 case RULE_OP_MANGLE_UREST
:
20330 out_len
= mangle_urest (out
, out_len
);
20333 case RULE_OP_MANGLE_LREST_UFIRST
:
20334 out_len
= mangle_lrest (out
, out_len
);
20335 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20338 case RULE_OP_MANGLE_UREST_LFIRST
:
20339 out_len
= mangle_urest (out
, out_len
);
20340 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20343 case RULE_OP_MANGLE_TREST
:
20344 out_len
= mangle_trest (out
, out_len
);
20347 case RULE_OP_MANGLE_TOGGLE_AT
:
20348 NEXT_RULEPOS (rule_pos
);
20349 NEXT_RPTOI (rule
, rule_pos
, upos
);
20350 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20353 case RULE_OP_MANGLE_REVERSE
:
20354 out_len
= mangle_reverse (out
, out_len
);
20357 case RULE_OP_MANGLE_DUPEWORD
:
20358 out_len
= mangle_double (out
, out_len
);
20361 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20362 NEXT_RULEPOS (rule_pos
);
20363 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20364 out_len
= mangle_double_times (out
, out_len
, ulen
);
20367 case RULE_OP_MANGLE_REFLECT
:
20368 out_len
= mangle_reflect (out
, out_len
);
20371 case RULE_OP_MANGLE_ROTATE_LEFT
:
20372 mangle_rotate_left (out
, out_len
);
20375 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20376 mangle_rotate_right (out
, out_len
);
20379 case RULE_OP_MANGLE_APPEND
:
20380 NEXT_RULEPOS (rule_pos
);
20381 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20384 case RULE_OP_MANGLE_PREPEND
:
20385 NEXT_RULEPOS (rule_pos
);
20386 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20389 case RULE_OP_MANGLE_DELETE_FIRST
:
20390 out_len
= mangle_delete_at (out
, out_len
, 0);
20393 case RULE_OP_MANGLE_DELETE_LAST
:
20394 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20397 case RULE_OP_MANGLE_DELETE_AT
:
20398 NEXT_RULEPOS (rule_pos
);
20399 NEXT_RPTOI (rule
, rule_pos
, upos
);
20400 out_len
= mangle_delete_at (out
, out_len
, upos
);
20403 case RULE_OP_MANGLE_EXTRACT
:
20404 NEXT_RULEPOS (rule_pos
);
20405 NEXT_RPTOI (rule
, rule_pos
, upos
);
20406 NEXT_RULEPOS (rule_pos
);
20407 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20408 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20411 case RULE_OP_MANGLE_OMIT
:
20412 NEXT_RULEPOS (rule_pos
);
20413 NEXT_RPTOI (rule
, rule_pos
, upos
);
20414 NEXT_RULEPOS (rule_pos
);
20415 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20416 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20419 case RULE_OP_MANGLE_INSERT
:
20420 NEXT_RULEPOS (rule_pos
);
20421 NEXT_RPTOI (rule
, rule_pos
, upos
);
20422 NEXT_RULEPOS (rule_pos
);
20423 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20426 case RULE_OP_MANGLE_OVERSTRIKE
:
20427 NEXT_RULEPOS (rule_pos
);
20428 NEXT_RPTOI (rule
, rule_pos
, upos
);
20429 NEXT_RULEPOS (rule_pos
);
20430 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20433 case RULE_OP_MANGLE_TRUNCATE_AT
:
20434 NEXT_RULEPOS (rule_pos
);
20435 NEXT_RPTOI (rule
, rule_pos
, upos
);
20436 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20439 case RULE_OP_MANGLE_REPLACE
:
20440 NEXT_RULEPOS (rule_pos
);
20441 NEXT_RULEPOS (rule_pos
);
20442 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20445 case RULE_OP_MANGLE_PURGECHAR
:
20446 NEXT_RULEPOS (rule_pos
);
20447 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20450 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20454 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20455 NEXT_RULEPOS (rule_pos
);
20456 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20457 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20460 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20461 NEXT_RULEPOS (rule_pos
);
20462 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20463 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20466 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20467 out_len
= mangle_dupechar (out
, out_len
);
20470 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20471 NEXT_RULEPOS (rule_pos
);
20472 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20473 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20476 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20477 NEXT_RULEPOS (rule_pos
);
20478 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20479 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20482 case RULE_OP_MANGLE_SWITCH_FIRST
:
20483 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20486 case RULE_OP_MANGLE_SWITCH_LAST
:
20487 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20490 case RULE_OP_MANGLE_SWITCH_AT
:
20491 NEXT_RULEPOS (rule_pos
);
20492 NEXT_RPTOI (rule
, rule_pos
, upos
);
20493 NEXT_RULEPOS (rule_pos
);
20494 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20495 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20498 case RULE_OP_MANGLE_CHR_SHIFTL
:
20499 NEXT_RULEPOS (rule_pos
);
20500 NEXT_RPTOI (rule
, rule_pos
, upos
);
20501 mangle_chr_shiftl (out
, out_len
, upos
);
20504 case RULE_OP_MANGLE_CHR_SHIFTR
:
20505 NEXT_RULEPOS (rule_pos
);
20506 NEXT_RPTOI (rule
, rule_pos
, upos
);
20507 mangle_chr_shiftr (out
, out_len
, upos
);
20510 case RULE_OP_MANGLE_CHR_INCR
:
20511 NEXT_RULEPOS (rule_pos
);
20512 NEXT_RPTOI (rule
, rule_pos
, upos
);
20513 mangle_chr_incr (out
, out_len
, upos
);
20516 case RULE_OP_MANGLE_CHR_DECR
:
20517 NEXT_RULEPOS (rule_pos
);
20518 NEXT_RPTOI (rule
, rule_pos
, upos
);
20519 mangle_chr_decr (out
, out_len
, upos
);
20522 case RULE_OP_MANGLE_REPLACE_NP1
:
20523 NEXT_RULEPOS (rule_pos
);
20524 NEXT_RPTOI (rule
, rule_pos
, upos
);
20525 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20528 case RULE_OP_MANGLE_REPLACE_NM1
:
20529 NEXT_RULEPOS (rule_pos
);
20530 NEXT_RPTOI (rule
, rule_pos
, upos
);
20531 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20534 case RULE_OP_MANGLE_TITLE
:
20535 out_len
= mangle_title (out
, out_len
);
20538 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20539 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20540 NEXT_RULEPOS (rule_pos
);
20541 NEXT_RPTOI (rule
, rule_pos
, upos
);
20542 NEXT_RULEPOS (rule_pos
);
20543 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20544 NEXT_RULEPOS (rule_pos
);
20545 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20546 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20549 case RULE_OP_MANGLE_APPEND_MEMORY
:
20550 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20551 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20552 memcpy (out
+ out_len
, mem
, mem_len
);
20553 out_len
+= mem_len
;
20556 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20557 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20558 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20559 memcpy (mem
+ mem_len
, out
, out_len
);
20560 out_len
+= mem_len
;
20561 memcpy (out
, mem
, out_len
);
20564 case RULE_OP_MEMORIZE_WORD
:
20565 memcpy (mem
, out
, out_len
);
20569 case RULE_OP_REJECT_LESS
:
20570 NEXT_RULEPOS (rule_pos
);
20571 NEXT_RPTOI (rule
, rule_pos
, upos
);
20572 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20575 case RULE_OP_REJECT_GREATER
:
20576 NEXT_RULEPOS (rule_pos
);
20577 NEXT_RPTOI (rule
, rule_pos
, upos
);
20578 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20581 case RULE_OP_REJECT_CONTAIN
:
20582 NEXT_RULEPOS (rule_pos
);
20583 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20586 case RULE_OP_REJECT_NOT_CONTAIN
:
20587 NEXT_RULEPOS (rule_pos
);
20588 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20591 case RULE_OP_REJECT_EQUAL_FIRST
:
20592 NEXT_RULEPOS (rule_pos
);
20593 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20596 case RULE_OP_REJECT_EQUAL_LAST
:
20597 NEXT_RULEPOS (rule_pos
);
20598 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20601 case RULE_OP_REJECT_EQUAL_AT
:
20602 NEXT_RULEPOS (rule_pos
);
20603 NEXT_RPTOI (rule
, rule_pos
, upos
);
20604 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20605 NEXT_RULEPOS (rule_pos
);
20606 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20609 case RULE_OP_REJECT_CONTAINS
:
20610 NEXT_RULEPOS (rule_pos
);
20611 NEXT_RPTOI (rule
, rule_pos
, upos
);
20612 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20613 NEXT_RULEPOS (rule_pos
);
20614 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20615 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20618 case RULE_OP_REJECT_MEMORY
:
20619 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20623 return (RULE_RC_SYNTAX_ERROR
);
20628 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);