2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
19 #define GET_ACCEL(x) KERNEL_ACCEL_ ## x
20 #define GET_LOOPS(x) KERNEL_LOOPS_ ## x
26 u32
rotl32 (const u32 a
, const u32 n
)
28 return ((a
<< n
) | (a
>> (32 - n
)));
31 u32
rotr32 (const u32 a
, const u32 n
)
33 return ((a
>> n
) | (a
<< (32 - n
)));
36 u64
rotl64 (const u64 a
, const u64 n
)
38 return ((a
<< n
) | (a
>> (64 - n
)));
41 u64
rotr64 (const u64 a
, const u64 n
)
43 return ((a
>> n
) | (a
<< (64 - n
)));
46 u32
byte_swap_32 (const u32 n
)
48 return (n
& 0xff000000) >> 24
49 | (n
& 0x00ff0000) >> 8
50 | (n
& 0x0000ff00) << 8
51 | (n
& 0x000000ff) << 24;
54 u64
byte_swap_64 (const u64 n
)
56 return (n
& 0xff00000000000000ULL
) >> 56
57 | (n
& 0x00ff000000000000ULL
) >> 40
58 | (n
& 0x0000ff0000000000ULL
) >> 24
59 | (n
& 0x000000ff00000000ULL
) >> 8
60 | (n
& 0x00000000ff000000ULL
) << 8
61 | (n
& 0x0000000000ff0000ULL
) << 24
62 | (n
& 0x000000000000ff00ULL
) << 40
63 | (n
& 0x00000000000000ffULL
) << 56;
67 * ciphers for use on cpu
74 * hashes for use on cpu
78 #include "cpu-sha256.c"
86 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
92 for (int i
= 0; i
< last_len
; i
++)
100 char s
[4096] = { 0 };
102 int max_len
= (int) sizeof (s
);
104 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
106 if (len
> max_len
) len
= max_len
;
108 fwrite (s
, len
, 1, fp
);
115 void log_out_nn (FILE *fp
, const char *fmt
, ...)
117 if (SUPPRESS_OUTPUT
) return;
123 log_final (fp
, fmt
, ap
);
128 void log_info_nn (const char *fmt
, ...)
130 if (SUPPRESS_OUTPUT
) return;
136 log_final (stdout
, fmt
, ap
);
141 void log_error_nn (const char *fmt
, ...)
143 if (SUPPRESS_OUTPUT
) return;
149 log_final (stderr
, fmt
, ap
);
154 void log_out (FILE *fp
, const char *fmt
, ...)
156 if (SUPPRESS_OUTPUT
) return;
162 log_final (fp
, fmt
, ap
);
171 void log_info (const char *fmt
, ...)
173 if (SUPPRESS_OUTPUT
) return;
179 log_final (stdout
, fmt
, ap
);
183 fputc ('\n', stdout
);
188 void log_error (const char *fmt
, ...)
190 if (SUPPRESS_OUTPUT
) return;
192 fputc ('\n', stderr
);
193 fputc ('\n', stderr
);
199 log_final (stderr
, fmt
, ap
);
203 fputc ('\n', stderr
);
204 fputc ('\n', stderr
);
213 u8
int_to_base32 (const u8 c
)
215 static const u8 tbl
[0x20] =
217 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
218 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
224 u8
base32_to_int (const u8 c
)
226 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
227 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
232 u8
int_to_itoa32 (const u8 c
)
234 static const u8 tbl
[0x20] =
236 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
237 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
243 u8
itoa32_to_int (const u8 c
)
245 if ((c
>= '0') && (c
<= '9')) return c
- '0';
246 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
251 u8
int_to_itoa64 (const u8 c
)
253 static const u8 tbl
[0x40] =
255 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
256 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
257 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
258 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
264 u8
itoa64_to_int (const u8 c
)
266 static const u8 tbl
[0x100] =
268 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
269 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
270 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
271 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
272 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
273 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
274 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
275 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
276 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
277 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
278 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
279 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
280 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
281 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
282 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
283 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
289 u8
int_to_base64 (const u8 c
)
291 static const u8 tbl
[0x40] =
293 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
294 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
295 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
296 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
302 u8
base64_to_int (const u8 c
)
304 static const u8 tbl
[0x100] =
306 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
308 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
309 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
310 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
311 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
313 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
327 u8
int_to_bf64 (const u8 c
)
329 static const u8 tbl
[0x40] =
331 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
332 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
333 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
334 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
340 u8
bf64_to_int (const u8 c
)
342 static const u8 tbl
[0x100] =
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
346 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
347 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
348 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
349 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
350 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
351 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
365 u8
int_to_lotus64 (const u8 c
)
367 if (c
< 10) return '0' + c
;
368 else if (c
< 36) return 'A' + c
- 10;
369 else if (c
< 62) return 'a' + c
- 36;
370 else if (c
== 62) return '+';
371 else if (c
== 63) return '/';
376 u8
lotus64_to_int (const u8 c
)
378 if ((c
>= '0') && (c
<= '9')) return c
- '0';
379 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
380 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
381 else if (c
== '+') return 62;
382 else if (c
== '/') return 63;
388 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
390 const u8
*in_ptr
= in_buf
;
392 u8
*out_ptr
= out_buf
;
394 for (int i
= 0; i
< in_len
; i
+= 8)
396 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
397 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
398 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
399 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
400 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
401 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
402 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
403 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
405 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
406 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
407 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
408 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
409 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
415 for (int i
= 0; i
< in_len
; i
++)
417 if (in_buf
[i
] != '=') continue;
422 int out_len
= (in_len
* 5) / 8;
427 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
429 const u8
*in_ptr
= in_buf
;
431 u8
*out_ptr
= out_buf
;
433 for (int i
= 0; i
< in_len
; i
+= 5)
435 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
436 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
437 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
438 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
439 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
440 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
441 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
442 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
444 out_ptr
[0] = out_val0
& 0x7f;
445 out_ptr
[1] = out_val1
& 0x7f;
446 out_ptr
[2] = out_val2
& 0x7f;
447 out_ptr
[3] = out_val3
& 0x7f;
448 out_ptr
[4] = out_val4
& 0x7f;
449 out_ptr
[5] = out_val5
& 0x7f;
450 out_ptr
[6] = out_val6
& 0x7f;
451 out_ptr
[7] = out_val7
& 0x7f;
457 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
461 out_buf
[out_len
] = '=';
469 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
471 const u8
*in_ptr
= in_buf
;
473 u8
*out_ptr
= out_buf
;
475 for (int i
= 0; i
< in_len
; i
+= 4)
477 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
478 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
479 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
480 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
482 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
483 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
484 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
490 for (int i
= 0; i
< in_len
; i
++)
492 if (in_buf
[i
] != '=') continue;
497 int out_len
= (in_len
* 6) / 8;
502 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
504 const u8
*in_ptr
= in_buf
;
506 u8
*out_ptr
= out_buf
;
508 for (int i
= 0; i
< in_len
; i
+= 3)
510 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
511 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
512 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
513 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
515 out_ptr
[0] = out_val0
& 0x7f;
516 out_ptr
[1] = out_val1
& 0x7f;
517 out_ptr
[2] = out_val2
& 0x7f;
518 out_ptr
[3] = out_val3
& 0x7f;
524 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
528 out_buf
[out_len
] = '=';
536 int is_valid_hex_char (const u8 c
)
538 if ((c
>= '0') && (c
<= '9')) return 1;
539 if ((c
>= 'A') && (c
<= 'F')) return 1;
540 if ((c
>= 'a') && (c
<= 'f')) return 1;
545 u8
hex_convert (const u8 c
)
547 return (c
& 15) + (c
>> 6) * 9;
550 u8
hex_to_u8 (const u8 hex
[2])
554 v
|= (hex_convert (hex
[1]) << 0);
555 v
|= (hex_convert (hex
[0]) << 4);
560 u32
hex_to_u32 (const u8 hex
[8])
564 v
|= ((u32
) hex_convert (hex
[7])) << 0;
565 v
|= ((u32
) hex_convert (hex
[6])) << 4;
566 v
|= ((u32
) hex_convert (hex
[5])) << 8;
567 v
|= ((u32
) hex_convert (hex
[4])) << 12;
568 v
|= ((u32
) hex_convert (hex
[3])) << 16;
569 v
|= ((u32
) hex_convert (hex
[2])) << 20;
570 v
|= ((u32
) hex_convert (hex
[1])) << 24;
571 v
|= ((u32
) hex_convert (hex
[0])) << 28;
576 u64
hex_to_u64 (const u8 hex
[16])
580 v
|= ((u64
) hex_convert (hex
[15]) << 0);
581 v
|= ((u64
) hex_convert (hex
[14]) << 4);
582 v
|= ((u64
) hex_convert (hex
[13]) << 8);
583 v
|= ((u64
) hex_convert (hex
[12]) << 12);
584 v
|= ((u64
) hex_convert (hex
[11]) << 16);
585 v
|= ((u64
) hex_convert (hex
[10]) << 20);
586 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
587 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
588 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
589 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
590 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
591 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
592 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
593 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
594 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
595 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
600 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
602 hex
[0] = v
>> 28 & 15;
603 hex
[1] = v
>> 24 & 15;
604 hex
[2] = v
>> 20 & 15;
605 hex
[3] = v
>> 16 & 15;
606 hex
[4] = v
>> 12 & 15;
607 hex
[5] = v
>> 8 & 15;
608 hex
[6] = v
>> 4 & 15;
609 hex
[7] = v
>> 0 & 15;
613 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
614 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
615 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
616 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
617 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
618 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
619 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
620 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
627 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
631 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
640 for (int i
= 0; i
< 16; i
+= 4)
650 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
657 out
[i
+ 0] = _out
[0];
658 out
[i
+ 1] = _out
[1];
659 out
[i
+ 2] = _out
[2];
660 out
[i
+ 3] = _out
[3];
669 static void juniper_decrypt_hash (char *in
, char *out
)
673 u8 base64_buf
[100] = { 0 };
675 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
679 u32 juniper_iv
[4] = { 0 };
681 memcpy (juniper_iv
, base64_buf
, 12);
683 memcpy (out
, juniper_iv
, 12);
687 u32 juniper_key
[4] = { 0 };
689 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
690 juniper_key
[1] = byte_swap_32 (0x8df91059);
691 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
692 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
696 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
697 u32
*out_ptr
= (u32
*) (out
+ 12);
699 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
702 void phpass_decode (u8 digest
[16], u8 buf
[22])
706 l
= itoa64_to_int (buf
[ 0]) << 0;
707 l
|= itoa64_to_int (buf
[ 1]) << 6;
708 l
|= itoa64_to_int (buf
[ 2]) << 12;
709 l
|= itoa64_to_int (buf
[ 3]) << 18;
711 digest
[ 0] = (l
>> 0) & 0xff;
712 digest
[ 1] = (l
>> 8) & 0xff;
713 digest
[ 2] = (l
>> 16) & 0xff;
715 l
= itoa64_to_int (buf
[ 4]) << 0;
716 l
|= itoa64_to_int (buf
[ 5]) << 6;
717 l
|= itoa64_to_int (buf
[ 6]) << 12;
718 l
|= itoa64_to_int (buf
[ 7]) << 18;
720 digest
[ 3] = (l
>> 0) & 0xff;
721 digest
[ 4] = (l
>> 8) & 0xff;
722 digest
[ 5] = (l
>> 16) & 0xff;
724 l
= itoa64_to_int (buf
[ 8]) << 0;
725 l
|= itoa64_to_int (buf
[ 9]) << 6;
726 l
|= itoa64_to_int (buf
[10]) << 12;
727 l
|= itoa64_to_int (buf
[11]) << 18;
729 digest
[ 6] = (l
>> 0) & 0xff;
730 digest
[ 7] = (l
>> 8) & 0xff;
731 digest
[ 8] = (l
>> 16) & 0xff;
733 l
= itoa64_to_int (buf
[12]) << 0;
734 l
|= itoa64_to_int (buf
[13]) << 6;
735 l
|= itoa64_to_int (buf
[14]) << 12;
736 l
|= itoa64_to_int (buf
[15]) << 18;
738 digest
[ 9] = (l
>> 0) & 0xff;
739 digest
[10] = (l
>> 8) & 0xff;
740 digest
[11] = (l
>> 16) & 0xff;
742 l
= itoa64_to_int (buf
[16]) << 0;
743 l
|= itoa64_to_int (buf
[17]) << 6;
744 l
|= itoa64_to_int (buf
[18]) << 12;
745 l
|= itoa64_to_int (buf
[19]) << 18;
747 digest
[12] = (l
>> 0) & 0xff;
748 digest
[13] = (l
>> 8) & 0xff;
749 digest
[14] = (l
>> 16) & 0xff;
751 l
= itoa64_to_int (buf
[20]) << 0;
752 l
|= itoa64_to_int (buf
[21]) << 6;
754 digest
[15] = (l
>> 0) & 0xff;
757 void phpass_encode (u8 digest
[16], u8 buf
[22])
761 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
763 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
766 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
768 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
770 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
773 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
775 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
777 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[11] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
784 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[15] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
791 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[19] = int_to_itoa64 (l
& 0x3f);
796 l
= (digest
[15] << 0);
798 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[21] = int_to_itoa64 (l
& 0x3f);
802 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
806 l
= itoa64_to_int (buf
[ 0]) << 0;
807 l
|= itoa64_to_int (buf
[ 1]) << 6;
808 l
|= itoa64_to_int (buf
[ 2]) << 12;
809 l
|= itoa64_to_int (buf
[ 3]) << 18;
811 digest
[ 0] = (l
>> 16) & 0xff;
812 digest
[ 6] = (l
>> 8) & 0xff;
813 digest
[12] = (l
>> 0) & 0xff;
815 l
= itoa64_to_int (buf
[ 4]) << 0;
816 l
|= itoa64_to_int (buf
[ 5]) << 6;
817 l
|= itoa64_to_int (buf
[ 6]) << 12;
818 l
|= itoa64_to_int (buf
[ 7]) << 18;
820 digest
[ 1] = (l
>> 16) & 0xff;
821 digest
[ 7] = (l
>> 8) & 0xff;
822 digest
[13] = (l
>> 0) & 0xff;
824 l
= itoa64_to_int (buf
[ 8]) << 0;
825 l
|= itoa64_to_int (buf
[ 9]) << 6;
826 l
|= itoa64_to_int (buf
[10]) << 12;
827 l
|= itoa64_to_int (buf
[11]) << 18;
829 digest
[ 2] = (l
>> 16) & 0xff;
830 digest
[ 8] = (l
>> 8) & 0xff;
831 digest
[14] = (l
>> 0) & 0xff;
833 l
= itoa64_to_int (buf
[12]) << 0;
834 l
|= itoa64_to_int (buf
[13]) << 6;
835 l
|= itoa64_to_int (buf
[14]) << 12;
836 l
|= itoa64_to_int (buf
[15]) << 18;
838 digest
[ 3] = (l
>> 16) & 0xff;
839 digest
[ 9] = (l
>> 8) & 0xff;
840 digest
[15] = (l
>> 0) & 0xff;
842 l
= itoa64_to_int (buf
[16]) << 0;
843 l
|= itoa64_to_int (buf
[17]) << 6;
844 l
|= itoa64_to_int (buf
[18]) << 12;
845 l
|= itoa64_to_int (buf
[19]) << 18;
847 digest
[ 4] = (l
>> 16) & 0xff;
848 digest
[10] = (l
>> 8) & 0xff;
849 digest
[ 5] = (l
>> 0) & 0xff;
851 l
= itoa64_to_int (buf
[20]) << 0;
852 l
|= itoa64_to_int (buf
[21]) << 6;
854 digest
[11] = (l
>> 0) & 0xff;
857 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
861 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
863 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
866 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
870 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
873 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
877 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
884 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
891 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 l
= (digest
[11] << 0);
898 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
902 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
906 l
= itoa64_to_int (buf
[ 0]) << 0;
907 l
|= itoa64_to_int (buf
[ 1]) << 6;
908 l
|= itoa64_to_int (buf
[ 2]) << 12;
909 l
|= itoa64_to_int (buf
[ 3]) << 18;
911 digest
[ 0] = (l
>> 16) & 0xff;
912 digest
[21] = (l
>> 8) & 0xff;
913 digest
[42] = (l
>> 0) & 0xff;
915 l
= itoa64_to_int (buf
[ 4]) << 0;
916 l
|= itoa64_to_int (buf
[ 5]) << 6;
917 l
|= itoa64_to_int (buf
[ 6]) << 12;
918 l
|= itoa64_to_int (buf
[ 7]) << 18;
920 digest
[22] = (l
>> 16) & 0xff;
921 digest
[43] = (l
>> 8) & 0xff;
922 digest
[ 1] = (l
>> 0) & 0xff;
924 l
= itoa64_to_int (buf
[ 8]) << 0;
925 l
|= itoa64_to_int (buf
[ 9]) << 6;
926 l
|= itoa64_to_int (buf
[10]) << 12;
927 l
|= itoa64_to_int (buf
[11]) << 18;
929 digest
[44] = (l
>> 16) & 0xff;
930 digest
[ 2] = (l
>> 8) & 0xff;
931 digest
[23] = (l
>> 0) & 0xff;
933 l
= itoa64_to_int (buf
[12]) << 0;
934 l
|= itoa64_to_int (buf
[13]) << 6;
935 l
|= itoa64_to_int (buf
[14]) << 12;
936 l
|= itoa64_to_int (buf
[15]) << 18;
938 digest
[ 3] = (l
>> 16) & 0xff;
939 digest
[24] = (l
>> 8) & 0xff;
940 digest
[45] = (l
>> 0) & 0xff;
942 l
= itoa64_to_int (buf
[16]) << 0;
943 l
|= itoa64_to_int (buf
[17]) << 6;
944 l
|= itoa64_to_int (buf
[18]) << 12;
945 l
|= itoa64_to_int (buf
[19]) << 18;
947 digest
[25] = (l
>> 16) & 0xff;
948 digest
[46] = (l
>> 8) & 0xff;
949 digest
[ 4] = (l
>> 0) & 0xff;
951 l
= itoa64_to_int (buf
[20]) << 0;
952 l
|= itoa64_to_int (buf
[21]) << 6;
953 l
|= itoa64_to_int (buf
[22]) << 12;
954 l
|= itoa64_to_int (buf
[23]) << 18;
956 digest
[47] = (l
>> 16) & 0xff;
957 digest
[ 5] = (l
>> 8) & 0xff;
958 digest
[26] = (l
>> 0) & 0xff;
960 l
= itoa64_to_int (buf
[24]) << 0;
961 l
|= itoa64_to_int (buf
[25]) << 6;
962 l
|= itoa64_to_int (buf
[26]) << 12;
963 l
|= itoa64_to_int (buf
[27]) << 18;
965 digest
[ 6] = (l
>> 16) & 0xff;
966 digest
[27] = (l
>> 8) & 0xff;
967 digest
[48] = (l
>> 0) & 0xff;
969 l
= itoa64_to_int (buf
[28]) << 0;
970 l
|= itoa64_to_int (buf
[29]) << 6;
971 l
|= itoa64_to_int (buf
[30]) << 12;
972 l
|= itoa64_to_int (buf
[31]) << 18;
974 digest
[28] = (l
>> 16) & 0xff;
975 digest
[49] = (l
>> 8) & 0xff;
976 digest
[ 7] = (l
>> 0) & 0xff;
978 l
= itoa64_to_int (buf
[32]) << 0;
979 l
|= itoa64_to_int (buf
[33]) << 6;
980 l
|= itoa64_to_int (buf
[34]) << 12;
981 l
|= itoa64_to_int (buf
[35]) << 18;
983 digest
[50] = (l
>> 16) & 0xff;
984 digest
[ 8] = (l
>> 8) & 0xff;
985 digest
[29] = (l
>> 0) & 0xff;
987 l
= itoa64_to_int (buf
[36]) << 0;
988 l
|= itoa64_to_int (buf
[37]) << 6;
989 l
|= itoa64_to_int (buf
[38]) << 12;
990 l
|= itoa64_to_int (buf
[39]) << 18;
992 digest
[ 9] = (l
>> 16) & 0xff;
993 digest
[30] = (l
>> 8) & 0xff;
994 digest
[51] = (l
>> 0) & 0xff;
996 l
= itoa64_to_int (buf
[40]) << 0;
997 l
|= itoa64_to_int (buf
[41]) << 6;
998 l
|= itoa64_to_int (buf
[42]) << 12;
999 l
|= itoa64_to_int (buf
[43]) << 18;
1001 digest
[31] = (l
>> 16) & 0xff;
1002 digest
[52] = (l
>> 8) & 0xff;
1003 digest
[10] = (l
>> 0) & 0xff;
1005 l
= itoa64_to_int (buf
[44]) << 0;
1006 l
|= itoa64_to_int (buf
[45]) << 6;
1007 l
|= itoa64_to_int (buf
[46]) << 12;
1008 l
|= itoa64_to_int (buf
[47]) << 18;
1010 digest
[53] = (l
>> 16) & 0xff;
1011 digest
[11] = (l
>> 8) & 0xff;
1012 digest
[32] = (l
>> 0) & 0xff;
1014 l
= itoa64_to_int (buf
[48]) << 0;
1015 l
|= itoa64_to_int (buf
[49]) << 6;
1016 l
|= itoa64_to_int (buf
[50]) << 12;
1017 l
|= itoa64_to_int (buf
[51]) << 18;
1019 digest
[12] = (l
>> 16) & 0xff;
1020 digest
[33] = (l
>> 8) & 0xff;
1021 digest
[54] = (l
>> 0) & 0xff;
1023 l
= itoa64_to_int (buf
[52]) << 0;
1024 l
|= itoa64_to_int (buf
[53]) << 6;
1025 l
|= itoa64_to_int (buf
[54]) << 12;
1026 l
|= itoa64_to_int (buf
[55]) << 18;
1028 digest
[34] = (l
>> 16) & 0xff;
1029 digest
[55] = (l
>> 8) & 0xff;
1030 digest
[13] = (l
>> 0) & 0xff;
1032 l
= itoa64_to_int (buf
[56]) << 0;
1033 l
|= itoa64_to_int (buf
[57]) << 6;
1034 l
|= itoa64_to_int (buf
[58]) << 12;
1035 l
|= itoa64_to_int (buf
[59]) << 18;
1037 digest
[56] = (l
>> 16) & 0xff;
1038 digest
[14] = (l
>> 8) & 0xff;
1039 digest
[35] = (l
>> 0) & 0xff;
1041 l
= itoa64_to_int (buf
[60]) << 0;
1042 l
|= itoa64_to_int (buf
[61]) << 6;
1043 l
|= itoa64_to_int (buf
[62]) << 12;
1044 l
|= itoa64_to_int (buf
[63]) << 18;
1046 digest
[15] = (l
>> 16) & 0xff;
1047 digest
[36] = (l
>> 8) & 0xff;
1048 digest
[57] = (l
>> 0) & 0xff;
1050 l
= itoa64_to_int (buf
[64]) << 0;
1051 l
|= itoa64_to_int (buf
[65]) << 6;
1052 l
|= itoa64_to_int (buf
[66]) << 12;
1053 l
|= itoa64_to_int (buf
[67]) << 18;
1055 digest
[37] = (l
>> 16) & 0xff;
1056 digest
[58] = (l
>> 8) & 0xff;
1057 digest
[16] = (l
>> 0) & 0xff;
1059 l
= itoa64_to_int (buf
[68]) << 0;
1060 l
|= itoa64_to_int (buf
[69]) << 6;
1061 l
|= itoa64_to_int (buf
[70]) << 12;
1062 l
|= itoa64_to_int (buf
[71]) << 18;
1064 digest
[59] = (l
>> 16) & 0xff;
1065 digest
[17] = (l
>> 8) & 0xff;
1066 digest
[38] = (l
>> 0) & 0xff;
1068 l
= itoa64_to_int (buf
[72]) << 0;
1069 l
|= itoa64_to_int (buf
[73]) << 6;
1070 l
|= itoa64_to_int (buf
[74]) << 12;
1071 l
|= itoa64_to_int (buf
[75]) << 18;
1073 digest
[18] = (l
>> 16) & 0xff;
1074 digest
[39] = (l
>> 8) & 0xff;
1075 digest
[60] = (l
>> 0) & 0xff;
1077 l
= itoa64_to_int (buf
[76]) << 0;
1078 l
|= itoa64_to_int (buf
[77]) << 6;
1079 l
|= itoa64_to_int (buf
[78]) << 12;
1080 l
|= itoa64_to_int (buf
[79]) << 18;
1082 digest
[40] = (l
>> 16) & 0xff;
1083 digest
[61] = (l
>> 8) & 0xff;
1084 digest
[19] = (l
>> 0) & 0xff;
1086 l
= itoa64_to_int (buf
[80]) << 0;
1087 l
|= itoa64_to_int (buf
[81]) << 6;
1088 l
|= itoa64_to_int (buf
[82]) << 12;
1089 l
|= itoa64_to_int (buf
[83]) << 18;
1091 digest
[62] = (l
>> 16) & 0xff;
1092 digest
[20] = (l
>> 8) & 0xff;
1093 digest
[41] = (l
>> 0) & 0xff;
1095 l
= itoa64_to_int (buf
[84]) << 0;
1096 l
|= itoa64_to_int (buf
[85]) << 6;
1098 digest
[63] = (l
>> 0) & 0xff;
1101 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1105 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1107 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1110 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1114 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1117 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1121 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1128 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1135 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1142 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1149 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1156 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1163 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1170 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1177 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1184 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1191 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1198 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1205 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1212 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1219 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1226 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1233 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1240 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1247 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 l
= 0 | 0 | (digest
[63] << 0);
1254 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1258 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1262 l
= itoa64_to_int (buf
[ 0]) << 0;
1263 l
|= itoa64_to_int (buf
[ 1]) << 6;
1264 l
|= itoa64_to_int (buf
[ 2]) << 12;
1265 l
|= itoa64_to_int (buf
[ 3]) << 18;
1267 digest
[ 2] = (l
>> 0) & 0xff;
1268 digest
[ 1] = (l
>> 8) & 0xff;
1269 digest
[ 0] = (l
>> 16) & 0xff;
1271 l
= itoa64_to_int (buf
[ 4]) << 0;
1272 l
|= itoa64_to_int (buf
[ 5]) << 6;
1273 l
|= itoa64_to_int (buf
[ 6]) << 12;
1274 l
|= itoa64_to_int (buf
[ 7]) << 18;
1276 digest
[ 5] = (l
>> 0) & 0xff;
1277 digest
[ 4] = (l
>> 8) & 0xff;
1278 digest
[ 3] = (l
>> 16) & 0xff;
1280 l
= itoa64_to_int (buf
[ 8]) << 0;
1281 l
|= itoa64_to_int (buf
[ 9]) << 6;
1282 l
|= itoa64_to_int (buf
[10]) << 12;
1283 l
|= itoa64_to_int (buf
[11]) << 18;
1285 digest
[ 8] = (l
>> 0) & 0xff;
1286 digest
[ 7] = (l
>> 8) & 0xff;
1287 digest
[ 6] = (l
>> 16) & 0xff;
1289 l
= itoa64_to_int (buf
[12]) << 0;
1290 l
|= itoa64_to_int (buf
[13]) << 6;
1291 l
|= itoa64_to_int (buf
[14]) << 12;
1292 l
|= itoa64_to_int (buf
[15]) << 18;
1294 digest
[11] = (l
>> 0) & 0xff;
1295 digest
[10] = (l
>> 8) & 0xff;
1296 digest
[ 9] = (l
>> 16) & 0xff;
1298 l
= itoa64_to_int (buf
[16]) << 0;
1299 l
|= itoa64_to_int (buf
[17]) << 6;
1300 l
|= itoa64_to_int (buf
[18]) << 12;
1301 l
|= itoa64_to_int (buf
[19]) << 18;
1303 digest
[14] = (l
>> 0) & 0xff;
1304 digest
[13] = (l
>> 8) & 0xff;
1305 digest
[12] = (l
>> 16) & 0xff;
1307 l
= itoa64_to_int (buf
[20]) << 0;
1308 l
|= itoa64_to_int (buf
[21]) << 6;
1309 l
|= itoa64_to_int (buf
[22]) << 12;
1310 l
|= itoa64_to_int (buf
[23]) << 18;
1312 digest
[17] = (l
>> 0) & 0xff;
1313 digest
[16] = (l
>> 8) & 0xff;
1314 digest
[15] = (l
>> 16) & 0xff;
1316 l
= itoa64_to_int (buf
[24]) << 0;
1317 l
|= itoa64_to_int (buf
[25]) << 6;
1318 l
|= itoa64_to_int (buf
[26]) << 12;
1320 digest
[19] = (l
>> 8) & 0xff;
1321 digest
[18] = (l
>> 16) & 0xff;
1324 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1328 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1330 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1333 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1335 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1337 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1340 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1342 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1344 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[11] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1351 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[15] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1358 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[19] = int_to_itoa64 (l
& 0x3f);
1363 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1365 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[23] = int_to_itoa64 (l
& 0x3f);
1370 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1372 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1374 buf
[26] = int_to_itoa64 (l
& 0x3f);
1377 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1381 l
= itoa64_to_int (buf
[ 0]) << 0;
1382 l
|= itoa64_to_int (buf
[ 1]) << 6;
1383 l
|= itoa64_to_int (buf
[ 2]) << 12;
1384 l
|= itoa64_to_int (buf
[ 3]) << 18;
1386 digest
[ 2] = (l
>> 0) & 0xff;
1387 digest
[ 1] = (l
>> 8) & 0xff;
1388 digest
[ 0] = (l
>> 16) & 0xff;
1390 l
= itoa64_to_int (buf
[ 4]) << 0;
1391 l
|= itoa64_to_int (buf
[ 5]) << 6;
1392 l
|= itoa64_to_int (buf
[ 6]) << 12;
1393 l
|= itoa64_to_int (buf
[ 7]) << 18;
1395 digest
[ 5] = (l
>> 0) & 0xff;
1396 digest
[ 4] = (l
>> 8) & 0xff;
1397 digest
[ 3] = (l
>> 16) & 0xff;
1399 l
= itoa64_to_int (buf
[ 8]) << 0;
1400 l
|= itoa64_to_int (buf
[ 9]) << 6;
1401 l
|= itoa64_to_int (buf
[10]) << 12;
1402 l
|= itoa64_to_int (buf
[11]) << 18;
1404 digest
[ 8] = (l
>> 0) & 0xff;
1405 digest
[ 7] = (l
>> 8) & 0xff;
1406 digest
[ 6] = (l
>> 16) & 0xff;
1408 l
= itoa64_to_int (buf
[12]) << 0;
1409 l
|= itoa64_to_int (buf
[13]) << 6;
1410 l
|= itoa64_to_int (buf
[14]) << 12;
1411 l
|= itoa64_to_int (buf
[15]) << 18;
1413 digest
[11] = (l
>> 0) & 0xff;
1414 digest
[10] = (l
>> 8) & 0xff;
1415 digest
[ 9] = (l
>> 16) & 0xff;
1417 l
= itoa64_to_int (buf
[16]) << 0;
1418 l
|= itoa64_to_int (buf
[17]) << 6;
1419 l
|= itoa64_to_int (buf
[18]) << 12;
1420 l
|= itoa64_to_int (buf
[19]) << 18;
1422 digest
[14] = (l
>> 0) & 0xff;
1423 digest
[13] = (l
>> 8) & 0xff;
1424 digest
[12] = (l
>> 16) & 0xff;
1426 l
= itoa64_to_int (buf
[20]) << 0;
1427 l
|= itoa64_to_int (buf
[21]) << 6;
1428 l
|= itoa64_to_int (buf
[22]) << 12;
1429 l
|= itoa64_to_int (buf
[23]) << 18;
1431 digest
[17] = (l
>> 0) & 0xff;
1432 digest
[16] = (l
>> 8) & 0xff;
1433 digest
[15] = (l
>> 16) & 0xff;
1435 l
= itoa64_to_int (buf
[24]) << 0;
1436 l
|= itoa64_to_int (buf
[25]) << 6;
1437 l
|= itoa64_to_int (buf
[26]) << 12;
1438 l
|= itoa64_to_int (buf
[27]) << 18;
1440 digest
[20] = (l
>> 0) & 0xff;
1441 digest
[19] = (l
>> 8) & 0xff;
1442 digest
[18] = (l
>> 16) & 0xff;
1444 l
= itoa64_to_int (buf
[28]) << 0;
1445 l
|= itoa64_to_int (buf
[29]) << 6;
1446 l
|= itoa64_to_int (buf
[30]) << 12;
1447 l
|= itoa64_to_int (buf
[31]) << 18;
1449 digest
[23] = (l
>> 0) & 0xff;
1450 digest
[22] = (l
>> 8) & 0xff;
1451 digest
[21] = (l
>> 16) & 0xff;
1453 l
= itoa64_to_int (buf
[32]) << 0;
1454 l
|= itoa64_to_int (buf
[33]) << 6;
1455 l
|= itoa64_to_int (buf
[34]) << 12;
1456 l
|= itoa64_to_int (buf
[35]) << 18;
1458 digest
[26] = (l
>> 0) & 0xff;
1459 digest
[25] = (l
>> 8) & 0xff;
1460 digest
[24] = (l
>> 16) & 0xff;
1462 l
= itoa64_to_int (buf
[36]) << 0;
1463 l
|= itoa64_to_int (buf
[37]) << 6;
1464 l
|= itoa64_to_int (buf
[38]) << 12;
1465 l
|= itoa64_to_int (buf
[39]) << 18;
1467 digest
[29] = (l
>> 0) & 0xff;
1468 digest
[28] = (l
>> 8) & 0xff;
1469 digest
[27] = (l
>> 16) & 0xff;
1471 l
= itoa64_to_int (buf
[40]) << 0;
1472 l
|= itoa64_to_int (buf
[41]) << 6;
1473 l
|= itoa64_to_int (buf
[42]) << 12;
1475 //digest[32] = (l >> 0) & 0xff;
1476 digest
[31] = (l
>> 8) & 0xff;
1477 digest
[30] = (l
>> 16) & 0xff;
1480 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1484 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1486 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1489 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1491 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1493 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1496 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1498 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1500 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[11] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1507 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[15] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1514 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[19] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1521 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[23] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1528 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[27] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1535 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[31] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1542 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[35] = int_to_itoa64 (l
& 0x3f);
1547 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1549 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[39] = int_to_itoa64 (l
& 0x3f);
1554 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1556 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1558 buf
[42] = int_to_itoa64 (l
& 0x3f);
1561 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1565 l
= itoa64_to_int (buf
[ 0]) << 0;
1566 l
|= itoa64_to_int (buf
[ 1]) << 6;
1567 l
|= itoa64_to_int (buf
[ 2]) << 12;
1568 l
|= itoa64_to_int (buf
[ 3]) << 18;
1570 digest
[ 2] = (l
>> 0) & 0xff;
1571 digest
[ 1] = (l
>> 8) & 0xff;
1572 digest
[ 0] = (l
>> 16) & 0xff;
1574 l
= itoa64_to_int (buf
[ 4]) << 0;
1575 l
|= itoa64_to_int (buf
[ 5]) << 6;
1576 l
|= itoa64_to_int (buf
[ 6]) << 12;
1577 l
|= itoa64_to_int (buf
[ 7]) << 18;
1579 digest
[ 5] = (l
>> 0) & 0xff;
1580 digest
[ 4] = (l
>> 8) & 0xff;
1581 digest
[ 3] = (l
>> 16) & 0xff;
1583 l
= itoa64_to_int (buf
[ 8]) << 0;
1584 l
|= itoa64_to_int (buf
[ 9]) << 6;
1585 l
|= itoa64_to_int (buf
[10]) << 12;
1586 l
|= itoa64_to_int (buf
[11]) << 18;
1588 digest
[ 8] = (l
>> 0) & 0xff;
1589 digest
[ 7] = (l
>> 8) & 0xff;
1590 digest
[ 6] = (l
>> 16) & 0xff;
1592 l
= itoa64_to_int (buf
[12]) << 0;
1593 l
|= itoa64_to_int (buf
[13]) << 6;
1594 l
|= itoa64_to_int (buf
[14]) << 12;
1595 l
|= itoa64_to_int (buf
[15]) << 18;
1597 digest
[11] = (l
>> 0) & 0xff;
1598 digest
[10] = (l
>> 8) & 0xff;
1599 digest
[ 9] = (l
>> 16) & 0xff;
1601 l
= itoa64_to_int (buf
[16]) << 0;
1602 l
|= itoa64_to_int (buf
[17]) << 6;
1603 l
|= itoa64_to_int (buf
[18]) << 12;
1604 l
|= itoa64_to_int (buf
[19]) << 18;
1606 digest
[14] = (l
>> 0) & 0xff;
1607 digest
[13] = (l
>> 8) & 0xff;
1608 digest
[12] = (l
>> 16) & 0xff;
1610 l
= itoa64_to_int (buf
[20]) << 0;
1611 l
|= itoa64_to_int (buf
[21]) << 6;
1612 l
|= itoa64_to_int (buf
[22]) << 12;
1613 l
|= itoa64_to_int (buf
[23]) << 18;
1615 digest
[17] = (l
>> 0) & 0xff;
1616 digest
[16] = (l
>> 8) & 0xff;
1617 digest
[15] = (l
>> 16) & 0xff;
1619 l
= itoa64_to_int (buf
[24]) << 0;
1620 l
|= itoa64_to_int (buf
[25]) << 6;
1621 l
|= itoa64_to_int (buf
[26]) << 12;
1622 l
|= itoa64_to_int (buf
[27]) << 18;
1624 digest
[20] = (l
>> 0) & 0xff;
1625 digest
[19] = (l
>> 8) & 0xff;
1626 digest
[18] = (l
>> 16) & 0xff;
1628 l
= itoa64_to_int (buf
[28]) << 0;
1629 l
|= itoa64_to_int (buf
[29]) << 6;
1630 l
|= itoa64_to_int (buf
[30]) << 12;
1631 l
|= itoa64_to_int (buf
[31]) << 18;
1633 digest
[23] = (l
>> 0) & 0xff;
1634 digest
[22] = (l
>> 8) & 0xff;
1635 digest
[21] = (l
>> 16) & 0xff;
1637 l
= itoa64_to_int (buf
[32]) << 0;
1638 l
|= itoa64_to_int (buf
[33]) << 6;
1639 l
|= itoa64_to_int (buf
[34]) << 12;
1640 l
|= itoa64_to_int (buf
[35]) << 18;
1642 digest
[26] = (l
>> 0) & 0xff;
1643 digest
[25] = (l
>> 8) & 0xff;
1644 digest
[24] = (l
>> 16) & 0xff;
1646 l
= itoa64_to_int (buf
[36]) << 0;
1647 l
|= itoa64_to_int (buf
[37]) << 6;
1648 l
|= itoa64_to_int (buf
[38]) << 12;
1649 l
|= itoa64_to_int (buf
[39]) << 18;
1651 digest
[29] = (l
>> 0) & 0xff;
1652 digest
[28] = (l
>> 8) & 0xff;
1653 digest
[27] = (l
>> 16) & 0xff;
1655 l
= itoa64_to_int (buf
[40]) << 0;
1656 l
|= itoa64_to_int (buf
[41]) << 6;
1657 l
|= itoa64_to_int (buf
[42]) << 12;
1658 l
|= itoa64_to_int (buf
[43]) << 18;
1660 digest
[32] = (l
>> 0) & 0xff;
1661 digest
[31] = (l
>> 8) & 0xff;
1662 digest
[30] = (l
>> 16) & 0xff;
1664 l
= itoa64_to_int (buf
[44]) << 0;
1665 l
|= itoa64_to_int (buf
[45]) << 6;
1666 l
|= itoa64_to_int (buf
[46]) << 12;
1667 l
|= itoa64_to_int (buf
[47]) << 18;
1669 digest
[35] = (l
>> 0) & 0xff;
1670 digest
[34] = (l
>> 8) & 0xff;
1671 digest
[33] = (l
>> 16) & 0xff;
1673 l
= itoa64_to_int (buf
[48]) << 0;
1674 l
|= itoa64_to_int (buf
[49]) << 6;
1675 l
|= itoa64_to_int (buf
[50]) << 12;
1676 l
|= itoa64_to_int (buf
[51]) << 18;
1678 digest
[38] = (l
>> 0) & 0xff;
1679 digest
[37] = (l
>> 8) & 0xff;
1680 digest
[36] = (l
>> 16) & 0xff;
1682 l
= itoa64_to_int (buf
[52]) << 0;
1683 l
|= itoa64_to_int (buf
[53]) << 6;
1684 l
|= itoa64_to_int (buf
[54]) << 12;
1685 l
|= itoa64_to_int (buf
[55]) << 18;
1687 digest
[41] = (l
>> 0) & 0xff;
1688 digest
[40] = (l
>> 8) & 0xff;
1689 digest
[39] = (l
>> 16) & 0xff;
1691 l
= itoa64_to_int (buf
[56]) << 0;
1692 l
|= itoa64_to_int (buf
[57]) << 6;
1693 l
|= itoa64_to_int (buf
[58]) << 12;
1694 l
|= itoa64_to_int (buf
[59]) << 18;
1696 digest
[44] = (l
>> 0) & 0xff;
1697 digest
[43] = (l
>> 8) & 0xff;
1698 digest
[42] = (l
>> 16) & 0xff;
1700 l
= itoa64_to_int (buf
[60]) << 0;
1701 l
|= itoa64_to_int (buf
[61]) << 6;
1702 l
|= itoa64_to_int (buf
[62]) << 12;
1703 l
|= itoa64_to_int (buf
[63]) << 18;
1705 digest
[47] = (l
>> 0) & 0xff;
1706 digest
[46] = (l
>> 8) & 0xff;
1707 digest
[45] = (l
>> 16) & 0xff;
1709 l
= itoa64_to_int (buf
[64]) << 0;
1710 l
|= itoa64_to_int (buf
[65]) << 6;
1711 l
|= itoa64_to_int (buf
[66]) << 12;
1712 l
|= itoa64_to_int (buf
[67]) << 18;
1714 digest
[50] = (l
>> 0) & 0xff;
1715 digest
[49] = (l
>> 8) & 0xff;
1716 digest
[48] = (l
>> 16) & 0xff;
1718 l
= itoa64_to_int (buf
[68]) << 0;
1719 l
|= itoa64_to_int (buf
[69]) << 6;
1720 l
|= itoa64_to_int (buf
[70]) << 12;
1721 l
|= itoa64_to_int (buf
[71]) << 18;
1723 digest
[53] = (l
>> 0) & 0xff;
1724 digest
[52] = (l
>> 8) & 0xff;
1725 digest
[51] = (l
>> 16) & 0xff;
1727 l
= itoa64_to_int (buf
[72]) << 0;
1728 l
|= itoa64_to_int (buf
[73]) << 6;
1729 l
|= itoa64_to_int (buf
[74]) << 12;
1730 l
|= itoa64_to_int (buf
[75]) << 18;
1732 digest
[56] = (l
>> 0) & 0xff;
1733 digest
[55] = (l
>> 8) & 0xff;
1734 digest
[54] = (l
>> 16) & 0xff;
1736 l
= itoa64_to_int (buf
[76]) << 0;
1737 l
|= itoa64_to_int (buf
[77]) << 6;
1738 l
|= itoa64_to_int (buf
[78]) << 12;
1739 l
|= itoa64_to_int (buf
[79]) << 18;
1741 digest
[59] = (l
>> 0) & 0xff;
1742 digest
[58] = (l
>> 8) & 0xff;
1743 digest
[57] = (l
>> 16) & 0xff;
1745 l
= itoa64_to_int (buf
[80]) << 0;
1746 l
|= itoa64_to_int (buf
[81]) << 6;
1747 l
|= itoa64_to_int (buf
[82]) << 12;
1748 l
|= itoa64_to_int (buf
[83]) << 18;
1750 digest
[62] = (l
>> 0) & 0xff;
1751 digest
[61] = (l
>> 8) & 0xff;
1752 digest
[60] = (l
>> 16) & 0xff;
1754 l
= itoa64_to_int (buf
[84]) << 0;
1755 l
|= itoa64_to_int (buf
[85]) << 6;
1757 digest
[63] = (l
>> 16) & 0xff;
1760 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1764 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1766 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1769 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1771 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1773 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1776 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1778 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1780 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[11] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1787 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[15] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1794 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[19] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1801 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[23] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1808 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[27] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1815 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[31] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1822 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[35] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1829 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[39] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1836 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[43] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1843 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[47] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1850 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[51] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1857 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[55] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1864 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[59] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1871 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[63] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1878 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[67] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1885 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[71] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1892 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[75] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1899 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[79] = int_to_itoa64 (l
& 0x3f);
1904 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1906 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[83] = int_to_itoa64 (l
& 0x3f);
1911 l
= 0 | 0 | (digest
[63] << 16);
1913 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1917 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1921 l
= itoa64_to_int (buf
[ 0]) << 0;
1922 l
|= itoa64_to_int (buf
[ 1]) << 6;
1923 l
|= itoa64_to_int (buf
[ 2]) << 12;
1924 l
|= itoa64_to_int (buf
[ 3]) << 18;
1926 digest
[ 0] = (l
>> 16) & 0xff;
1927 digest
[10] = (l
>> 8) & 0xff;
1928 digest
[20] = (l
>> 0) & 0xff;
1930 l
= itoa64_to_int (buf
[ 4]) << 0;
1931 l
|= itoa64_to_int (buf
[ 5]) << 6;
1932 l
|= itoa64_to_int (buf
[ 6]) << 12;
1933 l
|= itoa64_to_int (buf
[ 7]) << 18;
1935 digest
[21] = (l
>> 16) & 0xff;
1936 digest
[ 1] = (l
>> 8) & 0xff;
1937 digest
[11] = (l
>> 0) & 0xff;
1939 l
= itoa64_to_int (buf
[ 8]) << 0;
1940 l
|= itoa64_to_int (buf
[ 9]) << 6;
1941 l
|= itoa64_to_int (buf
[10]) << 12;
1942 l
|= itoa64_to_int (buf
[11]) << 18;
1944 digest
[12] = (l
>> 16) & 0xff;
1945 digest
[22] = (l
>> 8) & 0xff;
1946 digest
[ 2] = (l
>> 0) & 0xff;
1948 l
= itoa64_to_int (buf
[12]) << 0;
1949 l
|= itoa64_to_int (buf
[13]) << 6;
1950 l
|= itoa64_to_int (buf
[14]) << 12;
1951 l
|= itoa64_to_int (buf
[15]) << 18;
1953 digest
[ 3] = (l
>> 16) & 0xff;
1954 digest
[13] = (l
>> 8) & 0xff;
1955 digest
[23] = (l
>> 0) & 0xff;
1957 l
= itoa64_to_int (buf
[16]) << 0;
1958 l
|= itoa64_to_int (buf
[17]) << 6;
1959 l
|= itoa64_to_int (buf
[18]) << 12;
1960 l
|= itoa64_to_int (buf
[19]) << 18;
1962 digest
[24] = (l
>> 16) & 0xff;
1963 digest
[ 4] = (l
>> 8) & 0xff;
1964 digest
[14] = (l
>> 0) & 0xff;
1966 l
= itoa64_to_int (buf
[20]) << 0;
1967 l
|= itoa64_to_int (buf
[21]) << 6;
1968 l
|= itoa64_to_int (buf
[22]) << 12;
1969 l
|= itoa64_to_int (buf
[23]) << 18;
1971 digest
[15] = (l
>> 16) & 0xff;
1972 digest
[25] = (l
>> 8) & 0xff;
1973 digest
[ 5] = (l
>> 0) & 0xff;
1975 l
= itoa64_to_int (buf
[24]) << 0;
1976 l
|= itoa64_to_int (buf
[25]) << 6;
1977 l
|= itoa64_to_int (buf
[26]) << 12;
1978 l
|= itoa64_to_int (buf
[27]) << 18;
1980 digest
[ 6] = (l
>> 16) & 0xff;
1981 digest
[16] = (l
>> 8) & 0xff;
1982 digest
[26] = (l
>> 0) & 0xff;
1984 l
= itoa64_to_int (buf
[28]) << 0;
1985 l
|= itoa64_to_int (buf
[29]) << 6;
1986 l
|= itoa64_to_int (buf
[30]) << 12;
1987 l
|= itoa64_to_int (buf
[31]) << 18;
1989 digest
[27] = (l
>> 16) & 0xff;
1990 digest
[ 7] = (l
>> 8) & 0xff;
1991 digest
[17] = (l
>> 0) & 0xff;
1993 l
= itoa64_to_int (buf
[32]) << 0;
1994 l
|= itoa64_to_int (buf
[33]) << 6;
1995 l
|= itoa64_to_int (buf
[34]) << 12;
1996 l
|= itoa64_to_int (buf
[35]) << 18;
1998 digest
[18] = (l
>> 16) & 0xff;
1999 digest
[28] = (l
>> 8) & 0xff;
2000 digest
[ 8] = (l
>> 0) & 0xff;
2002 l
= itoa64_to_int (buf
[36]) << 0;
2003 l
|= itoa64_to_int (buf
[37]) << 6;
2004 l
|= itoa64_to_int (buf
[38]) << 12;
2005 l
|= itoa64_to_int (buf
[39]) << 18;
2007 digest
[ 9] = (l
>> 16) & 0xff;
2008 digest
[19] = (l
>> 8) & 0xff;
2009 digest
[29] = (l
>> 0) & 0xff;
2011 l
= itoa64_to_int (buf
[40]) << 0;
2012 l
|= itoa64_to_int (buf
[41]) << 6;
2013 l
|= itoa64_to_int (buf
[42]) << 12;
2015 digest
[31] = (l
>> 8) & 0xff;
2016 digest
[30] = (l
>> 0) & 0xff;
2019 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2023 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2025 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2028 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2032 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2035 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2039 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2046 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2053 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2060 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2067 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2074 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2081 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2088 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2095 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2097 buf
[42] = int_to_itoa64 (l
& 0x3f);
2100 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2104 l
= itoa64_to_int (buf
[ 0]) << 0;
2105 l
|= itoa64_to_int (buf
[ 1]) << 6;
2106 l
|= itoa64_to_int (buf
[ 2]) << 12;
2107 l
|= itoa64_to_int (buf
[ 3]) << 18;
2109 digest
[ 0] = (l
>> 0) & 0xff;
2110 digest
[ 1] = (l
>> 8) & 0xff;
2111 digest
[ 2] = (l
>> 16) & 0xff;
2113 l
= itoa64_to_int (buf
[ 4]) << 0;
2114 l
|= itoa64_to_int (buf
[ 5]) << 6;
2115 l
|= itoa64_to_int (buf
[ 6]) << 12;
2116 l
|= itoa64_to_int (buf
[ 7]) << 18;
2118 digest
[ 3] = (l
>> 0) & 0xff;
2119 digest
[ 4] = (l
>> 8) & 0xff;
2120 digest
[ 5] = (l
>> 16) & 0xff;
2122 l
= itoa64_to_int (buf
[ 8]) << 0;
2123 l
|= itoa64_to_int (buf
[ 9]) << 6;
2124 l
|= itoa64_to_int (buf
[10]) << 12;
2125 l
|= itoa64_to_int (buf
[11]) << 18;
2127 digest
[ 6] = (l
>> 0) & 0xff;
2128 digest
[ 7] = (l
>> 8) & 0xff;
2129 digest
[ 8] = (l
>> 16) & 0xff;
2131 l
= itoa64_to_int (buf
[12]) << 0;
2132 l
|= itoa64_to_int (buf
[13]) << 6;
2133 l
|= itoa64_to_int (buf
[14]) << 12;
2134 l
|= itoa64_to_int (buf
[15]) << 18;
2136 digest
[ 9] = (l
>> 0) & 0xff;
2137 digest
[10] = (l
>> 8) & 0xff;
2138 digest
[11] = (l
>> 16) & 0xff;
2140 l
= itoa64_to_int (buf
[16]) << 0;
2141 l
|= itoa64_to_int (buf
[17]) << 6;
2142 l
|= itoa64_to_int (buf
[18]) << 12;
2143 l
|= itoa64_to_int (buf
[19]) << 18;
2145 digest
[12] = (l
>> 0) & 0xff;
2146 digest
[13] = (l
>> 8) & 0xff;
2147 digest
[14] = (l
>> 16) & 0xff;
2149 l
= itoa64_to_int (buf
[20]) << 0;
2150 l
|= itoa64_to_int (buf
[21]) << 6;
2151 l
|= itoa64_to_int (buf
[22]) << 12;
2152 l
|= itoa64_to_int (buf
[23]) << 18;
2154 digest
[15] = (l
>> 0) & 0xff;
2155 digest
[16] = (l
>> 8) & 0xff;
2156 digest
[17] = (l
>> 16) & 0xff;
2158 l
= itoa64_to_int (buf
[24]) << 0;
2159 l
|= itoa64_to_int (buf
[25]) << 6;
2160 l
|= itoa64_to_int (buf
[26]) << 12;
2161 l
|= itoa64_to_int (buf
[27]) << 18;
2163 digest
[18] = (l
>> 0) & 0xff;
2164 digest
[19] = (l
>> 8) & 0xff;
2165 digest
[20] = (l
>> 16) & 0xff;
2167 l
= itoa64_to_int (buf
[28]) << 0;
2168 l
|= itoa64_to_int (buf
[29]) << 6;
2169 l
|= itoa64_to_int (buf
[30]) << 12;
2170 l
|= itoa64_to_int (buf
[31]) << 18;
2172 digest
[21] = (l
>> 0) & 0xff;
2173 digest
[22] = (l
>> 8) & 0xff;
2174 digest
[23] = (l
>> 16) & 0xff;
2176 l
= itoa64_to_int (buf
[32]) << 0;
2177 l
|= itoa64_to_int (buf
[33]) << 6;
2178 l
|= itoa64_to_int (buf
[34]) << 12;
2179 l
|= itoa64_to_int (buf
[35]) << 18;
2181 digest
[24] = (l
>> 0) & 0xff;
2182 digest
[25] = (l
>> 8) & 0xff;
2183 digest
[26] = (l
>> 16) & 0xff;
2185 l
= itoa64_to_int (buf
[36]) << 0;
2186 l
|= itoa64_to_int (buf
[37]) << 6;
2187 l
|= itoa64_to_int (buf
[38]) << 12;
2188 l
|= itoa64_to_int (buf
[39]) << 18;
2190 digest
[27] = (l
>> 0) & 0xff;
2191 digest
[28] = (l
>> 8) & 0xff;
2192 digest
[29] = (l
>> 16) & 0xff;
2194 l
= itoa64_to_int (buf
[40]) << 0;
2195 l
|= itoa64_to_int (buf
[41]) << 6;
2196 l
|= itoa64_to_int (buf
[42]) << 12;
2197 l
|= itoa64_to_int (buf
[43]) << 18;
2199 digest
[30] = (l
>> 0) & 0xff;
2200 digest
[31] = (l
>> 8) & 0xff;
2201 digest
[32] = (l
>> 16) & 0xff;
2236 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2240 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2242 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2245 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2247 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2249 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2252 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2254 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2256 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[11] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2263 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[15] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2270 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[19] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2277 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[23] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2284 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[27] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2291 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[31] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2298 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[35] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2305 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[39] = int_to_itoa64 (l
& 0x3f);
2310 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2312 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2315 //buf[43] = int_to_itoa64 (l & 0x3f);
2323 static struct termio savemodes
;
2324 static int havemodes
= 0;
2328 struct termio modmodes
;
2330 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2334 modmodes
= savemodes
;
2335 modmodes
.c_lflag
&= ~ICANON
;
2336 modmodes
.c_cc
[VMIN
] = 1;
2337 modmodes
.c_cc
[VTIME
] = 0;
2339 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2348 FD_SET (fileno (stdin
), &rfds
);
2355 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2357 if (retval
== 0) return 0;
2358 if (retval
== -1) return -1;
2365 if (!havemodes
) return 0;
2367 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2372 static struct termios savemodes
;
2373 static int havemodes
= 0;
2377 struct termios modmodes
;
2379 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2383 modmodes
= savemodes
;
2384 modmodes
.c_lflag
&= ~ICANON
;
2385 modmodes
.c_cc
[VMIN
] = 1;
2386 modmodes
.c_cc
[VTIME
] = 0;
2388 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2397 FD_SET (fileno (stdin
), &rfds
);
2404 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2406 if (retval
== 0) return 0;
2407 if (retval
== -1) return -1;
2414 if (!havemodes
) return 0;
2416 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2421 static DWORD saveMode
= 0;
2425 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2427 GetConsoleMode (stdinHandle
, &saveMode
);
2428 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2435 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2437 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2439 if (rc
== WAIT_TIMEOUT
) return 0;
2440 if (rc
== WAIT_ABANDONED
) return -1;
2441 if (rc
== WAIT_FAILED
) return -1;
2443 // The whole ReadConsoleInput () part is a workaround.
2444 // For some unknown reason, maybe a mingw bug, a random signal
2445 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2446 // Then it wants to read with getche () a keyboard input
2447 // which has never been made.
2449 INPUT_RECORD buf
[100];
2453 memset (buf
, 0, sizeof (buf
));
2455 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2457 FlushConsoleInputBuffer (stdinHandle
);
2459 for (uint i
= 0; i
< num
; i
++)
2461 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2463 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2465 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2467 return KeyEvent
.uChar
.AsciiChar
;
2475 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2477 SetConsoleMode (stdinHandle
, saveMode
);
2487 #define MSG_ENOMEM "Insufficient memory available"
2489 void *mycalloc (size_t nmemb
, size_t size
)
2491 void *p
= calloc (nmemb
, size
);
2495 log_error ("ERROR: %s", MSG_ENOMEM
);
2503 void *mymalloc (size_t size
)
2505 void *p
= malloc (size
);
2509 log_error ("ERROR: %s", MSG_ENOMEM
);
2514 memset (p
, 0, size
);
2519 void myfree (void *ptr
)
2521 if (ptr
== NULL
) return;
2526 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2528 void *p
= realloc (ptr
, oldsz
+ add
);
2532 log_error ("ERROR: %s", MSG_ENOMEM
);
2537 memset ((char *) p
+ oldsz
, 0, add
);
2542 char *mystrdup (const char *s
)
2544 const size_t len
= strlen (s
);
2546 char *b
= (char *) mymalloc (len
+ 1);
2553 FILE *logfile_open (char *logfile
)
2555 FILE *fp
= fopen (logfile
, "ab");
2565 void logfile_close (FILE *fp
)
2567 if (fp
== stdout
) return;
2572 void logfile_append (const char *fmt
, ...)
2574 if (data
.logfile_disable
== 1) return;
2576 FILE *fp
= logfile_open (data
.logfile
);
2582 vfprintf (fp
, fmt
, ap
);
2593 int logfile_generate_id ()
2595 const int n
= rand ();
2604 char *logfile_generate_topid ()
2606 const int id
= logfile_generate_id ();
2608 char *topid
= (char *) mymalloc (1 + 16 + 1);
2610 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2615 char *logfile_generate_subid ()
2617 const int id
= logfile_generate_id ();
2619 char *subid
= (char *) mymalloc (1 + 16 + 1);
2621 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2631 void lock_file (FILE *fp
)
2635 memset (&lock
, 0, sizeof (struct flock
));
2637 lock
.l_type
= F_WRLCK
;
2638 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2642 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2649 void unlock_file (FILE *fp
)
2653 memset (&lock
, 0, sizeof (struct flock
));
2655 lock
.l_type
= F_UNLCK
;
2656 fcntl(fileno(fp
), F_SETLK
, &lock
);
2663 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2665 FlushFileBuffers (h
);
2674 #if defined(_WIN) && defined(HAVE_NVAPI)
2675 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2679 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2683 log_info ("WARN: No NvAPI adapters found");
2690 #endif // _WIN && HAVE_NVAPI
2692 #if defined(LINUX) && defined(HAVE_NVML)
2693 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2697 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2699 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2701 // can be used to determine if the device by index matches the cuda device by index
2702 // char name[100]; memset (name, 0, sizeof (name));
2703 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2710 log_info ("WARN: No NVML adapters found");
2717 #endif // LINUX && HAVE_NVML
2720 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2722 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2724 if (iNumberAdapters
== 0)
2726 log_info ("WARN: No ADL adapters found.");
2735 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2737 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2738 ADLODParameters lpOdParameters;
2740 lpOdParameters.iSize = sizeof (ADLODParameters);
2741 size_t plevels_size = 0;
2743 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2745 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2746 __func__, iAdapterIndex,
2747 lpOdParameters.iNumberOfPerformanceLevels,
2748 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2749 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2751 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2753 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2755 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2757 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2759 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2760 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2761 __func__, iAdapterIndex, j,
2762 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2764 myfree (lpOdPerformanceLevels);
2770 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2772 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2774 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2776 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2778 return lpAdapterInfo
;
2783 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2786 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2790 for (uint i = 0; i < num_adl_adapters; i++)
2792 int opencl_bus_num = hm_device[i].busid;
2793 int opencl_dev_num = hm_device[i].devid;
2795 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2803 if (idx >= DEVICES_MAX) return -1;
2808 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2810 for (uint i = 0; i < opencl_num_devices; i++)
2812 cl_device_topology_amd device_topology;
2814 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2816 hm_device[i].busid = device_topology.pcie.bus;
2817 hm_device[i].devid = device_topology.pcie.device;
2822 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2824 // basically bubble sort
2826 for (int i
= 0; i
< num_adl_adapters
; i
++)
2828 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2830 // get info of adapter [x]
2832 u32 adapter_index_x
= valid_adl_device_list
[j
];
2833 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2835 u32 bus_num_x
= info_x
.iBusNumber
;
2836 u32 dev_num_x
= info_x
.iDeviceNumber
;
2838 // get info of adapter [y]
2840 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2841 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2843 u32 bus_num_y
= info_y
.iBusNumber
;
2844 u32 dev_num_y
= info_y
.iDeviceNumber
;
2848 if (bus_num_y
< bus_num_x
)
2852 else if (bus_num_y
== bus_num_x
)
2854 if (dev_num_y
< dev_num_x
)
2862 u32 temp
= valid_adl_device_list
[j
+ 1];
2864 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2865 valid_adl_device_list
[j
+ 0] = temp
;
2871 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2873 *num_adl_adapters
= 0;
2875 u32
*adl_adapters
= NULL
;
2877 int *bus_numbers
= NULL
;
2878 int *device_numbers
= NULL
;
2880 for (int i
= 0; i
< iNumberAdapters
; i
++)
2882 AdapterInfo info
= lpAdapterInfo
[i
];
2884 if (strlen (info
.strUDID
) < 1) continue;
2887 if (info
.iVendorID
!= 1002) continue;
2889 if (info
.iVendorID
!= 0x1002) continue;
2892 if (info
.iBusNumber
< 0) continue;
2893 if (info
.iDeviceNumber
< 0) continue;
2897 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2899 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2906 if (found
) continue;
2908 // add it to the list
2910 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2912 adl_adapters
[*num_adl_adapters
] = i
;
2914 // rest is just bookkeeping
2916 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2917 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2919 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2920 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2922 (*num_adl_adapters
)++;
2925 myfree (bus_numbers
);
2926 myfree (device_numbers
);
2928 // sort the list by increasing bus id, device id number
2930 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2932 return adl_adapters
;
2935 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2937 // loop through all valid devices
2939 for (int i
= 0; i
< num_adl_adapters
; i
++)
2941 u32 adapter_index
= valid_adl_device_list
[i
];
2945 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2947 // unfortunately this doesn't work since bus id and dev id are not unique
2948 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2949 // if (opencl_device_index == -1) continue;
2951 int opencl_device_index
= i
;
2953 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2955 // get fanspeed info
2957 if (hm_device
[opencl_device_index
].od_version
== 5)
2959 ADLFanSpeedInfo FanSpeedInfo
;
2961 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2963 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2965 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2967 // check read and write capability in fanspeedinfo
2969 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2970 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2972 hm_device
[opencl_device_index
].fan_supported
= 1;
2976 hm_device
[opencl_device_index
].fan_supported
= 0;
2979 else // od_version == 6
2981 ADLOD6FanSpeedInfo faninfo
;
2983 memset (&faninfo
, 0, sizeof (faninfo
));
2985 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2987 // check read capability in fanspeedinfo
2989 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2991 hm_device
[opencl_device_index
].fan_supported
= 1;
2995 hm_device
[opencl_device_index
].fan_supported
= 0;
3003 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3005 for (int i
= 0; i
< num_adl_adapters
; i
++)
3007 u32 adapter_index
= valid_adl_device_list
[i
];
3011 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3013 // get overdrive version
3015 int od_supported
= 0;
3019 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3021 // store the overdrive version in hm_device
3023 // unfortunately this doesn't work since bus id and dev id are not unique
3024 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3025 // if (opencl_device_index == -1) continue;
3027 int opencl_device_index
= i
;
3029 hm_device
[opencl_device_index
].od_version
= od_version
;
3035 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3037 for (int i
= 0; i
< num_adl_adapters
; i
++)
3039 u32 adapter_index
= valid_adl_device_list
[i
];
3043 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3045 // store the iAdapterIndex in hm_device
3047 // unfortunately this doesn't work since bus id and dev id are not unique
3048 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3049 // if (opencl_device_index == -1) continue;
3051 int opencl_device_index
= i
;
3053 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3056 return num_adl_adapters
;
3060 int hm_get_temperature_with_device_id (const uint device_id
)
3062 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3065 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3069 if (data
.hm_device
[device_id
].od_version
== 5)
3071 ADLTemperature Temperature
;
3073 Temperature
.iSize
= sizeof (ADLTemperature
);
3075 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3077 return Temperature
.iTemperature
/ 1000;
3079 else if (data
.hm_device
[device_id
].od_version
== 6)
3081 int Temperature
= 0;
3083 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3085 return Temperature
/ 1000;
3091 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3092 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3094 #if defined(LINUX) && defined(HAVE_NVML)
3095 int temperature
= 0;
3097 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3102 #if defined(WIN) && defined(HAVE_NVAPI)
3103 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3105 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3106 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3107 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3108 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3110 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3112 return pThermalSettings
.sensor
[0].currentTemp
;
3113 #endif // WIN && HAVE_NVAPI
3115 #endif // HAVE_NVML || HAVE_NVAPI
3120 int hm_get_fanspeed_with_device_id (const uint device_id
)
3122 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3123 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3125 if (data
.hm_device
[device_id
].fan_supported
== 1)
3128 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3132 if (data
.hm_device
[device_id
].od_version
== 5)
3134 ADLFanSpeedValue lpFanSpeedValue
;
3136 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3138 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3139 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3140 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3142 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3144 return lpFanSpeedValue
.iFanSpeed
;
3146 else // od_version == 6
3148 ADLOD6FanSpeedInfo faninfo
;
3150 memset (&faninfo
, 0, sizeof (faninfo
));
3152 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3154 return faninfo
.iFanSpeedPercent
;
3160 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3161 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3163 #if defined(LINUX) && defined(HAVE_NVML)
3166 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3171 #if defined(WIN) && defined(HAVE_NVAPI)
3173 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3175 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3177 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3179 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3182 #endif // HAVE_NVML || HAVE_NVAPI
3188 int hm_get_utilization_with_device_id (const uint device_id
)
3190 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3193 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3197 ADLPMActivity PMActivity
;
3199 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3201 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3203 return PMActivity
.iActivityPercent
;
3208 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3209 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3211 #if defined(LINUX) && defined(HAVE_NVML)
3212 nvmlUtilization_t utilization
;
3214 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3216 return utilization
.gpu
;
3219 #if defined(WIN) && defined(HAVE_NVAPI)
3220 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3222 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3224 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3226 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3229 #endif // HAVE_NVML || HAVE_NVAPI
3235 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3237 if (data
.hm_device
[device_id
].fan_supported
== 1)
3241 if (data
.hm_device
[device_id
].od_version
== 5)
3243 ADLFanSpeedValue lpFanSpeedValue
;
3245 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3247 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3248 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3249 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3250 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3252 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3256 else // od_version == 6
3258 ADLOD6FanSpeedValue fan_speed_value
;
3260 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3262 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3263 fan_speed_value
.iFanSpeed
= fanspeed
;
3265 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3276 // helper function for status display
3278 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3280 #define VALUE_NOT_AVAILABLE "N/A"
3284 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3288 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3291 #endif // HAVE_HWMON
3297 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3299 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3301 if (css_cnt
> SP_PW_MAX
)
3303 log_error ("ERROR: mask length is too long");
3308 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3310 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3312 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3313 uint cs_len
= css
[css_pos
].cs_len
;
3315 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3317 uint c
= cs_buf
[cs_pos
] & 0xff;
3324 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3326 cs_t
*cs
= &css
[css_cnt
];
3328 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3330 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3334 for (i
= 0; i
< cs
->cs_len
; i
++)
3336 const uint u
= cs
->cs_buf
[i
];
3341 for (i
= 0; i
< in_len
; i
++)
3343 uint u
= in_buf
[i
] & 0xff;
3345 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3347 if (css_uniq
[u
] == 1) continue;
3351 cs
->cs_buf
[cs
->cs_len
] = u
;
3359 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3363 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3365 uint p0
= in_buf
[in_pos
] & 0xff;
3367 if (interpret
== 1 && p0
== '?')
3371 if (in_pos
== in_len
) break;
3373 uint p1
= in_buf
[in_pos
] & 0xff;
3377 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3379 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3381 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3383 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3385 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3387 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3389 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3390 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3392 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3393 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3395 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3396 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3398 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3399 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3401 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3403 default: log_error ("Syntax error: %s", in_buf
);
3409 if (data
.hex_charset
)
3413 if (in_pos
== in_len
)
3415 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3420 uint p1
= in_buf
[in_pos
] & 0xff;
3422 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3424 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3431 chr
= hex_convert (p1
) << 0;
3432 chr
|= hex_convert (p0
) << 4;
3434 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3440 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3446 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3450 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3452 sum
*= css
[css_pos
].cs_len
;
3458 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3460 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3465 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3467 char p0
= mask_buf
[mask_pos
];
3473 if (mask_pos
== mask_len
) break;
3475 char p1
= mask_buf
[mask_pos
];
3481 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3483 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3485 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3487 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3489 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3491 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3493 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3494 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3496 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3497 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3499 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3500 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3502 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3503 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3505 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3507 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3513 if (data
.hex_charset
)
3517 // if there is no 2nd hex character, show an error:
3519 if (mask_pos
== mask_len
)
3521 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3526 char p1
= mask_buf
[mask_pos
];
3528 // if they are not valid hex character, show an error:
3530 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3532 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3539 chr
|= hex_convert (p1
) << 0;
3540 chr
|= hex_convert (p0
) << 4;
3542 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3548 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3555 log_error ("ERROR: invalid mask length (0)");
3565 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3567 for (int i
= 0; i
< css_cnt
; i
++)
3569 uint len
= css
[i
].cs_len
;
3570 u64 next
= val
/ len
;
3571 uint pos
= val
% len
;
3572 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3577 void mp_cut_at (char *mask
, uint max
)
3581 uint mask_len
= strlen (mask
);
3583 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3585 if (mask
[i
] == '?') i
++;
3591 void mp_setup_sys (cs_t
*mp_sys
)
3595 uint donec
[CHARSIZ
] = { 0 };
3597 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3598 mp_sys
[0].cs_buf
[pos
++] = chr
;
3599 mp_sys
[0].cs_len
= pos
; }
3601 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3602 mp_sys
[1].cs_buf
[pos
++] = chr
;
3603 mp_sys
[1].cs_len
= pos
; }
3605 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3606 mp_sys
[2].cs_buf
[pos
++] = chr
;
3607 mp_sys
[2].cs_len
= pos
; }
3609 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3610 mp_sys
[3].cs_buf
[pos
++] = chr
;
3611 mp_sys
[3].cs_len
= pos
; }
3613 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3614 mp_sys
[4].cs_len
= pos
; }
3616 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3617 mp_sys
[5].cs_len
= pos
; }
3620 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3622 FILE *fp
= fopen (buf
, "rb");
3624 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3626 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3630 char mp_file
[1024] = { 0 };
3632 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3636 len
= in_superchop (mp_file
);
3640 log_info ("WARNING: charset file corrupted");
3642 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3646 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3651 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3653 mp_usr
[index
].cs_len
= 0;
3655 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3658 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3660 char *new_mask_buf
= (char *) mymalloc (256);
3666 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3668 if (css_pos
== len
) break;
3670 char p0
= mask_buf
[mask_pos
];
3672 new_mask_buf
[mask_pos
] = p0
;
3678 if (mask_pos
== mask_len
) break;
3680 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3684 if (data
.hex_charset
)
3688 if (mask_pos
== mask_len
)
3690 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3695 char p1
= mask_buf
[mask_pos
];
3697 // if they are not valid hex character, show an error:
3699 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3701 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3706 new_mask_buf
[mask_pos
] = p1
;
3711 if (css_pos
== len
) return (new_mask_buf
);
3713 myfree (new_mask_buf
);
3722 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3728 for (i
= start
; i
< stop
; i
++)
3730 sum
*= root_css_buf
[i
].cs_len
;
3736 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3740 cs_t
*cs
= &root_css_buf
[start
];
3744 for (i
= start
; i
< stop
; i
++)
3746 const u64 m
= v
% cs
->cs_len
;
3747 const u64 d
= v
/ cs
->cs_len
;
3751 const uint k
= cs
->cs_buf
[m
];
3753 pw_buf
[i
- start
] = (char) k
;
3755 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3759 int sp_comp_val (const void *p1
, const void *p2
)
3761 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3762 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3764 return b2
->val
- b1
->val
;
3767 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
)
3774 * Initialize hcstats
3777 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3779 u64
*root_stats_ptr
= root_stats_buf
;
3781 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3783 for (i
= 0; i
< SP_PW_MAX
; i
++)
3785 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3787 root_stats_ptr
+= CHARSIZ
;
3790 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3792 u64
*markov_stats_ptr
= markov_stats_buf
;
3794 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3796 for (i
= 0; i
< SP_PW_MAX
; i
++)
3798 for (j
= 0; j
< CHARSIZ
; j
++)
3800 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3802 markov_stats_ptr
+= CHARSIZ
;
3812 char hcstat_tmp
[256] = { 0 };
3814 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3816 hcstat
= hcstat_tmp
;
3819 FILE *fd
= fopen (hcstat
, "rb");
3823 log_error ("%s: %s", hcstat
, strerror (errno
));
3828 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3830 log_error ("%s: Could not load data", hcstat
);
3837 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3839 log_error ("%s: Could not load data", hcstat
);
3849 * Markov modifier of hcstat_table on user request
3854 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3855 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3860 /* Add all stats to first position */
3862 for (i
= 1; i
< SP_PW_MAX
; i
++)
3864 u64
*out
= root_stats_buf_by_pos
[0];
3865 u64
*in
= root_stats_buf_by_pos
[i
];
3867 for (j
= 0; j
< CHARSIZ
; j
++)
3873 for (i
= 1; i
< SP_PW_MAX
; i
++)
3875 u64
*out
= markov_stats_buf_by_key
[0][0];
3876 u64
*in
= markov_stats_buf_by_key
[i
][0];
3878 for (j
= 0; j
< CHARSIZ
; j
++)
3880 for (k
= 0; k
< CHARSIZ
; k
++)
3887 /* copy them to all pw_positions */
3889 for (i
= 1; i
< SP_PW_MAX
; i
++)
3891 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3894 for (i
= 1; i
< SP_PW_MAX
; i
++)
3896 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3904 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3906 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3908 for (i
= 0; i
< SP_PW_MAX
; i
++)
3910 root_table_buf_by_pos
[i
] = root_table_ptr
;
3912 root_table_ptr
+= CHARSIZ
;
3915 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3917 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3919 for (i
= 0; i
< SP_PW_MAX
; i
++)
3921 for (j
= 0; j
< CHARSIZ
; j
++)
3923 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3925 markov_table_ptr
+= CHARSIZ
;
3930 * Convert hcstat to tables
3933 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3935 uint key
= i
% CHARSIZ
;
3937 root_table_buf
[i
].key
= key
;
3938 root_table_buf
[i
].val
= root_stats_buf
[i
];
3941 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3943 uint key
= i
% CHARSIZ
;
3945 markov_table_buf
[i
].key
= key
;
3946 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3949 myfree (root_stats_buf
);
3950 myfree (markov_stats_buf
);
3956 for (i
= 0; i
< SP_PW_MAX
; i
++)
3958 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3961 for (i
= 0; i
< SP_PW_MAX
; i
++)
3963 for (j
= 0; j
< CHARSIZ
; j
++)
3965 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3970 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
])
3973 * Convert tables to css
3976 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3978 uint pw_pos
= i
/ CHARSIZ
;
3980 cs_t
*cs
= &root_css_buf
[pw_pos
];
3982 if (cs
->cs_len
== threshold
) continue;
3984 uint key
= root_table_buf
[i
].key
;
3986 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3988 cs
->cs_buf
[cs
->cs_len
] = key
;
3994 * Convert table to css
3997 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3999 uint c
= i
/ CHARSIZ
;
4001 cs_t
*cs
= &markov_css_buf
[c
];
4003 if (cs
->cs_len
== threshold
) continue;
4005 uint pw_pos
= c
/ CHARSIZ
;
4007 uint key
= markov_table_buf
[i
].key
;
4009 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4011 cs
->cs_buf
[cs
->cs_len
] = key
;
4017 for (uint i = 0; i < 8; i++)
4019 for (uint j = 0x20; j < 0x80; j++)
4021 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4023 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4025 for (uint k = 0; k < 10; k++)
4027 printf (" %u\n", ptr->cs_buf[k]);
4034 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4036 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4038 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4048 for (uint j
= 1; j
< CHARSIZ
; j
++)
4058 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4060 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4062 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4064 out
+= CHARSIZ
* CHARSIZ
;
4065 in
+= CHARSIZ
* CHARSIZ
;
4067 for (uint j
= 0; j
< CHARSIZ
; j
++)
4074 for (uint k
= 1; k
< CHARSIZ
; k
++)
4086 * mixed shared functions
4089 void dump_hex (const u8
*s
, const int sz
)
4091 for (int i
= 0; i
< sz
; i
++)
4093 log_info_nn ("%02x ", s
[i
]);
4099 void usage_mini_print (const char *progname
)
4101 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4104 void usage_big_print (const char *progname
)
4106 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4109 char *get_exec_path ()
4111 int exec_path_len
= 1024;
4113 char *exec_path
= (char *) mymalloc (exec_path_len
);
4117 char tmp
[32] = { 0 };
4119 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4121 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4125 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4129 uint size
= exec_path_len
;
4131 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4133 log_error("! executable path buffer too small\n");
4138 const int len
= strlen (exec_path
);
4141 #error Your Operating System is not supported or detected
4149 char *get_install_dir (const char *progname
)
4151 char *install_dir
= mystrdup (progname
);
4152 char *last_slash
= NULL
;
4154 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4158 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4164 install_dir
[0] = '.';
4168 return (install_dir
);
4171 char *get_profile_dir (const char *homedir
)
4173 #define DOT_HASHCAT ".hashcat"
4175 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4177 char *profile_dir
= (char *) mymalloc (len
+ 1);
4179 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4184 char *get_session_dir (const char *profile_dir
)
4186 #define SESSIONS_FOLDER "sessions"
4188 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4190 char *session_dir
= (char *) mymalloc (len
+ 1);
4192 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4197 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4201 FILE *fd
= fopen (filename
, "rb");
4205 log_error ("%s: %s", filename
, strerror (errno
));
4210 #define MAX_KEY_SIZE (1024 * 1024)
4212 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4214 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4220 for (int fpos
= 0; fpos
< nread
; fpos
++)
4222 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4224 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4225 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4226 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4227 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4229 if (kpos
>= 64) kpos
= 0;
4235 void set_cpu_affinity (char *cpu_affinity
)
4238 DWORD_PTR aff_mask
= 0;
4246 char *devices
= strdup (cpu_affinity
);
4248 char *next
= strtok (devices
, ",");
4252 uint cpu_id
= atoi (next
);
4267 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4273 aff_mask
|= 1 << (cpu_id
- 1);
4275 CPU_SET ((cpu_id
- 1), &cpuset
);
4278 } while ((next
= strtok (NULL
, ",")) != NULL
);
4284 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4285 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4287 pthread_t thread
= pthread_self ();
4288 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4292 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4294 char *element
, *end
;
4296 end
= (char *) base
+ nmemb
* size
;
4298 for (element
= (char *) base
; element
< end
; element
+= size
)
4299 if (!compar (element
, key
))
4305 int sort_by_salt (const void *v1
, const void *v2
)
4307 const salt_t
*s1
= (const salt_t
*) v1
;
4308 const salt_t
*s2
= (const salt_t
*) v2
;
4310 const int res1
= s1
->salt_len
- s2
->salt_len
;
4312 if (res1
!= 0) return (res1
);
4314 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4316 if (res2
!= 0) return (res2
);
4324 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4325 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4332 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4333 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4339 int sort_by_salt_buf (const void *v1
, const void *v2
)
4341 const pot_t
*p1
= (const pot_t
*) v1
;
4342 const pot_t
*p2
= (const pot_t
*) v2
;
4344 const hash_t
*h1
= &p1
->hash
;
4345 const hash_t
*h2
= &p2
->hash
;
4347 const salt_t
*s1
= h1
->salt
;
4348 const salt_t
*s2
= h2
->salt
;
4354 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4355 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4361 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4363 const hash_t
*h1
= (const hash_t
*) v1
;
4364 const hash_t
*h2
= (const hash_t
*) v2
;
4366 const salt_t
*s1
= h1
->salt
;
4367 const salt_t
*s2
= h2
->salt
;
4369 // testphase: this should work
4374 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4375 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4378 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4379 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4380 if (s1->salt_len > s2->salt_len) return ( 1);
4381 if (s1->salt_len < s2->salt_len) return (-1);
4383 uint n = s1->salt_len;
4387 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4388 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4395 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4397 const hash_t
*h1
= (const hash_t
*) v1
;
4398 const hash_t
*h2
= (const hash_t
*) v2
;
4400 const salt_t
*s1
= h1
->salt
;
4401 const salt_t
*s2
= h2
->salt
;
4403 // 12 - 2 (since last 2 uints contain the digest)
4408 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4409 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4415 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4417 const hash_t
*h1
= (const hash_t
*) v1
;
4418 const hash_t
*h2
= (const hash_t
*) v2
;
4420 const void *d1
= h1
->digest
;
4421 const void *d2
= h2
->digest
;
4423 return data
.sort_by_digest (d1
, d2
);
4426 int sort_by_hash (const void *v1
, const void *v2
)
4428 const hash_t
*h1
= (const hash_t
*) v1
;
4429 const hash_t
*h2
= (const hash_t
*) v2
;
4433 const salt_t
*s1
= h1
->salt
;
4434 const salt_t
*s2
= h2
->salt
;
4436 int res
= sort_by_salt (s1
, s2
);
4438 if (res
!= 0) return (res
);
4441 const void *d1
= h1
->digest
;
4442 const void *d2
= h2
->digest
;
4444 return data
.sort_by_digest (d1
, d2
);
4447 int sort_by_pot (const void *v1
, const void *v2
)
4449 const pot_t
*p1
= (const pot_t
*) v1
;
4450 const pot_t
*p2
= (const pot_t
*) v2
;
4452 const hash_t
*h1
= &p1
->hash
;
4453 const hash_t
*h2
= &p2
->hash
;
4455 return sort_by_hash (h1
, h2
);
4458 int sort_by_mtime (const void *p1
, const void *p2
)
4460 const char **f1
= (const char **) p1
;
4461 const char **f2
= (const char **) p2
;
4463 struct stat s1
; stat (*f1
, &s1
);
4464 struct stat s2
; stat (*f2
, &s2
);
4466 return s2
.st_mtime
- s1
.st_mtime
;
4469 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4471 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4472 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4474 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4477 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4479 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4480 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4482 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4485 int sort_by_stringptr (const void *p1
, const void *p2
)
4487 const char **s1
= (const char **) p1
;
4488 const char **s2
= (const char **) p2
;
4490 return strcmp (*s1
, *s2
);
4493 int sort_by_dictstat (const void *s1
, const void *s2
)
4495 dictstat_t
*d1
= (dictstat_t
*) s1
;
4496 dictstat_t
*d2
= (dictstat_t
*) s2
;
4499 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4501 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4504 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4507 int sort_by_bitmap (const void *p1
, const void *p2
)
4509 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4510 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4512 return b1
->collisions
- b2
->collisions
;
4515 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4517 const u32
*d1
= (const u32
*) v1
;
4518 const u32
*d2
= (const u32
*) v2
;
4524 if (d1
[n
] > d2
[n
]) return ( 1);
4525 if (d1
[n
] < d2
[n
]) return (-1);
4531 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4533 const u32
*d1
= (const u32
*) v1
;
4534 const u32
*d2
= (const u32
*) v2
;
4540 if (d1
[n
] > d2
[n
]) return ( 1);
4541 if (d1
[n
] < d2
[n
]) return (-1);
4547 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4549 const u32
*d1
= (const u32
*) v1
;
4550 const u32
*d2
= (const u32
*) v2
;
4556 if (d1
[n
] > d2
[n
]) return ( 1);
4557 if (d1
[n
] < d2
[n
]) return (-1);
4563 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4565 const u32
*d1
= (const u32
*) v1
;
4566 const u32
*d2
= (const u32
*) v2
;
4572 if (d1
[n
] > d2
[n
]) return ( 1);
4573 if (d1
[n
] < d2
[n
]) return (-1);
4579 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4581 const u32
*d1
= (const u32
*) v1
;
4582 const u32
*d2
= (const u32
*) v2
;
4588 if (d1
[n
] > d2
[n
]) return ( 1);
4589 if (d1
[n
] < d2
[n
]) return (-1);
4595 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4597 const u32
*d1
= (const u32
*) v1
;
4598 const u32
*d2
= (const u32
*) v2
;
4604 if (d1
[n
] > d2
[n
]) return ( 1);
4605 if (d1
[n
] < d2
[n
]) return (-1);
4611 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4613 const u32
*d1
= (const u32
*) v1
;
4614 const u32
*d2
= (const u32
*) v2
;
4620 if (d1
[n
] > d2
[n
]) return ( 1);
4621 if (d1
[n
] < d2
[n
]) return (-1);
4627 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4629 const u32
*d1
= (const u32
*) v1
;
4630 const u32
*d2
= (const u32
*) v2
;
4636 if (d1
[n
] > d2
[n
]) return ( 1);
4637 if (d1
[n
] < d2
[n
]) return (-1);
4643 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4645 const u64
*d1
= (const u64
*) v1
;
4646 const u64
*d2
= (const u64
*) v2
;
4652 if (d1
[n
] > d2
[n
]) return ( 1);
4653 if (d1
[n
] < d2
[n
]) return (-1);
4659 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4661 const u64
*d1
= (const u64
*) v1
;
4662 const u64
*d2
= (const u64
*) v2
;
4668 if (d1
[n
] > d2
[n
]) return ( 1);
4669 if (d1
[n
] < d2
[n
]) return (-1);
4675 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4677 const u64
*d1
= (const u64
*) v1
;
4678 const u64
*d2
= (const u64
*) v2
;
4684 if (d1
[n
] > d2
[n
]) return ( 1);
4685 if (d1
[n
] < d2
[n
]) return (-1);
4691 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4693 const u32
*d1
= (const u32
*) v1
;
4694 const u32
*d2
= (const u32
*) v2
;
4696 const uint dgst_pos0
= data
.dgst_pos0
;
4697 const uint dgst_pos1
= data
.dgst_pos1
;
4698 const uint dgst_pos2
= data
.dgst_pos2
;
4699 const uint dgst_pos3
= data
.dgst_pos3
;
4701 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4702 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4703 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4704 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4705 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4706 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4707 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4708 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4713 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
)
4715 uint outfile_autohex
= data
.outfile_autohex
;
4717 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4719 FILE *debug_fp
= NULL
;
4721 if (debug_file
!= NULL
)
4723 debug_fp
= fopen (debug_file
, "ab");
4725 lock_file (debug_fp
);
4732 if (debug_fp
== NULL
)
4734 log_info ("WARNING: Could not open debug-file for writing");
4738 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4740 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4742 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4745 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4747 if (debug_mode
== 4)
4749 fputc (':', debug_fp
);
4751 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4754 fputc ('\n', debug_fp
);
4756 if (debug_file
!= NULL
) fclose (debug_fp
);
4760 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4762 int needs_hexify
= 0;
4764 if (outfile_autohex
== 1)
4766 for (uint i
= 0; i
< plain_len
; i
++)
4768 if (plain_ptr
[i
] < 0x20)
4775 if (plain_ptr
[i
] > 0x7f)
4784 if (needs_hexify
== 1)
4786 fprintf (fp
, "$HEX[");
4788 for (uint i
= 0; i
< plain_len
; i
++)
4790 fprintf (fp
, "%02x", plain_ptr
[i
]);
4797 fwrite (plain_ptr
, plain_len
, 1, fp
);
4801 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
)
4803 uint outfile_format
= data
.outfile_format
;
4805 char separator
= data
.separator
;
4807 if (outfile_format
& OUTFILE_FMT_HASH
)
4809 fprintf (out_fp
, "%s", out_buf
);
4811 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4813 fputc (separator
, out_fp
);
4816 else if (data
.username
)
4818 if (username
!= NULL
)
4820 for (uint i
= 0; i
< user_len
; i
++)
4822 fprintf (out_fp
, "%c", username
[i
]);
4825 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4827 fputc (separator
, out_fp
);
4832 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4834 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4836 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4838 fputc (separator
, out_fp
);
4842 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4844 for (uint i
= 0; i
< plain_len
; i
++)
4846 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4849 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4851 fputc (separator
, out_fp
);
4855 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4858 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4863 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4865 fprintf (out_fp
, "%llu", crackpos
);
4870 fputc ('\n', out_fp
);
4873 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
)
4877 pot_key
.hash
.salt
= hashes_buf
->salt
;
4878 pot_key
.hash
.digest
= hashes_buf
->digest
;
4880 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4886 input_buf
[input_len
] = 0;
4889 unsigned char *username
= NULL
;
4894 user_t
*user
= hashes_buf
->hash_info
->user
;
4898 username
= (unsigned char *) (user
->user_name
);
4900 user_len
= user
->user_len
;
4904 // do output the line
4905 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4909 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4910 #define LM_MASKED_PLAIN "[notfound]"
4912 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
)
4918 pot_left_key
.hash
.salt
= hash_left
->salt
;
4919 pot_left_key
.hash
.digest
= hash_left
->digest
;
4921 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4925 uint weak_hash_found
= 0;
4927 pot_t pot_right_key
;
4929 pot_right_key
.hash
.salt
= hash_right
->salt
;
4930 pot_right_key
.hash
.digest
= hash_right
->digest
;
4932 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4934 if (pot_right_ptr
== NULL
)
4936 // special case, if "weak hash"
4938 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4940 weak_hash_found
= 1;
4942 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4944 // in theory this is not needed, but we are paranoia:
4946 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4947 pot_right_ptr
->plain_len
= 0;
4951 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4953 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
4958 // at least one half was found:
4962 input_buf
[input_len
] = 0;
4966 unsigned char *username
= NULL
;
4971 user_t
*user
= hash_left
->hash_info
->user
;
4975 username
= (unsigned char *) (user
->user_name
);
4977 user_len
= user
->user_len
;
4981 // mask the part which was not found
4983 uint left_part_masked
= 0;
4984 uint right_part_masked
= 0;
4986 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
4988 if (pot_left_ptr
== NULL
)
4990 left_part_masked
= 1;
4992 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4994 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
4996 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4997 pot_left_ptr
->plain_len
= mask_plain_len
;
5000 if (pot_right_ptr
== NULL
)
5002 right_part_masked
= 1;
5004 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5006 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5008 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5009 pot_right_ptr
->plain_len
= mask_plain_len
;
5012 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5016 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5018 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5020 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5022 // do output the line
5024 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5026 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5028 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5029 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5032 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
)
5036 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5038 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5040 if (pot_ptr
== NULL
)
5044 input_buf
[input_len
] = 0;
5046 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5050 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
)
5056 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5058 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5062 pot_t pot_right_key
;
5064 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5066 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5068 uint weak_hash_found
= 0;
5070 if (pot_right_ptr
== NULL
)
5072 // special case, if "weak hash"
5074 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5076 weak_hash_found
= 1;
5078 // we just need that pot_right_ptr is not a NULL pointer
5080 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5084 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5086 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5091 // ... at least one part was not cracked
5095 input_buf
[input_len
] = 0;
5097 // only show the hash part which is still not cracked
5099 uint user_len
= input_len
- 32;
5101 char *hash_output
= (char *) mymalloc (33);
5103 memcpy (hash_output
, input_buf
, input_len
);
5105 if (pot_left_ptr
!= NULL
)
5107 // only show right part (because left part was already found)
5109 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5111 hash_output
[user_len
+ 16] = 0;
5114 if (pot_right_ptr
!= NULL
)
5116 // only show left part (because right part was already found)
5118 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5120 hash_output
[user_len
+ 16] = 0;
5123 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5125 myfree (hash_output
);
5127 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5130 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5132 uint opencl_platforms_filter
= 0;
5134 if (opencl_platforms
)
5136 char *platforms
= strdup (opencl_platforms
);
5138 char *next
= strtok (platforms
, ",");
5142 int platform
= atoi (next
);
5144 if (platform
< 1 || platform
> 32)
5146 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5151 opencl_platforms_filter
|= 1 << (platform
- 1);
5153 } while ((next
= strtok (NULL
, ",")) != NULL
);
5159 opencl_platforms_filter
= -1;
5162 return opencl_platforms_filter
;
5165 u32
setup_devices_filter (char *opencl_devices
)
5167 u32 devices_filter
= 0;
5171 char *devices
= strdup (opencl_devices
);
5173 char *next
= strtok (devices
, ",");
5177 int device_id
= atoi (next
);
5179 if (device_id
< 1 || device_id
> 32)
5181 log_error ("ERROR: invalid device_id %u specified", device_id
);
5186 devices_filter
|= 1 << (device_id
- 1);
5188 } while ((next
= strtok (NULL
, ",")) != NULL
);
5194 devices_filter
= -1;
5197 return devices_filter
;
5200 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5202 cl_device_type device_types_filter
= 0;
5204 if (opencl_device_types
)
5206 char *device_types
= strdup (opencl_device_types
);
5208 char *next
= strtok (device_types
, ",");
5212 int device_type
= atoi (next
);
5214 if (device_type
< 1 || device_type
> 3)
5216 log_error ("ERROR: invalid device_type %u specified", device_type
);
5221 device_types_filter
|= 1 << device_type
;
5223 } while ((next
= strtok (NULL
, ",")) != NULL
);
5225 free (device_types
);
5229 // Do not use CPU by default, this often reduces GPU performance because
5230 // the CPU is too busy to handle GPU synchronization
5232 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5235 return device_types_filter
;
5238 u32
get_random_num (const u32 min
, const u32 max
)
5240 if (min
== max
) return (min
);
5242 return ((rand () % (max
- min
)) + min
);
5245 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5247 u32 quotient
= dividend
/ divisor
;
5249 if (dividend
% divisor
) quotient
++;
5254 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5256 u64 quotient
= dividend
/ divisor
;
5258 if (dividend
% divisor
) quotient
++;
5263 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5265 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5266 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5268 if (tm
->tm_year
- 70)
5270 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5271 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5273 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5275 else if (tm
->tm_yday
)
5277 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5278 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5280 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5282 else if (tm
->tm_hour
)
5284 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5285 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5287 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5289 else if (tm
->tm_min
)
5291 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5292 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5294 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5298 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5300 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5304 void format_speed_display (float val
, char *buf
, size_t len
)
5315 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5326 /* generate output */
5330 snprintf (buf
, len
- 1, "%.0f ", val
);
5334 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5338 void lowercase (u8
*buf
, int len
)
5340 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5343 void uppercase (u8
*buf
, int len
)
5345 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5348 int fgetl (FILE *fp
, char *line_buf
)
5354 const int c
= fgetc (fp
);
5356 if (c
== EOF
) break;
5358 line_buf
[line_len
] = (char) c
;
5362 if (line_len
== BUFSIZ
) line_len
--;
5364 if (c
== '\n') break;
5367 if (line_len
== 0) return 0;
5369 if (line_buf
[line_len
- 1] == '\n')
5373 line_buf
[line_len
] = 0;
5376 if (line_len
== 0) return 0;
5378 if (line_buf
[line_len
- 1] == '\r')
5382 line_buf
[line_len
] = 0;
5388 int in_superchop (char *buf
)
5390 int len
= strlen (buf
);
5394 if (buf
[len
- 1] == '\n')
5401 if (buf
[len
- 1] == '\r')
5416 char **scan_directory (const char *path
)
5418 char *tmp_path
= mystrdup (path
);
5420 size_t tmp_path_len
= strlen (tmp_path
);
5422 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5424 tmp_path
[tmp_path_len
- 1] = 0;
5426 tmp_path_len
= strlen (tmp_path
);
5429 char **files
= NULL
;
5435 if ((d
= opendir (tmp_path
)) != NULL
)
5441 memset (&e
, 0, sizeof (e
));
5442 struct dirent
*de
= NULL
;
5444 if (readdir_r (d
, &e
, &de
) != 0)
5446 log_error ("ERROR: readdir_r() failed");
5451 if (de
== NULL
) break;
5455 while ((de
= readdir (d
)) != NULL
)
5458 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5460 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5462 char *path_file
= (char *) mymalloc (path_size
+ 1);
5464 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5466 path_file
[path_size
] = 0;
5470 if ((d_test
= opendir (path_file
)) != NULL
)
5478 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5482 files
[num_files
- 1] = path_file
;
5488 else if (errno
== ENOTDIR
)
5490 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5494 files
[num_files
- 1] = mystrdup (path
);
5497 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5501 files
[num_files
- 1] = NULL
;
5508 int count_dictionaries (char **dictionary_files
)
5510 if (dictionary_files
== NULL
) return 0;
5514 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5522 char *stroptitype (const uint opti_type
)
5526 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5527 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5528 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5529 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5530 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5531 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5532 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5533 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5534 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5535 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5536 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5537 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5538 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5539 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5545 char *strparser (const uint parser_status
)
5547 switch (parser_status
)
5549 case PARSER_OK
: return ((char *) PA_000
); break;
5550 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5551 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5552 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5553 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5554 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5555 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5556 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5557 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5558 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5559 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5560 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5561 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5562 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5563 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5564 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5565 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5568 return ((char *) PA_255
);
5571 char *strhashtype (const uint hash_mode
)
5575 case 0: return ((char *) HT_00000
); break;
5576 case 10: return ((char *) HT_00010
); break;
5577 case 11: return ((char *) HT_00011
); break;
5578 case 12: return ((char *) HT_00012
); break;
5579 case 20: return ((char *) HT_00020
); break;
5580 case 21: return ((char *) HT_00021
); break;
5581 case 22: return ((char *) HT_00022
); break;
5582 case 23: return ((char *) HT_00023
); break;
5583 case 30: return ((char *) HT_00030
); break;
5584 case 40: return ((char *) HT_00040
); break;
5585 case 50: return ((char *) HT_00050
); break;
5586 case 60: return ((char *) HT_00060
); break;
5587 case 100: return ((char *) HT_00100
); break;
5588 case 101: return ((char *) HT_00101
); break;
5589 case 110: return ((char *) HT_00110
); break;
5590 case 111: return ((char *) HT_00111
); break;
5591 case 112: return ((char *) HT_00112
); break;
5592 case 120: return ((char *) HT_00120
); break;
5593 case 121: return ((char *) HT_00121
); break;
5594 case 122: return ((char *) HT_00122
); break;
5595 case 124: return ((char *) HT_00124
); break;
5596 case 130: return ((char *) HT_00130
); break;
5597 case 131: return ((char *) HT_00131
); break;
5598 case 132: return ((char *) HT_00132
); break;
5599 case 133: return ((char *) HT_00133
); break;
5600 case 140: return ((char *) HT_00140
); break;
5601 case 141: return ((char *) HT_00141
); break;
5602 case 150: return ((char *) HT_00150
); break;
5603 case 160: return ((char *) HT_00160
); break;
5604 case 190: return ((char *) HT_00190
); break;
5605 case 200: return ((char *) HT_00200
); break;
5606 case 300: return ((char *) HT_00300
); break;
5607 case 400: return ((char *) HT_00400
); break;
5608 case 500: return ((char *) HT_00500
); break;
5609 case 501: return ((char *) HT_00501
); break;
5610 case 900: return ((char *) HT_00900
); break;
5611 case 910: return ((char *) HT_00910
); break;
5612 case 1000: return ((char *) HT_01000
); break;
5613 case 1100: return ((char *) HT_01100
); break;
5614 case 1400: return ((char *) HT_01400
); break;
5615 case 1410: return ((char *) HT_01410
); break;
5616 case 1420: return ((char *) HT_01420
); break;
5617 case 1421: return ((char *) HT_01421
); break;
5618 case 1430: return ((char *) HT_01430
); break;
5619 case 1440: return ((char *) HT_01440
); break;
5620 case 1441: return ((char *) HT_01441
); break;
5621 case 1450: return ((char *) HT_01450
); break;
5622 case 1460: return ((char *) HT_01460
); break;
5623 case 1500: return ((char *) HT_01500
); break;
5624 case 1600: return ((char *) HT_01600
); break;
5625 case 1700: return ((char *) HT_01700
); break;
5626 case 1710: return ((char *) HT_01710
); break;
5627 case 1711: return ((char *) HT_01711
); break;
5628 case 1720: return ((char *) HT_01720
); break;
5629 case 1722: return ((char *) HT_01722
); break;
5630 case 1730: return ((char *) HT_01730
); break;
5631 case 1731: return ((char *) HT_01731
); break;
5632 case 1740: return ((char *) HT_01740
); break;
5633 case 1750: return ((char *) HT_01750
); break;
5634 case 1760: return ((char *) HT_01760
); break;
5635 case 1800: return ((char *) HT_01800
); break;
5636 case 2100: return ((char *) HT_02100
); break;
5637 case 2400: return ((char *) HT_02400
); break;
5638 case 2410: return ((char *) HT_02410
); break;
5639 case 2500: return ((char *) HT_02500
); break;
5640 case 2600: return ((char *) HT_02600
); break;
5641 case 2611: return ((char *) HT_02611
); break;
5642 case 2612: return ((char *) HT_02612
); break;
5643 case 2711: return ((char *) HT_02711
); break;
5644 case 2811: return ((char *) HT_02811
); break;
5645 case 3000: return ((char *) HT_03000
); break;
5646 case 3100: return ((char *) HT_03100
); break;
5647 case 3200: return ((char *) HT_03200
); break;
5648 case 3710: return ((char *) HT_03710
); break;
5649 case 3711: return ((char *) HT_03711
); break;
5650 case 3800: return ((char *) HT_03800
); break;
5651 case 4300: return ((char *) HT_04300
); break;
5652 case 4400: return ((char *) HT_04400
); break;
5653 case 4500: return ((char *) HT_04500
); break;
5654 case 4700: return ((char *) HT_04700
); break;
5655 case 4800: return ((char *) HT_04800
); break;
5656 case 4900: return ((char *) HT_04900
); break;
5657 case 5000: return ((char *) HT_05000
); break;
5658 case 5100: return ((char *) HT_05100
); break;
5659 case 5200: return ((char *) HT_05200
); break;
5660 case 5300: return ((char *) HT_05300
); break;
5661 case 5400: return ((char *) HT_05400
); break;
5662 case 5500: return ((char *) HT_05500
); break;
5663 case 5600: return ((char *) HT_05600
); break;
5664 case 5700: return ((char *) HT_05700
); break;
5665 case 5800: return ((char *) HT_05800
); break;
5666 case 6000: return ((char *) HT_06000
); break;
5667 case 6100: return ((char *) HT_06100
); break;
5668 case 6211: return ((char *) HT_06211
); break;
5669 case 6212: return ((char *) HT_06212
); break;
5670 case 6213: return ((char *) HT_06213
); break;
5671 case 6221: return ((char *) HT_06221
); break;
5672 case 6222: return ((char *) HT_06222
); break;
5673 case 6223: return ((char *) HT_06223
); break;
5674 case 6231: return ((char *) HT_06231
); break;
5675 case 6232: return ((char *) HT_06232
); break;
5676 case 6233: return ((char *) HT_06233
); break;
5677 case 6241: return ((char *) HT_06241
); break;
5678 case 6242: return ((char *) HT_06242
); break;
5679 case 6243: return ((char *) HT_06243
); break;
5680 case 6300: return ((char *) HT_06300
); break;
5681 case 6400: return ((char *) HT_06400
); break;
5682 case 6500: return ((char *) HT_06500
); break;
5683 case 6600: return ((char *) HT_06600
); break;
5684 case 6700: return ((char *) HT_06700
); break;
5685 case 6800: return ((char *) HT_06800
); break;
5686 case 6900: return ((char *) HT_06900
); break;
5687 case 7100: return ((char *) HT_07100
); break;
5688 case 7200: return ((char *) HT_07200
); break;
5689 case 7300: return ((char *) HT_07300
); break;
5690 case 7400: return ((char *) HT_07400
); break;
5691 case 7500: return ((char *) HT_07500
); break;
5692 case 7600: return ((char *) HT_07600
); break;
5693 case 7700: return ((char *) HT_07700
); break;
5694 case 7800: return ((char *) HT_07800
); break;
5695 case 7900: return ((char *) HT_07900
); break;
5696 case 8000: return ((char *) HT_08000
); break;
5697 case 8100: return ((char *) HT_08100
); break;
5698 case 8200: return ((char *) HT_08200
); break;
5699 case 8300: return ((char *) HT_08300
); break;
5700 case 8400: return ((char *) HT_08400
); break;
5701 case 8500: return ((char *) HT_08500
); break;
5702 case 8600: return ((char *) HT_08600
); break;
5703 case 8700: return ((char *) HT_08700
); break;
5704 case 8800: return ((char *) HT_08800
); break;
5705 case 8900: return ((char *) HT_08900
); break;
5706 case 9000: return ((char *) HT_09000
); break;
5707 case 9100: return ((char *) HT_09100
); break;
5708 case 9200: return ((char *) HT_09200
); break;
5709 case 9300: return ((char *) HT_09300
); break;
5710 case 9400: return ((char *) HT_09400
); break;
5711 case 9500: return ((char *) HT_09500
); break;
5712 case 9600: return ((char *) HT_09600
); break;
5713 case 9700: return ((char *) HT_09700
); break;
5714 case 9710: return ((char *) HT_09710
); break;
5715 case 9720: return ((char *) HT_09720
); break;
5716 case 9800: return ((char *) HT_09800
); break;
5717 case 9810: return ((char *) HT_09810
); break;
5718 case 9820: return ((char *) HT_09820
); break;
5719 case 9900: return ((char *) HT_09900
); break;
5720 case 10000: return ((char *) HT_10000
); break;
5721 case 10100: return ((char *) HT_10100
); break;
5722 case 10200: return ((char *) HT_10200
); break;
5723 case 10300: return ((char *) HT_10300
); break;
5724 case 10400: return ((char *) HT_10400
); break;
5725 case 10410: return ((char *) HT_10410
); break;
5726 case 10420: return ((char *) HT_10420
); break;
5727 case 10500: return ((char *) HT_10500
); break;
5728 case 10600: return ((char *) HT_10600
); break;
5729 case 10700: return ((char *) HT_10700
); break;
5730 case 10800: return ((char *) HT_10800
); break;
5731 case 10900: return ((char *) HT_10900
); break;
5732 case 11000: return ((char *) HT_11000
); break;
5733 case 11100: return ((char *) HT_11100
); break;
5734 case 11200: return ((char *) HT_11200
); break;
5735 case 11300: return ((char *) HT_11300
); break;
5736 case 11400: return ((char *) HT_11400
); break;
5737 case 11500: return ((char *) HT_11500
); break;
5738 case 11600: return ((char *) HT_11600
); break;
5739 case 11700: return ((char *) HT_11700
); break;
5740 case 11800: return ((char *) HT_11800
); break;
5741 case 11900: return ((char *) HT_11900
); break;
5742 case 12000: return ((char *) HT_12000
); break;
5743 case 12100: return ((char *) HT_12100
); break;
5744 case 12200: return ((char *) HT_12200
); break;
5745 case 12300: return ((char *) HT_12300
); break;
5746 case 12400: return ((char *) HT_12400
); break;
5747 case 12500: return ((char *) HT_12500
); break;
5748 case 12600: return ((char *) HT_12600
); break;
5749 case 12700: return ((char *) HT_12700
); break;
5750 case 12800: return ((char *) HT_12800
); break;
5751 case 12900: return ((char *) HT_12900
); break;
5752 case 13000: return ((char *) HT_13000
); break;
5755 return ((char *) "Unknown");
5758 char *strstatus (const uint devices_status
)
5760 switch (devices_status
)
5762 case STATUS_INIT
: return ((char *) ST_0000
); break;
5763 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5764 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5765 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5766 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5767 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5768 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5769 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5770 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5771 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5774 return ((char *) "Unknown");
5777 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5779 uint hash_type
= data
.hash_type
;
5780 uint hash_mode
= data
.hash_mode
;
5781 uint salt_type
= data
.salt_type
;
5782 uint opts_type
= data
.opts_type
;
5783 uint opti_type
= data
.opti_type
;
5784 uint dgst_size
= data
.dgst_size
;
5786 char *hashfile
= data
.hashfile
;
5790 uint digest_buf
[64] = { 0 };
5792 u64
*digest_buf64
= (u64
*) digest_buf
;
5794 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5796 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5798 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5804 case HASH_TYPE_DESCRYPT
:
5805 FP (digest_buf
[1], digest_buf
[0], tt
);
5808 case HASH_TYPE_DESRACF
:
5809 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5810 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5812 FP (digest_buf
[1], digest_buf
[0], tt
);
5816 FP (digest_buf
[1], digest_buf
[0], tt
);
5819 case HASH_TYPE_NETNTLM
:
5820 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5821 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5822 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5823 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5825 FP (digest_buf
[1], digest_buf
[0], tt
);
5826 FP (digest_buf
[3], digest_buf
[2], tt
);
5829 case HASH_TYPE_BSDICRYPT
:
5830 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5831 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5833 FP (digest_buf
[1], digest_buf
[0], tt
);
5838 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5843 digest_buf
[0] += MD4M_A
;
5844 digest_buf
[1] += MD4M_B
;
5845 digest_buf
[2] += MD4M_C
;
5846 digest_buf
[3] += MD4M_D
;
5850 digest_buf
[0] += MD5M_A
;
5851 digest_buf
[1] += MD5M_B
;
5852 digest_buf
[2] += MD5M_C
;
5853 digest_buf
[3] += MD5M_D
;
5856 case HASH_TYPE_SHA1
:
5857 digest_buf
[0] += SHA1M_A
;
5858 digest_buf
[1] += SHA1M_B
;
5859 digest_buf
[2] += SHA1M_C
;
5860 digest_buf
[3] += SHA1M_D
;
5861 digest_buf
[4] += SHA1M_E
;
5864 case HASH_TYPE_SHA256
:
5865 digest_buf
[0] += SHA256M_A
;
5866 digest_buf
[1] += SHA256M_B
;
5867 digest_buf
[2] += SHA256M_C
;
5868 digest_buf
[3] += SHA256M_D
;
5869 digest_buf
[4] += SHA256M_E
;
5870 digest_buf
[5] += SHA256M_F
;
5871 digest_buf
[6] += SHA256M_G
;
5872 digest_buf
[7] += SHA256M_H
;
5875 case HASH_TYPE_SHA384
:
5876 digest_buf64
[0] += SHA384M_A
;
5877 digest_buf64
[1] += SHA384M_B
;
5878 digest_buf64
[2] += SHA384M_C
;
5879 digest_buf64
[3] += SHA384M_D
;
5880 digest_buf64
[4] += SHA384M_E
;
5881 digest_buf64
[5] += SHA384M_F
;
5882 digest_buf64
[6] += 0;
5883 digest_buf64
[7] += 0;
5886 case HASH_TYPE_SHA512
:
5887 digest_buf64
[0] += SHA512M_A
;
5888 digest_buf64
[1] += SHA512M_B
;
5889 digest_buf64
[2] += SHA512M_C
;
5890 digest_buf64
[3] += SHA512M_D
;
5891 digest_buf64
[4] += SHA512M_E
;
5892 digest_buf64
[5] += SHA512M_F
;
5893 digest_buf64
[6] += SHA512M_G
;
5894 digest_buf64
[7] += SHA512M_H
;
5899 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5901 if (dgst_size
== DGST_SIZE_4_2
)
5903 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5905 else if (dgst_size
== DGST_SIZE_4_4
)
5907 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5909 else if (dgst_size
== DGST_SIZE_4_5
)
5911 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5913 else if (dgst_size
== DGST_SIZE_4_6
)
5915 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5917 else if (dgst_size
== DGST_SIZE_4_8
)
5919 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5921 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5923 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5925 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5927 else if (hash_type
== HASH_TYPE_SHA384
)
5929 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5931 else if (hash_type
== HASH_TYPE_SHA512
)
5933 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5935 else if (hash_type
== HASH_TYPE_GOST
)
5937 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5940 else if (dgst_size
== DGST_SIZE_4_64
)
5942 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5944 else if (dgst_size
== DGST_SIZE_8_25
)
5946 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5950 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5951 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5952 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5958 memset (&salt
, 0, sizeof (salt_t
));
5960 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5962 char *ptr
= (char *) salt
.salt_buf
;
5964 uint len
= salt
.salt_len
;
5966 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5972 case HASH_TYPE_NETNTLM
:
5974 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
5975 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
5977 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5983 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5985 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5993 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
5995 uint max
= salt
.salt_len
/ 4;
5999 for (uint i
= 0; i
< max
; i
++)
6001 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6005 if (opts_type
& OPTS_TYPE_ST_HEX
)
6007 char tmp
[64] = { 0 };
6009 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6011 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6016 memcpy (ptr
, tmp
, len
);
6019 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6021 memset (ptr
+ len
, 0, memset_size
);
6023 salt
.salt_len
= len
;
6027 // some modes require special encoding
6030 uint out_buf_plain
[256] = { 0 };
6031 uint out_buf_salt
[256] = { 0 };
6033 char tmp_buf
[1024] = { 0 };
6035 char *ptr_plain
= (char *) out_buf_plain
;
6036 char *ptr_salt
= (char *) out_buf_salt
;
6038 if (hash_mode
== 22)
6040 char username
[30] = { 0 };
6042 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6044 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6046 u16
*ptr
= (u16
*) digest_buf
;
6048 tmp_buf
[ 0] = sig
[0];
6049 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6050 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6051 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6052 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6053 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6054 tmp_buf
[ 6] = sig
[1];
6055 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6056 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6057 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6058 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6059 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6060 tmp_buf
[12] = sig
[2];
6061 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6062 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6063 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6064 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6065 tmp_buf
[17] = sig
[3];
6066 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6067 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6068 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6069 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6070 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6071 tmp_buf
[23] = sig
[4];
6072 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6073 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6074 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6075 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6076 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6077 tmp_buf
[29] = sig
[5];
6079 snprintf (out_buf
, len
-1, "%s:%s",
6083 else if (hash_mode
== 23)
6085 // do not show the \nskyper\n part in output
6087 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6089 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6091 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6098 else if (hash_mode
== 101)
6100 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6102 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6103 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6104 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6105 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6106 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6108 memcpy (tmp_buf
, digest_buf
, 20);
6110 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6112 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6114 else if (hash_mode
== 111)
6116 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6118 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6119 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6120 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6121 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6122 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6124 memcpy (tmp_buf
, digest_buf
, 20);
6125 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6127 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6129 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6131 else if (hash_mode
== 122)
6133 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6134 (char *) salt
.salt_buf
,
6141 else if (hash_mode
== 124)
6143 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6144 (char *) salt
.salt_buf
,
6151 else if (hash_mode
== 131)
6153 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6154 (char *) salt
.salt_buf
,
6162 else if (hash_mode
== 132)
6164 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6165 (char *) salt
.salt_buf
,
6172 else if (hash_mode
== 133)
6174 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6176 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6177 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6178 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6179 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6180 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6182 memcpy (tmp_buf
, digest_buf
, 20);
6184 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6186 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6188 else if (hash_mode
== 141)
6190 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6192 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6194 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6196 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6198 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6199 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6200 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6201 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6202 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6204 memcpy (tmp_buf
, digest_buf
, 20);
6206 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6210 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6212 else if (hash_mode
== 400)
6214 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6216 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6217 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6218 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6219 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6221 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6223 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6225 else if (hash_mode
== 500)
6227 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6229 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6230 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6231 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6232 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6234 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6236 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6238 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6242 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6245 else if (hash_mode
== 501)
6247 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6249 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6250 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6252 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6254 else if (hash_mode
== 1421)
6256 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6258 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6274 else if (hash_mode
== 1441)
6276 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6278 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6280 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6282 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6284 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6285 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6286 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6287 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6288 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6289 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6290 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6291 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6293 memcpy (tmp_buf
, digest_buf
, 32);
6295 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6299 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6301 else if (hash_mode
== 1500)
6303 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6304 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6305 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6306 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6307 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6309 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6311 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6313 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6314 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6316 memcpy (tmp_buf
, digest_buf
, 8);
6318 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6320 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6324 else if (hash_mode
== 1600)
6326 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6328 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6329 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6330 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6331 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6333 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6335 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6337 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6341 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6344 else if (hash_mode
== 1711)
6346 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6348 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6349 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6350 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6351 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6352 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6353 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6354 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6355 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6357 memcpy (tmp_buf
, digest_buf
, 64);
6358 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6360 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6362 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6364 else if (hash_mode
== 1722)
6366 uint
*ptr
= digest_buf
;
6368 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6369 (unsigned char *) salt
.salt_buf
,
6379 else if (hash_mode
== 1731)
6381 uint
*ptr
= digest_buf
;
6383 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6384 (unsigned char *) salt
.salt_buf
,
6394 else if (hash_mode
== 1800)
6398 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6399 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6400 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6401 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6402 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6403 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6404 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6405 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6407 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6409 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6411 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6415 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6418 else if (hash_mode
== 2100)
6422 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6424 salt
.salt_iter
+ 1);
6426 uint signature_len
= strlen (out_buf
);
6428 pos
+= signature_len
;
6429 len
-= signature_len
;
6431 char *salt_ptr
= (char *) salt
.salt_buf
;
6433 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6435 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6436 byte_swap_32 (digest_buf
[0]),
6437 byte_swap_32 (digest_buf
[1]),
6438 byte_swap_32 (digest_buf
[2]),
6439 byte_swap_32 (digest_buf
[3]));
6441 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6443 memcpy (tmp_buf
, digest_buf
, 16);
6445 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6447 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6448 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6449 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6450 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6452 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6453 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6454 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6455 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6457 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6458 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6459 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6460 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6462 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6463 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6464 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6465 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6467 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6468 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6469 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6470 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6474 else if (hash_mode
== 2500)
6476 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6478 wpa_t
*wpa
= &wpas
[salt_pos
];
6480 uint pke
[25] = { 0 };
6482 char *pke_ptr
= (char *) pke
;
6484 for (uint i
= 0; i
< 25; i
++)
6486 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6489 unsigned char mac1
[6] = { 0 };
6490 unsigned char mac2
[6] = { 0 };
6492 memcpy (mac1
, pke_ptr
+ 23, 6);
6493 memcpy (mac2
, pke_ptr
+ 29, 6);
6495 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6496 (char *) salt
.salt_buf
,
6510 else if (hash_mode
== 4400)
6512 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6513 byte_swap_32 (digest_buf
[0]),
6514 byte_swap_32 (digest_buf
[1]),
6515 byte_swap_32 (digest_buf
[2]),
6516 byte_swap_32 (digest_buf
[3]));
6518 else if (hash_mode
== 4700)
6520 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6521 byte_swap_32 (digest_buf
[0]),
6522 byte_swap_32 (digest_buf
[1]),
6523 byte_swap_32 (digest_buf
[2]),
6524 byte_swap_32 (digest_buf
[3]),
6525 byte_swap_32 (digest_buf
[4]));
6527 else if (hash_mode
== 4800)
6529 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6531 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6536 byte_swap_32 (salt
.salt_buf
[0]),
6537 byte_swap_32 (salt
.salt_buf
[1]),
6538 byte_swap_32 (salt
.salt_buf
[2]),
6539 byte_swap_32 (salt
.salt_buf
[3]),
6542 else if (hash_mode
== 4900)
6544 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6545 byte_swap_32 (digest_buf
[0]),
6546 byte_swap_32 (digest_buf
[1]),
6547 byte_swap_32 (digest_buf
[2]),
6548 byte_swap_32 (digest_buf
[3]),
6549 byte_swap_32 (digest_buf
[4]));
6551 else if (hash_mode
== 5100)
6553 snprintf (out_buf
, len
-1, "%08x%08x",
6557 else if (hash_mode
== 5200)
6559 snprintf (out_buf
, len
-1, "%s", hashfile
);
6561 else if (hash_mode
== 5300)
6563 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6565 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6567 int buf_len
= len
-1;
6571 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6573 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6575 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6577 snprintf (out_buf
, buf_len
, ":");
6583 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6591 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6593 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6595 if ((i
== 0) || (i
== 5))
6597 snprintf (out_buf
, buf_len
, ":");
6603 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6611 for (uint i
= 0; i
< 4; i
++)
6615 snprintf (out_buf
, buf_len
, ":");
6621 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6627 else if (hash_mode
== 5400)
6629 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6631 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6633 int buf_len
= len
-1;
6637 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6639 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6641 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6643 snprintf (out_buf
, buf_len
, ":");
6649 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6657 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6659 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6661 if ((i
== 0) || (i
== 5))
6663 snprintf (out_buf
, buf_len
, ":");
6669 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6677 for (uint i
= 0; i
< 5; i
++)
6681 snprintf (out_buf
, buf_len
, ":");
6687 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6693 else if (hash_mode
== 5500)
6695 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6697 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6699 char user_buf
[64] = { 0 };
6700 char domain_buf
[64] = { 0 };
6701 char srvchall_buf
[1024] = { 0 };
6702 char clichall_buf
[1024] = { 0 };
6704 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6706 char *ptr
= (char *) netntlm
->userdomain_buf
;
6708 user_buf
[i
] = ptr
[j
];
6711 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6713 char *ptr
= (char *) netntlm
->userdomain_buf
;
6715 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6718 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6720 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6722 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6725 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6727 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6729 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6732 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6740 byte_swap_32 (salt
.salt_buf_pc
[0]),
6741 byte_swap_32 (salt
.salt_buf_pc
[1]),
6744 else if (hash_mode
== 5600)
6746 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6748 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6750 char user_buf
[64] = { 0 };
6751 char domain_buf
[64] = { 0 };
6752 char srvchall_buf
[1024] = { 0 };
6753 char clichall_buf
[1024] = { 0 };
6755 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6757 char *ptr
= (char *) netntlm
->userdomain_buf
;
6759 user_buf
[i
] = ptr
[j
];
6762 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6764 char *ptr
= (char *) netntlm
->userdomain_buf
;
6766 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6769 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6771 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6773 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6776 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6778 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6780 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6783 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6793 else if (hash_mode
== 5700)
6795 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6797 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6798 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6799 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6800 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6801 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6802 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6803 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6804 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6806 memcpy (tmp_buf
, digest_buf
, 32);
6808 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6812 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6814 else if (hash_mode
== 5800)
6816 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6817 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6818 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6819 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6820 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6822 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6829 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6831 snprintf (out_buf
, len
-1, "%s", hashfile
);
6833 else if (hash_mode
== 6300)
6835 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6837 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6838 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6839 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6840 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6842 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6844 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6846 else if (hash_mode
== 6400)
6848 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6850 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6852 else if (hash_mode
== 6500)
6854 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6856 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6858 else if (hash_mode
== 6600)
6860 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6862 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6864 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6865 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6867 uint buf_len
= len
- 1;
6869 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6872 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6874 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6879 else if (hash_mode
== 6700)
6881 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6883 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6885 else if (hash_mode
== 6800)
6887 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6889 else if (hash_mode
== 7100)
6891 uint
*ptr
= digest_buf
;
6893 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6895 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6897 uint esalt
[8] = { 0 };
6899 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6900 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6901 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6902 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6903 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6904 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6905 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6906 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6908 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",
6909 SIGNATURE_SHA512OSX
,
6911 esalt
[ 0], esalt
[ 1],
6912 esalt
[ 2], esalt
[ 3],
6913 esalt
[ 4], esalt
[ 5],
6914 esalt
[ 6], esalt
[ 7],
6922 ptr
[15], ptr
[14]);
6924 else if (hash_mode
== 7200)
6926 uint
*ptr
= digest_buf
;
6928 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6930 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6934 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6936 len_used
= strlen (out_buf
);
6938 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6940 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6942 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6945 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",
6953 ptr
[15], ptr
[14]);
6955 else if (hash_mode
== 7300)
6957 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6959 rakp_t
*rakp
= &rakps
[salt_pos
];
6961 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6963 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6966 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6973 else if (hash_mode
== 7400)
6975 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6977 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6978 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6979 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6980 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6981 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6982 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6983 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6984 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6986 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6988 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
6990 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6994 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6997 else if (hash_mode
== 7500)
6999 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7001 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7003 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7004 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7006 char data
[128] = { 0 };
7008 char *ptr_data
= data
;
7010 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7012 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7015 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7017 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7022 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7024 (char *) krb5pa
->user
,
7025 (char *) krb5pa
->realm
,
7026 (char *) krb5pa
->salt
,
7029 else if (hash_mode
== 7700)
7031 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7032 (char *) salt
.salt_buf
,
7036 else if (hash_mode
== 7800)
7038 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7039 (char *) salt
.salt_buf
,
7046 else if (hash_mode
== 7900)
7048 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7052 char *tmp
= (char *) salt
.salt_buf_pc
;
7054 ptr_plain
[42] = tmp
[0];
7060 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7062 else if (hash_mode
== 8000)
7064 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7065 (unsigned char *) salt
.salt_buf
,
7075 else if (hash_mode
== 8100)
7077 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7078 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7080 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7081 (unsigned char *) salt
.salt_buf
,
7088 else if (hash_mode
== 8200)
7090 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7092 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7094 char data_buf
[4096] = { 0 };
7096 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7098 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7101 data_buf
[cloudkey
->data_len
* 2] = 0;
7103 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7104 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7105 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7106 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7107 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7108 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7109 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7110 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7112 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7113 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7114 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7115 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7117 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7133 else if (hash_mode
== 8300)
7135 char digest_buf_c
[34] = { 0 };
7137 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7139 digest_buf_c
[32] = 0;
7143 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7145 char domain_buf_c
[33] = { 0 };
7147 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7149 for (uint i
= 0; i
< salt_pc_len
; i
++)
7151 const char next
= domain_buf_c
[i
];
7153 domain_buf_c
[i
] = '.';
7158 domain_buf_c
[salt_pc_len
] = 0;
7162 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7164 else if (hash_mode
== 8500)
7166 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7168 else if (hash_mode
== 2612)
7170 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7172 (char *) salt
.salt_buf
,
7178 else if (hash_mode
== 3711)
7180 char *salt_ptr
= (char *) salt
.salt_buf
;
7182 salt_ptr
[salt
.salt_len
- 1] = 0;
7184 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7185 SIGNATURE_MEDIAWIKI_B
,
7192 else if (hash_mode
== 8800)
7194 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7196 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7198 char tmp
[3073] = { 0 };
7200 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7202 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7207 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7208 SIGNATURE_ANDROIDFDE
,
7209 byte_swap_32 (salt
.salt_buf
[0]),
7210 byte_swap_32 (salt
.salt_buf
[1]),
7211 byte_swap_32 (salt
.salt_buf
[2]),
7212 byte_swap_32 (salt
.salt_buf
[3]),
7213 byte_swap_32 (digest_buf
[0]),
7214 byte_swap_32 (digest_buf
[1]),
7215 byte_swap_32 (digest_buf
[2]),
7216 byte_swap_32 (digest_buf
[3]),
7219 else if (hash_mode
== 8900)
7221 uint N
= salt
.scrypt_N
;
7222 uint r
= salt
.scrypt_r
;
7223 uint p
= salt
.scrypt_p
;
7225 char base64_salt
[32] = { 0 };
7227 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7229 memset (tmp_buf
, 0, 46);
7231 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7232 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7233 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7234 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7235 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7236 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7237 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7238 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7239 digest_buf
[8] = 0; // needed for base64_encode ()
7241 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7243 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7251 else if (hash_mode
== 9000)
7253 snprintf (out_buf
, len
-1, "%s", hashfile
);
7255 else if (hash_mode
== 9200)
7259 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7261 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7263 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7267 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7268 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7269 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7270 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7271 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7272 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7273 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7274 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7275 digest_buf
[8] = 0; // needed for base64_encode ()
7277 char tmp_buf
[64] = { 0 };
7279 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7280 tmp_buf
[43] = 0; // cut it here
7284 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7286 else if (hash_mode
== 9300)
7288 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7289 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7290 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7291 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7292 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7293 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7294 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7295 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7296 digest_buf
[8] = 0; // needed for base64_encode ()
7298 char tmp_buf
[64] = { 0 };
7300 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7301 tmp_buf
[43] = 0; // cut it here
7303 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7305 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7307 else if (hash_mode
== 9400)
7309 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7311 office2007_t
*office2007
= &office2007s
[salt_pos
];
7313 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7314 SIGNATURE_OFFICE2007
,
7317 office2007
->keySize
,
7323 office2007
->encryptedVerifier
[0],
7324 office2007
->encryptedVerifier
[1],
7325 office2007
->encryptedVerifier
[2],
7326 office2007
->encryptedVerifier
[3],
7327 office2007
->encryptedVerifierHash
[0],
7328 office2007
->encryptedVerifierHash
[1],
7329 office2007
->encryptedVerifierHash
[2],
7330 office2007
->encryptedVerifierHash
[3],
7331 office2007
->encryptedVerifierHash
[4]);
7333 else if (hash_mode
== 9500)
7335 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7337 office2010_t
*office2010
= &office2010s
[salt_pos
];
7339 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,
7345 office2010
->encryptedVerifier
[0],
7346 office2010
->encryptedVerifier
[1],
7347 office2010
->encryptedVerifier
[2],
7348 office2010
->encryptedVerifier
[3],
7349 office2010
->encryptedVerifierHash
[0],
7350 office2010
->encryptedVerifierHash
[1],
7351 office2010
->encryptedVerifierHash
[2],
7352 office2010
->encryptedVerifierHash
[3],
7353 office2010
->encryptedVerifierHash
[4],
7354 office2010
->encryptedVerifierHash
[5],
7355 office2010
->encryptedVerifierHash
[6],
7356 office2010
->encryptedVerifierHash
[7]);
7358 else if (hash_mode
== 9600)
7360 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7362 office2013_t
*office2013
= &office2013s
[salt_pos
];
7364 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,
7370 office2013
->encryptedVerifier
[0],
7371 office2013
->encryptedVerifier
[1],
7372 office2013
->encryptedVerifier
[2],
7373 office2013
->encryptedVerifier
[3],
7374 office2013
->encryptedVerifierHash
[0],
7375 office2013
->encryptedVerifierHash
[1],
7376 office2013
->encryptedVerifierHash
[2],
7377 office2013
->encryptedVerifierHash
[3],
7378 office2013
->encryptedVerifierHash
[4],
7379 office2013
->encryptedVerifierHash
[5],
7380 office2013
->encryptedVerifierHash
[6],
7381 office2013
->encryptedVerifierHash
[7]);
7383 else if (hash_mode
== 9700)
7385 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7387 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7389 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7390 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7391 byte_swap_32 (salt
.salt_buf
[0]),
7392 byte_swap_32 (salt
.salt_buf
[1]),
7393 byte_swap_32 (salt
.salt_buf
[2]),
7394 byte_swap_32 (salt
.salt_buf
[3]),
7395 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7396 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7397 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7398 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7399 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7400 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7401 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7402 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7404 else if (hash_mode
== 9710)
7406 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7408 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7410 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7411 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7412 byte_swap_32 (salt
.salt_buf
[0]),
7413 byte_swap_32 (salt
.salt_buf
[1]),
7414 byte_swap_32 (salt
.salt_buf
[2]),
7415 byte_swap_32 (salt
.salt_buf
[3]),
7416 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7417 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7418 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7419 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7420 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7421 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7422 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7423 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7425 else if (hash_mode
== 9720)
7427 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7429 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7431 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7433 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7434 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7435 byte_swap_32 (salt
.salt_buf
[0]),
7436 byte_swap_32 (salt
.salt_buf
[1]),
7437 byte_swap_32 (salt
.salt_buf
[2]),
7438 byte_swap_32 (salt
.salt_buf
[3]),
7439 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7440 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7441 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7442 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7443 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7444 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7445 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7446 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7453 else if (hash_mode
== 9800)
7455 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7457 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7459 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7460 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7465 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7466 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7467 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7468 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7469 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7470 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7471 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7472 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7473 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7475 else if (hash_mode
== 9810)
7477 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7479 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7481 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7482 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7487 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7488 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7489 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7490 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7491 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7492 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7493 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7494 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7495 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7497 else if (hash_mode
== 9820)
7499 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7501 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7503 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7505 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7506 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7511 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7512 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7513 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7514 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7515 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7516 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7517 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7518 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7519 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7526 else if (hash_mode
== 10000)
7530 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7532 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7534 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7538 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7539 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7540 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7541 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7542 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7543 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7544 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7545 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7546 digest_buf
[8] = 0; // needed for base64_encode ()
7548 char tmp_buf
[64] = { 0 };
7550 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7554 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7556 else if (hash_mode
== 10100)
7558 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7563 byte_swap_32 (salt
.salt_buf
[0]),
7564 byte_swap_32 (salt
.salt_buf
[1]),
7565 byte_swap_32 (salt
.salt_buf
[2]),
7566 byte_swap_32 (salt
.salt_buf
[3]));
7568 else if (hash_mode
== 10200)
7570 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7572 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7576 char challenge
[100] = { 0 };
7578 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7582 char tmp_buf
[100] = { 0 };
7584 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7585 (char *) cram_md5
->user
,
7591 char response
[100] = { 0 };
7593 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7595 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7597 else if (hash_mode
== 10300)
7599 char tmp_buf
[100] = { 0 };
7601 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7602 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7604 uint tmp_len
= 20 + salt
.salt_len
;
7608 char base64_encoded
[100] = { 0 };
7610 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7612 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7614 else if (hash_mode
== 10400)
7616 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7618 pdf_t
*pdf
= &pdfs
[salt_pos
];
7620 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",
7628 byte_swap_32 (pdf
->id_buf
[0]),
7629 byte_swap_32 (pdf
->id_buf
[1]),
7630 byte_swap_32 (pdf
->id_buf
[2]),
7631 byte_swap_32 (pdf
->id_buf
[3]),
7633 byte_swap_32 (pdf
->u_buf
[0]),
7634 byte_swap_32 (pdf
->u_buf
[1]),
7635 byte_swap_32 (pdf
->u_buf
[2]),
7636 byte_swap_32 (pdf
->u_buf
[3]),
7637 byte_swap_32 (pdf
->u_buf
[4]),
7638 byte_swap_32 (pdf
->u_buf
[5]),
7639 byte_swap_32 (pdf
->u_buf
[6]),
7640 byte_swap_32 (pdf
->u_buf
[7]),
7642 byte_swap_32 (pdf
->o_buf
[0]),
7643 byte_swap_32 (pdf
->o_buf
[1]),
7644 byte_swap_32 (pdf
->o_buf
[2]),
7645 byte_swap_32 (pdf
->o_buf
[3]),
7646 byte_swap_32 (pdf
->o_buf
[4]),
7647 byte_swap_32 (pdf
->o_buf
[5]),
7648 byte_swap_32 (pdf
->o_buf
[6]),
7649 byte_swap_32 (pdf
->o_buf
[7])
7652 else if (hash_mode
== 10410)
7654 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7656 pdf_t
*pdf
= &pdfs
[salt_pos
];
7658 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",
7666 byte_swap_32 (pdf
->id_buf
[0]),
7667 byte_swap_32 (pdf
->id_buf
[1]),
7668 byte_swap_32 (pdf
->id_buf
[2]),
7669 byte_swap_32 (pdf
->id_buf
[3]),
7671 byte_swap_32 (pdf
->u_buf
[0]),
7672 byte_swap_32 (pdf
->u_buf
[1]),
7673 byte_swap_32 (pdf
->u_buf
[2]),
7674 byte_swap_32 (pdf
->u_buf
[3]),
7675 byte_swap_32 (pdf
->u_buf
[4]),
7676 byte_swap_32 (pdf
->u_buf
[5]),
7677 byte_swap_32 (pdf
->u_buf
[6]),
7678 byte_swap_32 (pdf
->u_buf
[7]),
7680 byte_swap_32 (pdf
->o_buf
[0]),
7681 byte_swap_32 (pdf
->o_buf
[1]),
7682 byte_swap_32 (pdf
->o_buf
[2]),
7683 byte_swap_32 (pdf
->o_buf
[3]),
7684 byte_swap_32 (pdf
->o_buf
[4]),
7685 byte_swap_32 (pdf
->o_buf
[5]),
7686 byte_swap_32 (pdf
->o_buf
[6]),
7687 byte_swap_32 (pdf
->o_buf
[7])
7690 else if (hash_mode
== 10420)
7692 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7694 pdf_t
*pdf
= &pdfs
[salt_pos
];
7696 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7698 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",
7706 byte_swap_32 (pdf
->id_buf
[0]),
7707 byte_swap_32 (pdf
->id_buf
[1]),
7708 byte_swap_32 (pdf
->id_buf
[2]),
7709 byte_swap_32 (pdf
->id_buf
[3]),
7711 byte_swap_32 (pdf
->u_buf
[0]),
7712 byte_swap_32 (pdf
->u_buf
[1]),
7713 byte_swap_32 (pdf
->u_buf
[2]),
7714 byte_swap_32 (pdf
->u_buf
[3]),
7715 byte_swap_32 (pdf
->u_buf
[4]),
7716 byte_swap_32 (pdf
->u_buf
[5]),
7717 byte_swap_32 (pdf
->u_buf
[6]),
7718 byte_swap_32 (pdf
->u_buf
[7]),
7720 byte_swap_32 (pdf
->o_buf
[0]),
7721 byte_swap_32 (pdf
->o_buf
[1]),
7722 byte_swap_32 (pdf
->o_buf
[2]),
7723 byte_swap_32 (pdf
->o_buf
[3]),
7724 byte_swap_32 (pdf
->o_buf
[4]),
7725 byte_swap_32 (pdf
->o_buf
[5]),
7726 byte_swap_32 (pdf
->o_buf
[6]),
7727 byte_swap_32 (pdf
->o_buf
[7]),
7735 else if (hash_mode
== 10500)
7737 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7739 pdf_t
*pdf
= &pdfs
[salt_pos
];
7741 if (pdf
->id_len
== 32)
7743 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",
7751 byte_swap_32 (pdf
->id_buf
[0]),
7752 byte_swap_32 (pdf
->id_buf
[1]),
7753 byte_swap_32 (pdf
->id_buf
[2]),
7754 byte_swap_32 (pdf
->id_buf
[3]),
7755 byte_swap_32 (pdf
->id_buf
[4]),
7756 byte_swap_32 (pdf
->id_buf
[5]),
7757 byte_swap_32 (pdf
->id_buf
[6]),
7758 byte_swap_32 (pdf
->id_buf
[7]),
7760 byte_swap_32 (pdf
->u_buf
[0]),
7761 byte_swap_32 (pdf
->u_buf
[1]),
7762 byte_swap_32 (pdf
->u_buf
[2]),
7763 byte_swap_32 (pdf
->u_buf
[3]),
7764 byte_swap_32 (pdf
->u_buf
[4]),
7765 byte_swap_32 (pdf
->u_buf
[5]),
7766 byte_swap_32 (pdf
->u_buf
[6]),
7767 byte_swap_32 (pdf
->u_buf
[7]),
7769 byte_swap_32 (pdf
->o_buf
[0]),
7770 byte_swap_32 (pdf
->o_buf
[1]),
7771 byte_swap_32 (pdf
->o_buf
[2]),
7772 byte_swap_32 (pdf
->o_buf
[3]),
7773 byte_swap_32 (pdf
->o_buf
[4]),
7774 byte_swap_32 (pdf
->o_buf
[5]),
7775 byte_swap_32 (pdf
->o_buf
[6]),
7776 byte_swap_32 (pdf
->o_buf
[7])
7781 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",
7789 byte_swap_32 (pdf
->id_buf
[0]),
7790 byte_swap_32 (pdf
->id_buf
[1]),
7791 byte_swap_32 (pdf
->id_buf
[2]),
7792 byte_swap_32 (pdf
->id_buf
[3]),
7794 byte_swap_32 (pdf
->u_buf
[0]),
7795 byte_swap_32 (pdf
->u_buf
[1]),
7796 byte_swap_32 (pdf
->u_buf
[2]),
7797 byte_swap_32 (pdf
->u_buf
[3]),
7798 byte_swap_32 (pdf
->u_buf
[4]),
7799 byte_swap_32 (pdf
->u_buf
[5]),
7800 byte_swap_32 (pdf
->u_buf
[6]),
7801 byte_swap_32 (pdf
->u_buf
[7]),
7803 byte_swap_32 (pdf
->o_buf
[0]),
7804 byte_swap_32 (pdf
->o_buf
[1]),
7805 byte_swap_32 (pdf
->o_buf
[2]),
7806 byte_swap_32 (pdf
->o_buf
[3]),
7807 byte_swap_32 (pdf
->o_buf
[4]),
7808 byte_swap_32 (pdf
->o_buf
[5]),
7809 byte_swap_32 (pdf
->o_buf
[6]),
7810 byte_swap_32 (pdf
->o_buf
[7])
7814 else if (hash_mode
== 10600)
7816 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7818 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7819 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7821 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7823 else if (hash_mode
== 10700)
7825 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7827 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7828 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7830 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7832 else if (hash_mode
== 10900)
7834 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7836 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7837 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7839 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7841 else if (hash_mode
== 11100)
7843 u32 salt_challenge
= salt
.salt_buf
[0];
7845 salt_challenge
= byte_swap_32 (salt_challenge
);
7847 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7849 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7850 SIGNATURE_POSTGRESQL_AUTH
,
7858 else if (hash_mode
== 11200)
7860 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7861 SIGNATURE_MYSQL_AUTH
,
7862 (unsigned char *) salt
.salt_buf
,
7869 else if (hash_mode
== 11300)
7871 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7873 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7875 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7876 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7877 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7879 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7880 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7881 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7883 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7885 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7887 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7890 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7892 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7894 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7897 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7899 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7901 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7904 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7905 SIGNATURE_BITCOIN_WALLET
,
7909 (unsigned char *) salt
.salt_buf
,
7917 free (cry_master_buf
);
7919 free (public_key_buf
);
7921 else if (hash_mode
== 11400)
7923 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7925 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7926 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7928 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7930 else if (hash_mode
== 11600)
7932 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7934 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7936 const uint data_len
= seven_zip
->data_len
;
7938 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7940 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7942 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
7944 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7947 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7948 SIGNATURE_SEVEN_ZIP
,
7952 (char *) seven_zip
->salt_buf
,
7954 seven_zip
->iv_buf
[0],
7955 seven_zip
->iv_buf
[1],
7956 seven_zip
->iv_buf
[2],
7957 seven_zip
->iv_buf
[3],
7959 seven_zip
->data_len
,
7960 seven_zip
->unpack_size
,
7965 else if (hash_mode
== 11700)
7967 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7977 else if (hash_mode
== 11800)
7979 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7997 else if (hash_mode
== 11900)
7999 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8001 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8002 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8004 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8006 else if (hash_mode
== 12000)
8008 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8010 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8011 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8013 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8015 else if (hash_mode
== 12100)
8017 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8019 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8020 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8022 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8024 else if (hash_mode
== 12200)
8026 uint
*ptr_digest
= digest_buf
;
8027 uint
*ptr_salt
= salt
.salt_buf
;
8029 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8036 else if (hash_mode
== 12300)
8038 uint
*ptr_digest
= digest_buf
;
8039 uint
*ptr_salt
= salt
.salt_buf
;
8041 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",
8042 ptr_digest
[ 0], ptr_digest
[ 1],
8043 ptr_digest
[ 2], ptr_digest
[ 3],
8044 ptr_digest
[ 4], ptr_digest
[ 5],
8045 ptr_digest
[ 6], ptr_digest
[ 7],
8046 ptr_digest
[ 8], ptr_digest
[ 9],
8047 ptr_digest
[10], ptr_digest
[11],
8048 ptr_digest
[12], ptr_digest
[13],
8049 ptr_digest
[14], ptr_digest
[15],
8055 else if (hash_mode
== 12400)
8057 // encode iteration count
8059 char salt_iter
[5] = { 0 };
8061 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8062 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8063 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8064 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8069 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8070 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8071 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8072 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8077 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8079 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8080 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8082 memcpy (tmp_buf
, digest_buf
, 8);
8084 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8088 // fill the resulting buffer
8090 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8092 else if (hash_mode
== 12500)
8094 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8096 byte_swap_32 (salt
.salt_buf
[0]),
8097 byte_swap_32 (salt
.salt_buf
[1]),
8103 else if (hash_mode
== 12600)
8105 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8106 digest_buf
[0] + salt
.salt_buf_pc
[0],
8107 digest_buf
[1] + salt
.salt_buf_pc
[1],
8108 digest_buf
[2] + salt
.salt_buf_pc
[2],
8109 digest_buf
[3] + salt
.salt_buf_pc
[3],
8110 digest_buf
[4] + salt
.salt_buf_pc
[4],
8111 digest_buf
[5] + salt
.salt_buf_pc
[5],
8112 digest_buf
[6] + salt
.salt_buf_pc
[6],
8113 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8115 else if (hash_mode
== 12700)
8117 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8119 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8120 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8122 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8124 else if (hash_mode
== 12800)
8126 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8128 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",
8141 byte_swap_32 (digest_buf
[0]),
8142 byte_swap_32 (digest_buf
[1]),
8143 byte_swap_32 (digest_buf
[2]),
8144 byte_swap_32 (digest_buf
[3]),
8145 byte_swap_32 (digest_buf
[4]),
8146 byte_swap_32 (digest_buf
[5]),
8147 byte_swap_32 (digest_buf
[6]),
8148 byte_swap_32 (digest_buf
[7])
8151 else if (hash_mode
== 12900)
8153 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",
8162 byte_swap_32 (digest_buf
[0]),
8163 byte_swap_32 (digest_buf
[1]),
8164 byte_swap_32 (digest_buf
[2]),
8165 byte_swap_32 (digest_buf
[3]),
8166 byte_swap_32 (digest_buf
[4]),
8167 byte_swap_32 (digest_buf
[5]),
8168 byte_swap_32 (digest_buf
[6]),
8169 byte_swap_32 (digest_buf
[7]),
8176 else if (hash_mode
== 13000)
8178 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8180 rar5_t
*rar5
= &rar5s
[salt_pos
];
8182 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8192 byte_swap_32 (digest_buf
[0]),
8193 byte_swap_32 (digest_buf
[1])
8198 if (hash_type
== HASH_TYPE_MD4
)
8200 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8206 else if (hash_type
== HASH_TYPE_MD5
)
8208 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8214 else if (hash_type
== HASH_TYPE_SHA1
)
8216 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8223 else if (hash_type
== HASH_TYPE_SHA256
)
8225 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8235 else if (hash_type
== HASH_TYPE_SHA384
)
8237 uint
*ptr
= digest_buf
;
8239 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8247 else if (hash_type
== HASH_TYPE_SHA512
)
8249 uint
*ptr
= digest_buf
;
8251 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8261 else if (hash_type
== HASH_TYPE_LM
)
8263 snprintf (out_buf
, len
-1, "%08x%08x",
8267 else if (hash_type
== HASH_TYPE_ORACLEH
)
8269 snprintf (out_buf
, len
-1, "%08X%08X",
8273 else if (hash_type
== HASH_TYPE_BCRYPT
)
8275 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8276 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8278 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8280 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8282 else if (hash_type
== HASH_TYPE_KECCAK
)
8284 uint
*ptr
= digest_buf
;
8286 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",
8314 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8316 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8318 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8325 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8327 digest_buf
[ 0] = digest_buf
[ 0];
8328 digest_buf
[ 1] = digest_buf
[ 1];
8329 digest_buf
[ 2] = digest_buf
[ 2];
8330 digest_buf
[ 3] = digest_buf
[ 3];
8331 digest_buf
[ 4] = digest_buf
[ 4];
8332 digest_buf
[ 5] = digest_buf
[ 5];
8333 digest_buf
[ 6] = digest_buf
[ 6];
8334 digest_buf
[ 7] = digest_buf
[ 7];
8335 digest_buf
[ 8] = digest_buf
[ 8];
8336 digest_buf
[ 9] = digest_buf
[ 9];
8337 digest_buf
[10] = digest_buf
[10];
8338 digest_buf
[11] = digest_buf
[11];
8339 digest_buf
[12] = digest_buf
[12];
8340 digest_buf
[13] = digest_buf
[13];
8341 digest_buf
[14] = digest_buf
[14];
8342 digest_buf
[15] = digest_buf
[15];
8344 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8362 else if (hash_type
== HASH_TYPE_GOST
)
8364 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8374 else if (hash_type
== HASH_TYPE_MYSQL
)
8376 snprintf (out_buf
, len
-1, "%08x%08x",
8380 else if (hash_type
== HASH_TYPE_LOTUS5
)
8382 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8388 else if (hash_type
== HASH_TYPE_LOTUS6
)
8390 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8391 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8392 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8393 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8395 char buf
[16] = { 0 };
8397 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8398 memcpy (buf
+ 5, digest_buf
, 9);
8402 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8404 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8407 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8409 else if (hash_type
== HASH_TYPE_LOTUS8
)
8411 char buf
[52] = { 0 };
8415 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8421 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8425 buf
[26] = salt
.salt_buf_pc
[0];
8426 buf
[27] = salt
.salt_buf_pc
[1];
8430 memcpy (buf
+ 28, digest_buf
, 8);
8432 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8436 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8438 else if (hash_type
== HASH_TYPE_CRC32
)
8440 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8444 if (salt_type
== SALT_TYPE_INTERN
)
8446 size_t pos
= strlen (out_buf
);
8448 out_buf
[pos
] = data
.separator
;
8450 char *ptr
= (char *) salt
.salt_buf
;
8452 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8454 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8458 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8460 memset (hccap
, 0, sizeof (hccap_t
));
8462 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8464 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8466 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8467 wpa_t
*wpa
= &wpas
[salt_pos
];
8469 hccap
->keyver
= wpa
->keyver
;
8471 hccap
->eapol_size
= wpa
->eapol_size
;
8473 if (wpa
->keyver
!= 1)
8475 uint eapol_tmp
[64] = { 0 };
8477 for (uint i
= 0; i
< 64; i
++)
8479 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8482 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8486 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8489 uint pke_tmp
[25] = { 0 };
8491 for (int i
= 5; i
< 25; i
++)
8493 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8496 char *pke_ptr
= (char *) pke_tmp
;
8498 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8499 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8500 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8501 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8503 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8505 uint dgst_size
= data
.dgst_size
;
8507 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8509 if (wpa
->keyver
!= 1)
8511 uint digest_tmp
[4] = { 0 };
8513 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8514 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8515 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8516 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8518 memcpy (hccap
->keymic
, digest_tmp
, 16);
8522 memcpy (hccap
->keymic
, digest_ptr
, 16);
8526 void SuspendThreads ()
8528 if (data
.devices_status
== STATUS_RUNNING
)
8530 hc_timer_set (&data
.timer_paused
);
8532 data
.devices_status
= STATUS_PAUSED
;
8534 log_info ("Paused");
8538 void ResumeThreads ()
8540 if (data
.devices_status
== STATUS_PAUSED
)
8544 hc_timer_get (data
.timer_paused
, ms_paused
);
8546 data
.ms_paused
+= ms_paused
;
8548 data
.devices_status
= STATUS_RUNNING
;
8550 log_info ("Resumed");
8556 if (data
.devices_status
!= STATUS_RUNNING
) return;
8558 data
.devices_status
= STATUS_BYPASS
;
8560 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8563 void stop_at_checkpoint ()
8565 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8567 if (data
.devices_status
!= STATUS_RUNNING
) return;
8570 // this feature only makes sense if --restore-disable was not specified
8572 if (data
.restore_disable
== 1)
8574 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8579 // check if monitoring of Restore Point updates should be enabled or disabled
8581 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8583 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8585 // save the current restore point value
8587 data
.checkpoint_cur_words
= get_lowest_words_done ();
8589 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8593 data
.devices_status
= STATUS_RUNNING
;
8595 // reset the global value for checkpoint checks
8597 data
.checkpoint_cur_words
= 0;
8599 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8605 if (data
.devices_status
== STATUS_INIT
) return;
8606 if (data
.devices_status
== STATUS_STARTING
) return;
8608 data
.devices_status
= STATUS_ABORTED
;
8613 if (data
.devices_status
== STATUS_INIT
) return;
8614 if (data
.devices_status
== STATUS_STARTING
) return;
8616 data
.devices_status
= STATUS_QUIT
;
8619 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8621 FILE *fp
= fopen (kernel_file
, "rb");
8627 memset (&st
, 0, sizeof (st
));
8629 stat (kernel_file
, &st
);
8631 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8633 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8635 if (num_read
!= (size_t) st
.st_size
)
8637 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8644 buf
[st
.st_size
] = 0;
8646 for (int i
= 0; i
< num_devices
; i
++)
8648 kernel_lengths
[i
] = (size_t) st
.st_size
;
8650 kernel_sources
[i
] = buf
;
8655 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8663 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8665 if (binary_size
> 0)
8667 FILE *fp
= fopen (dst
, "wb");
8670 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8681 restore_data_t
*init_restore (int argc
, char **argv
)
8683 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8685 if (data
.restore_disable
== 0)
8687 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8691 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8695 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8704 char pidbin
[BUFSIZ
] = { 0 };
8706 int pidbin_len
= -1;
8709 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8711 FILE *fd
= fopen (pidbin
, "rb");
8715 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8717 pidbin
[pidbin_len
] = 0;
8721 char *argv0_r
= strrchr (argv
[0], '/');
8723 char *pidbin_r
= strrchr (pidbin
, '/');
8725 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8727 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8729 if (strcmp (argv0_r
, pidbin_r
) == 0)
8731 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8738 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8740 char pidbin2
[BUFSIZ
] = { 0 };
8742 int pidbin2_len
= -1;
8744 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8745 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8747 pidbin
[pidbin_len
] = 0;
8748 pidbin2
[pidbin2_len
] = 0;
8752 if (strcmp (pidbin
, pidbin2
) == 0)
8754 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8762 if (rd
->version_bin
< RESTORE_MIN
)
8764 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8771 memset (rd
, 0, sizeof (restore_data_t
));
8773 rd
->version_bin
= VERSION_BIN
;
8776 rd
->pid
= getpid ();
8778 rd
->pid
= GetCurrentProcessId ();
8781 if (getcwd (rd
->cwd
, 255) == NULL
)
8794 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8796 FILE *fp
= fopen (eff_restore_file
, "rb");
8800 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8805 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8807 log_error ("ERROR: cannot read %s", eff_restore_file
);
8812 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8814 for (uint i
= 0; i
< rd
->argc
; i
++)
8816 char buf
[BUFSIZ
] = { 0 };
8818 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8820 log_error ("ERROR: cannot read %s", eff_restore_file
);
8825 size_t len
= strlen (buf
);
8827 if (len
) buf
[len
- 1] = 0;
8829 rd
->argv
[i
] = mystrdup (buf
);
8834 char new_cwd
[1024] = { 0 };
8836 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8840 log_error ("Restore file is corrupted");
8843 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8845 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8847 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8852 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8855 if (chdir (rd
->cwd
))
8857 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8863 u64
get_lowest_words_done ()
8867 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8869 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8871 if (device_param
->skipped
) continue;
8873 const u64 words_done
= device_param
->words_done
;
8875 if (words_done
< words_cur
) words_cur
= words_done
;
8878 // It's possible that a device's workload isn't finished right after a restore-case.
8879 // In that case, this function would return 0 and overwrite the real restore point
8880 // There's also data.words_cur which is set to rd->words_cur but it changes while
8881 // the attack is running therefore we should stick to rd->words_cur.
8882 // Note that -s influences rd->words_cur we should keep a close look on that.
8884 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8889 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8891 u64 words_cur
= get_lowest_words_done ();
8893 rd
->words_cur
= words_cur
;
8895 FILE *fp
= fopen (new_restore_file
, "wb");
8899 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8904 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8906 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8911 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8913 for (uint i
= 0; i
< rd
->argc
; i
++)
8915 fprintf (fp
, "%s", rd
->argv
[i
]);
8921 fsync (fileno (fp
));
8926 void cycle_restore ()
8928 const char *eff_restore_file
= data
.eff_restore_file
;
8929 const char *new_restore_file
= data
.new_restore_file
;
8931 restore_data_t
*rd
= data
.rd
;
8933 write_restore (new_restore_file
, rd
);
8937 memset (&st
, 0, sizeof(st
));
8939 if (stat (eff_restore_file
, &st
) == 0)
8941 if (unlink (eff_restore_file
))
8943 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8947 if (rename (new_restore_file
, eff_restore_file
))
8949 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8953 void check_checkpoint ()
8955 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8957 u64 words_cur
= get_lowest_words_done ();
8959 if (words_cur
!= data
.checkpoint_cur_words
)
8969 uint
set_kernel_accel (uint hash_mode
)
8973 case 0: return GET_ACCEL (0);
8974 case 10: return GET_ACCEL (10);
8975 case 11: return GET_ACCEL (11);
8976 case 12: return GET_ACCEL (12);
8977 case 20: return GET_ACCEL (20);
8978 case 21: return GET_ACCEL (21);
8979 case 22: return GET_ACCEL (22);
8980 case 23: return GET_ACCEL (23);
8981 case 30: return GET_ACCEL (30);
8982 case 40: return GET_ACCEL (40);
8983 case 50: return GET_ACCEL (50);
8984 case 60: return GET_ACCEL (60);
8985 case 100: return GET_ACCEL (100);
8986 case 101: return GET_ACCEL (101);
8987 case 110: return GET_ACCEL (110);
8988 case 111: return GET_ACCEL (111);
8989 case 112: return GET_ACCEL (112);
8990 case 120: return GET_ACCEL (120);
8991 case 121: return GET_ACCEL (121);
8992 case 122: return GET_ACCEL (122);
8993 case 124: return GET_ACCEL (124);
8994 case 130: return GET_ACCEL (130);
8995 case 131: return GET_ACCEL (131);
8996 case 132: return GET_ACCEL (132);
8997 case 133: return GET_ACCEL (133);
8998 case 140: return GET_ACCEL (140);
8999 case 141: return GET_ACCEL (141);
9000 case 150: return GET_ACCEL (150);
9001 case 160: return GET_ACCEL (160);
9002 case 190: return GET_ACCEL (190);
9003 case 200: return GET_ACCEL (200);
9004 case 300: return GET_ACCEL (300);
9005 case 400: return GET_ACCEL (400);
9006 case 500: return GET_ACCEL (500);
9007 case 501: return GET_ACCEL (501);
9008 case 900: return GET_ACCEL (900);
9009 case 910: return GET_ACCEL (910);
9010 case 1000: return GET_ACCEL (1000);
9011 case 1100: return GET_ACCEL (1100);
9012 case 1400: return GET_ACCEL (1400);
9013 case 1410: return GET_ACCEL (1410);
9014 case 1420: return GET_ACCEL (1420);
9015 case 1421: return GET_ACCEL (1421);
9016 case 1430: return GET_ACCEL (1430);
9017 case 1440: return GET_ACCEL (1440);
9018 case 1441: return GET_ACCEL (1441);
9019 case 1450: return GET_ACCEL (1450);
9020 case 1460: return GET_ACCEL (1460);
9021 case 1500: return GET_ACCEL (1500);
9022 case 1600: return GET_ACCEL (1600);
9023 case 1700: return GET_ACCEL (1700);
9024 case 1710: return GET_ACCEL (1710);
9025 case 1711: return GET_ACCEL (1711);
9026 case 1720: return GET_ACCEL (1720);
9027 case 1722: return GET_ACCEL (1722);
9028 case 1730: return GET_ACCEL (1730);
9029 case 1731: return GET_ACCEL (1731);
9030 case 1740: return GET_ACCEL (1740);
9031 case 1750: return GET_ACCEL (1750);
9032 case 1760: return GET_ACCEL (1760);
9033 case 1800: return GET_ACCEL (1800);
9034 case 2100: return GET_ACCEL (2100);
9035 case 2400: return GET_ACCEL (2400);
9036 case 2410: return GET_ACCEL (2410);
9037 case 2500: return GET_ACCEL (2500);
9038 case 2600: return GET_ACCEL (2600);
9039 case 2611: return GET_ACCEL (2611);
9040 case 2612: return GET_ACCEL (2612);
9041 case 2711: return GET_ACCEL (2711);
9042 case 2811: return GET_ACCEL (2811);
9043 case 3000: return GET_ACCEL (3000);
9044 case 3100: return GET_ACCEL (3100);
9045 case 3200: return GET_ACCEL (3200);
9046 case 3710: return GET_ACCEL (3710);
9047 case 3711: return GET_ACCEL (3711);
9048 case 3800: return GET_ACCEL (3800);
9049 case 4300: return GET_ACCEL (4300);
9050 case 4400: return GET_ACCEL (4400);
9051 case 4500: return GET_ACCEL (4500);
9052 case 4700: return GET_ACCEL (4700);
9053 case 4800: return GET_ACCEL (4800);
9054 case 4900: return GET_ACCEL (4900);
9055 case 5000: return GET_ACCEL (5000);
9056 case 5100: return GET_ACCEL (5100);
9057 case 5200: return GET_ACCEL (5200);
9058 case 5300: return GET_ACCEL (5300);
9059 case 5400: return GET_ACCEL (5400);
9060 case 5500: return GET_ACCEL (5500);
9061 case 5600: return GET_ACCEL (5600);
9062 case 5700: return GET_ACCEL (5700);
9063 case 5800: return GET_ACCEL (5800);
9064 case 6000: return GET_ACCEL (6000);
9065 case 6100: return GET_ACCEL (6100);
9066 case 6211: return GET_ACCEL (6211);
9067 case 6212: return GET_ACCEL (6212);
9068 case 6213: return GET_ACCEL (6213);
9069 case 6221: return GET_ACCEL (6221);
9070 case 6222: return GET_ACCEL (6222);
9071 case 6223: return GET_ACCEL (6223);
9072 case 6231: return GET_ACCEL (6231);
9073 case 6232: return GET_ACCEL (6232);
9074 case 6233: return GET_ACCEL (6233);
9075 case 6241: return GET_ACCEL (6241);
9076 case 6242: return GET_ACCEL (6242);
9077 case 6243: return GET_ACCEL (6243);
9078 case 6300: return GET_ACCEL (6300);
9079 case 6400: return GET_ACCEL (6400);
9080 case 6500: return GET_ACCEL (6500);
9081 case 6600: return GET_ACCEL (6600);
9082 case 6700: return GET_ACCEL (6700);
9083 case 6800: return GET_ACCEL (6800);
9084 case 6900: return GET_ACCEL (6900);
9085 case 7100: return GET_ACCEL (7100);
9086 case 7200: return GET_ACCEL (7200);
9087 case 7300: return GET_ACCEL (7300);
9088 case 7400: return GET_ACCEL (7400);
9089 case 7500: return GET_ACCEL (7500);
9090 case 7600: return GET_ACCEL (7600);
9091 case 7700: return GET_ACCEL (7700);
9092 case 7800: return GET_ACCEL (7800);
9093 case 7900: return GET_ACCEL (7900);
9094 case 8000: return GET_ACCEL (8000);
9095 case 8100: return GET_ACCEL (8100);
9096 case 8200: return GET_ACCEL (8200);
9097 case 8300: return GET_ACCEL (8300);
9098 case 8400: return GET_ACCEL (8400);
9099 case 8500: return GET_ACCEL (8500);
9100 case 8600: return GET_ACCEL (8600);
9101 case 8700: return GET_ACCEL (8700);
9102 case 8800: return GET_ACCEL (8800);
9103 case 8900: return GET_ACCEL (8900);
9104 case 9000: return GET_ACCEL (9000);
9105 case 9100: return GET_ACCEL (9100);
9106 case 9200: return GET_ACCEL (9200);
9107 case 9300: return GET_ACCEL (9300);
9108 case 9400: return GET_ACCEL (9400);
9109 case 9500: return GET_ACCEL (9500);
9110 case 9600: return GET_ACCEL (9600);
9111 case 9700: return GET_ACCEL (9700);
9112 case 9710: return GET_ACCEL (9710);
9113 case 9720: return GET_ACCEL (9720);
9114 case 9800: return GET_ACCEL (9800);
9115 case 9810: return GET_ACCEL (9810);
9116 case 9820: return GET_ACCEL (9820);
9117 case 9900: return GET_ACCEL (9900);
9118 case 10000: return GET_ACCEL (10000);
9119 case 10100: return GET_ACCEL (10100);
9120 case 10200: return GET_ACCEL (10200);
9121 case 10300: return GET_ACCEL (10300);
9122 case 10400: return GET_ACCEL (10400);
9123 case 10410: return GET_ACCEL (10410);
9124 case 10420: return GET_ACCEL (10420);
9125 case 10500: return GET_ACCEL (10500);
9126 case 10600: return GET_ACCEL (10600);
9127 case 10700: return GET_ACCEL (10700);
9128 case 10800: return GET_ACCEL (10800);
9129 case 10900: return GET_ACCEL (10900);
9130 case 11000: return GET_ACCEL (11000);
9131 case 11100: return GET_ACCEL (11100);
9132 case 11200: return GET_ACCEL (11200);
9133 case 11300: return GET_ACCEL (11300);
9134 case 11400: return GET_ACCEL (11400);
9135 case 11500: return GET_ACCEL (11500);
9136 case 11600: return GET_ACCEL (11600);
9137 case 11700: return GET_ACCEL (11700);
9138 case 11800: return GET_ACCEL (11800);
9139 case 11900: return GET_ACCEL (11900);
9140 case 12000: return GET_ACCEL (12000);
9141 case 12100: return GET_ACCEL (12100);
9142 case 12200: return GET_ACCEL (12200);
9143 case 12300: return GET_ACCEL (12300);
9144 case 12400: return GET_ACCEL (12400);
9145 case 12500: return GET_ACCEL (12500);
9146 case 12600: return GET_ACCEL (12600);
9147 case 12700: return GET_ACCEL (12700);
9148 case 12800: return GET_ACCEL (12800);
9149 case 12900: return GET_ACCEL (12900);
9150 case 13000: return GET_ACCEL (13000);
9156 uint
set_kernel_loops (uint hash_mode
)
9160 case 0: return GET_LOOPS (0);
9161 case 10: return GET_LOOPS (10);
9162 case 11: return GET_LOOPS (11);
9163 case 12: return GET_LOOPS (12);
9164 case 20: return GET_LOOPS (20);
9165 case 21: return GET_LOOPS (21);
9166 case 22: return GET_LOOPS (22);
9167 case 23: return GET_LOOPS (23);
9168 case 30: return GET_LOOPS (30);
9169 case 40: return GET_LOOPS (40);
9170 case 50: return GET_LOOPS (50);
9171 case 60: return GET_LOOPS (60);
9172 case 100: return GET_LOOPS (100);
9173 case 101: return GET_LOOPS (101);
9174 case 110: return GET_LOOPS (110);
9175 case 111: return GET_LOOPS (111);
9176 case 112: return GET_LOOPS (112);
9177 case 120: return GET_LOOPS (120);
9178 case 121: return GET_LOOPS (121);
9179 case 122: return GET_LOOPS (122);
9180 case 124: return GET_LOOPS (124);
9181 case 130: return GET_LOOPS (130);
9182 case 131: return GET_LOOPS (131);
9183 case 132: return GET_LOOPS (132);
9184 case 133: return GET_LOOPS (133);
9185 case 140: return GET_LOOPS (140);
9186 case 141: return GET_LOOPS (141);
9187 case 150: return GET_LOOPS (150);
9188 case 160: return GET_LOOPS (160);
9189 case 190: return GET_LOOPS (190);
9190 case 200: return GET_LOOPS (200);
9191 case 300: return GET_LOOPS (300);
9192 case 400: return GET_LOOPS (400);
9193 case 500: return GET_LOOPS (500);
9194 case 501: return GET_LOOPS (501);
9195 case 900: return GET_LOOPS (900);
9196 case 910: return GET_LOOPS (910);
9197 case 1000: return GET_LOOPS (1000);
9198 case 1100: return GET_LOOPS (1100);
9199 case 1400: return GET_LOOPS (1400);
9200 case 1410: return GET_LOOPS (1410);
9201 case 1420: return GET_LOOPS (1420);
9202 case 1421: return GET_LOOPS (1421);
9203 case 1430: return GET_LOOPS (1430);
9204 case 1440: return GET_LOOPS (1440);
9205 case 1441: return GET_LOOPS (1441);
9206 case 1450: return GET_LOOPS (1450);
9207 case 1460: return GET_LOOPS (1460);
9208 case 1500: return GET_LOOPS (1500);
9209 case 1600: return GET_LOOPS (1600);
9210 case 1700: return GET_LOOPS (1700);
9211 case 1710: return GET_LOOPS (1710);
9212 case 1711: return GET_LOOPS (1711);
9213 case 1720: return GET_LOOPS (1720);
9214 case 1722: return GET_LOOPS (1722);
9215 case 1730: return GET_LOOPS (1730);
9216 case 1731: return GET_LOOPS (1731);
9217 case 1740: return GET_LOOPS (1740);
9218 case 1750: return GET_LOOPS (1750);
9219 case 1760: return GET_LOOPS (1760);
9220 case 1800: return GET_LOOPS (1800);
9221 case 2100: return GET_LOOPS (2100);
9222 case 2400: return GET_LOOPS (2400);
9223 case 2410: return GET_LOOPS (2410);
9224 case 2500: return GET_LOOPS (2500);
9225 case 2600: return GET_LOOPS (2600);
9226 case 2611: return GET_LOOPS (2611);
9227 case 2612: return GET_LOOPS (2612);
9228 case 2711: return GET_LOOPS (2711);
9229 case 2811: return GET_LOOPS (2811);
9230 case 3000: return GET_LOOPS (3000);
9231 case 3100: return GET_LOOPS (3100);
9232 case 3200: return GET_LOOPS (3200);
9233 case 3710: return GET_LOOPS (3710);
9234 case 3711: return GET_LOOPS (3711);
9235 case 3800: return GET_LOOPS (3800);
9236 case 4300: return GET_LOOPS (4300);
9237 case 4400: return GET_LOOPS (4400);
9238 case 4500: return GET_LOOPS (4500);
9239 case 4700: return GET_LOOPS (4700);
9240 case 4800: return GET_LOOPS (4800);
9241 case 4900: return GET_LOOPS (4900);
9242 case 5000: return GET_LOOPS (5000);
9243 case 5100: return GET_LOOPS (5100);
9244 case 5200: return GET_LOOPS (5200);
9245 case 5300: return GET_LOOPS (5300);
9246 case 5400: return GET_LOOPS (5400);
9247 case 5500: return GET_LOOPS (5500);
9248 case 5600: return GET_LOOPS (5600);
9249 case 5700: return GET_LOOPS (5700);
9250 case 5800: return GET_LOOPS (5800);
9251 case 6000: return GET_LOOPS (6000);
9252 case 6100: return GET_LOOPS (6100);
9253 case 6211: return GET_LOOPS (6211);
9254 case 6212: return GET_LOOPS (6212);
9255 case 6213: return GET_LOOPS (6213);
9256 case 6221: return GET_LOOPS (6221);
9257 case 6222: return GET_LOOPS (6222);
9258 case 6223: return GET_LOOPS (6223);
9259 case 6231: return GET_LOOPS (6231);
9260 case 6232: return GET_LOOPS (6232);
9261 case 6233: return GET_LOOPS (6233);
9262 case 6241: return GET_LOOPS (6241);
9263 case 6242: return GET_LOOPS (6242);
9264 case 6243: return GET_LOOPS (6243);
9265 case 6300: return GET_LOOPS (6300);
9266 case 6400: return GET_LOOPS (6400);
9267 case 6500: return GET_LOOPS (6500);
9268 case 6600: return GET_LOOPS (6600);
9269 case 6700: return GET_LOOPS (6700);
9270 case 6800: return GET_LOOPS (6800);
9271 case 6900: return GET_LOOPS (6900);
9272 case 7100: return GET_LOOPS (7100);
9273 case 7200: return GET_LOOPS (7200);
9274 case 7300: return GET_LOOPS (7300);
9275 case 7400: return GET_LOOPS (7400);
9276 case 7500: return GET_LOOPS (7500);
9277 case 7600: return GET_LOOPS (7600);
9278 case 7700: return GET_LOOPS (7700);
9279 case 7800: return GET_LOOPS (7800);
9280 case 7900: return GET_LOOPS (7900);
9281 case 8000: return GET_LOOPS (8000);
9282 case 8100: return GET_LOOPS (8100);
9283 case 8200: return GET_LOOPS (8200);
9284 case 8300: return GET_LOOPS (8300);
9285 case 8400: return GET_LOOPS (8400);
9286 case 8500: return GET_LOOPS (8500);
9287 case 8600: return GET_LOOPS (8600);
9288 case 8700: return GET_LOOPS (8700);
9289 case 8800: return GET_LOOPS (8800);
9290 case 8900: return GET_LOOPS (8900);
9291 case 9000: return GET_LOOPS (9000);
9292 case 9100: return GET_LOOPS (9100);
9293 case 9200: return GET_LOOPS (9200);
9294 case 9300: return GET_LOOPS (9300);
9295 case 9400: return GET_LOOPS (9400);
9296 case 9500: return GET_LOOPS (9500);
9297 case 9600: return GET_LOOPS (9600);
9298 case 9700: return GET_LOOPS (9700);
9299 case 9710: return GET_LOOPS (9710);
9300 case 9720: return GET_LOOPS (9720);
9301 case 9800: return GET_LOOPS (9800);
9302 case 9810: return GET_LOOPS (9810);
9303 case 9820: return GET_LOOPS (9820);
9304 case 9900: return GET_LOOPS (9900);
9305 case 10000: return GET_LOOPS (10000);
9306 case 10100: return GET_LOOPS (10100);
9307 case 10200: return GET_LOOPS (10200);
9308 case 10300: return GET_LOOPS (10300);
9309 case 10400: return GET_LOOPS (10400);
9310 case 10410: return GET_LOOPS (10410);
9311 case 10420: return GET_LOOPS (10420);
9312 case 10500: return GET_LOOPS (10500);
9313 case 10600: return GET_LOOPS (10600);
9314 case 10700: return GET_LOOPS (10700);
9315 case 10800: return GET_LOOPS (10800);
9316 case 10900: return GET_LOOPS (10900);
9317 case 11000: return GET_LOOPS (11000);
9318 case 11100: return GET_LOOPS (11100);
9319 case 11200: return GET_LOOPS (11200);
9320 case 11300: return GET_LOOPS (11300);
9321 case 11400: return GET_LOOPS (11400);
9322 case 11500: return GET_LOOPS (11500);
9323 case 11600: return GET_LOOPS (11600);
9324 case 11700: return GET_LOOPS (11700);
9325 case 11800: return GET_LOOPS (11800);
9326 case 11900: return GET_LOOPS (11900);
9327 case 12000: return GET_LOOPS (12000);
9328 case 12100: return GET_LOOPS (12100);
9329 case 12200: return GET_LOOPS (12200);
9330 case 12300: return GET_LOOPS (12300);
9331 case 12400: return GET_LOOPS (12400);
9332 case 12500: return GET_LOOPS (12500);
9333 case 12600: return GET_LOOPS (12600);
9334 case 12700: return GET_LOOPS (12700);
9335 case 12800: return GET_LOOPS (12800);
9336 case 12900: return GET_LOOPS (12900);
9337 case 13000: return GET_LOOPS (13000);
9347 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9349 u8 tmp
[256] = { 0 };
9351 if (salt_len
> sizeof (tmp
))
9356 memcpy (tmp
, in
, salt_len
);
9358 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9360 if ((salt_len
% 2) == 0)
9362 u32 new_salt_len
= salt_len
/ 2;
9364 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9369 tmp
[i
] = hex_convert (p1
) << 0;
9370 tmp
[i
] |= hex_convert (p0
) << 4;
9373 salt_len
= new_salt_len
;
9380 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9382 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9385 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9387 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9391 u32
*tmp_uint
= (u32
*) tmp
;
9393 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9394 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9395 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9396 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9397 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9398 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9399 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9400 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9401 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9402 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9404 salt_len
= salt_len
* 2;
9412 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9414 lowercase (tmp
, salt_len
);
9417 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9419 uppercase (tmp
, salt_len
);
9424 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9429 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9434 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9436 u32
*tmp_uint
= (uint
*) tmp
;
9442 for (u32 i
= 0; i
< max
; i
++)
9444 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9447 // Important: we may need to increase the length of memcpy since
9448 // we don't want to "loose" some swapped bytes (could happen if
9449 // they do not perfectly fit in the 4-byte blocks)
9450 // Memcpy does always copy the bytes in the BE order, but since
9451 // we swapped them, some important bytes could be in positions
9452 // we normally skip with the original len
9454 if (len
% 4) len
+= 4 - (len
% 4);
9457 memcpy (out
, tmp
, len
);
9462 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9464 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9466 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9468 u32
*digest
= (u32
*) hash_buf
->digest
;
9470 salt_t
*salt
= hash_buf
->salt
;
9472 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9474 char *iter_pos
= input_buf
+ 4;
9476 salt
->salt_iter
= 1 << atoi (iter_pos
);
9478 char *salt_pos
= strchr (iter_pos
, '$');
9480 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9486 salt
->salt_len
= salt_len
;
9488 u8 tmp_buf
[100] = { 0 };
9490 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9492 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9494 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9496 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9497 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9498 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9499 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9501 char *hash_pos
= salt_pos
+ 22;
9503 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9505 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9507 memcpy (digest
, tmp_buf
, 24);
9509 digest
[0] = byte_swap_32 (digest
[0]);
9510 digest
[1] = byte_swap_32 (digest
[1]);
9511 digest
[2] = byte_swap_32 (digest
[2]);
9512 digest
[3] = byte_swap_32 (digest
[3]);
9513 digest
[4] = byte_swap_32 (digest
[4]);
9514 digest
[5] = byte_swap_32 (digest
[5]);
9516 digest
[5] &= ~0xff; // its just 23 not 24 !
9521 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9523 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9525 u32
*digest
= (u32
*) hash_buf
->digest
;
9527 u8 tmp_buf
[100] = { 0 };
9529 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9531 memcpy (digest
, tmp_buf
, 32);
9533 digest
[0] = byte_swap_32 (digest
[0]);
9534 digest
[1] = byte_swap_32 (digest
[1]);
9535 digest
[2] = byte_swap_32 (digest
[2]);
9536 digest
[3] = byte_swap_32 (digest
[3]);
9537 digest
[4] = byte_swap_32 (digest
[4]);
9538 digest
[5] = byte_swap_32 (digest
[5]);
9539 digest
[6] = byte_swap_32 (digest
[6]);
9540 digest
[7] = byte_swap_32 (digest
[7]);
9542 digest
[0] -= SHA256M_A
;
9543 digest
[1] -= SHA256M_B
;
9544 digest
[2] -= SHA256M_C
;
9545 digest
[3] -= SHA256M_D
;
9546 digest
[4] -= SHA256M_E
;
9547 digest
[5] -= SHA256M_F
;
9548 digest
[6] -= SHA256M_G
;
9549 digest
[7] -= SHA256M_H
;
9554 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9556 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9558 u32
*digest
= (u32
*) hash_buf
->digest
;
9560 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9561 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9563 digest
[0] = byte_swap_32 (digest
[0]);
9564 digest
[1] = byte_swap_32 (digest
[1]);
9568 IP (digest
[0], digest
[1], tt
);
9570 digest
[0] = digest
[0];
9571 digest
[1] = digest
[1];
9578 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9580 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9582 u32
*digest
= (u32
*) hash_buf
->digest
;
9584 salt_t
*salt
= hash_buf
->salt
;
9586 char *hash_pos
= input_buf
+ 8;
9588 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9589 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9590 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9591 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9592 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9594 digest
[0] -= SHA1M_A
;
9595 digest
[1] -= SHA1M_B
;
9596 digest
[2] -= SHA1M_C
;
9597 digest
[3] -= SHA1M_D
;
9598 digest
[4] -= SHA1M_E
;
9602 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9604 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9606 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9608 salt
->salt_len
= salt_len
;
9613 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9615 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9617 u64
*digest
= (u64
*) hash_buf
->digest
;
9619 salt_t
*salt
= hash_buf
->salt
;
9621 char *hash_pos
= input_buf
+ 8;
9623 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9624 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9625 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9626 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9627 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9628 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9629 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9630 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9632 digest
[0] -= SHA512M_A
;
9633 digest
[1] -= SHA512M_B
;
9634 digest
[2] -= SHA512M_C
;
9635 digest
[3] -= SHA512M_D
;
9636 digest
[4] -= SHA512M_E
;
9637 digest
[5] -= SHA512M_F
;
9638 digest
[6] -= SHA512M_G
;
9639 digest
[7] -= SHA512M_H
;
9643 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9645 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9647 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9649 salt
->salt_len
= salt_len
;
9654 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9656 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9658 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9662 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9665 u32
*digest
= (u32
*) hash_buf
->digest
;
9667 salt_t
*salt
= hash_buf
->salt
;
9669 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9670 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9671 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9672 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9674 digest
[0] = byte_swap_32 (digest
[0]);
9675 digest
[1] = byte_swap_32 (digest
[1]);
9676 digest
[2] = byte_swap_32 (digest
[2]);
9677 digest
[3] = byte_swap_32 (digest
[3]);
9679 digest
[0] -= MD5M_A
;
9680 digest
[1] -= MD5M_B
;
9681 digest
[2] -= MD5M_C
;
9682 digest
[3] -= MD5M_D
;
9684 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9686 uint salt_len
= input_len
- 32 - 1;
9688 char *salt_buf
= input_buf
+ 32 + 1;
9690 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9692 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9694 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9696 salt
->salt_len
= salt_len
;
9701 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9703 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9705 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9709 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9714 char clean_input_buf
[32] = { 0 };
9716 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9717 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9719 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9723 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9729 clean_input_buf
[k
] = input_buf
[i
];
9737 u32
*digest
= (u32
*) hash_buf
->digest
;
9739 salt_t
*salt
= hash_buf
->salt
;
9741 u32 a
, b
, c
, d
, e
, f
;
9743 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9744 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9745 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9746 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9747 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9748 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9750 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9751 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9753 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9754 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9755 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9756 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9757 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9758 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9760 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9761 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9763 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9764 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9765 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9766 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9767 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9768 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9770 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9771 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9773 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9774 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9775 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9776 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9777 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9778 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9780 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9781 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9783 digest
[0] = byte_swap_32 (digest
[0]);
9784 digest
[1] = byte_swap_32 (digest
[1]);
9785 digest
[2] = byte_swap_32 (digest
[2]);
9786 digest
[3] = byte_swap_32 (digest
[3]);
9788 digest
[0] -= MD5M_A
;
9789 digest
[1] -= MD5M_B
;
9790 digest
[2] -= MD5M_C
;
9791 digest
[3] -= MD5M_D
;
9793 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9795 uint salt_len
= input_len
- 30 - 1;
9797 char *salt_buf
= input_buf
+ 30 + 1;
9799 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9801 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9803 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9804 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9806 salt
->salt_len
= salt_len
;
9808 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9810 salt
->salt_len
+= 22;
9815 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9817 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9819 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9823 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9826 u32
*digest
= (u32
*) hash_buf
->digest
;
9828 salt_t
*salt
= hash_buf
->salt
;
9830 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9831 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9832 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9833 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9834 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9836 digest
[0] -= SHA1M_A
;
9837 digest
[1] -= SHA1M_B
;
9838 digest
[2] -= SHA1M_C
;
9839 digest
[3] -= SHA1M_D
;
9840 digest
[4] -= SHA1M_E
;
9842 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9844 uint salt_len
= input_len
- 40 - 1;
9846 char *salt_buf
= input_buf
+ 40 + 1;
9848 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9850 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9852 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9854 salt
->salt_len
= salt_len
;
9859 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9861 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9863 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9867 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9870 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9872 char *iter_pos
= input_buf
+ 6;
9874 salt_t
*salt
= hash_buf
->salt
;
9876 uint iter
= atoi (iter_pos
);
9883 salt
->salt_iter
= iter
- 1;
9885 char *salt_pos
= strchr (iter_pos
, '#');
9887 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9891 char *digest_pos
= strchr (salt_pos
, '#');
9893 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9897 uint salt_len
= digest_pos
- salt_pos
- 1;
9899 u32
*digest
= (u32
*) hash_buf
->digest
;
9901 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9902 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9903 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9904 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9906 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9908 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9910 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9912 salt
->salt_len
= salt_len
;
9917 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9919 u32
*digest
= (u32
*) hash_buf
->digest
;
9921 salt_t
*salt
= hash_buf
->salt
;
9923 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9927 memcpy (&in
, input_buf
, input_len
);
9929 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9931 memcpy (digest
, in
.keymic
, 16);
9934 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9935 The phrase "Pairwise key expansion"
9936 Access Point Address (referred to as Authenticator Address AA)
9937 Supplicant Address (referred to as Supplicant Address SA)
9938 Access Point Nonce (referred to as Authenticator Anonce)
9939 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9942 uint salt_len
= strlen (in
.essid
);
9944 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9946 salt
->salt_len
= salt_len
;
9948 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9950 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9952 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9954 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9956 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9957 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9961 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9962 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9965 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9967 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9968 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9972 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9973 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9976 for (int i
= 0; i
< 25; i
++)
9978 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9981 wpa
->keyver
= in
.keyver
;
9983 if (wpa
->keyver
> 255)
9985 log_info ("ATTENTION!");
9986 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9987 log_info (" This could be due to a recent aircrack-ng bug.");
9988 log_info (" The key version was automatically reset to a reasonable value.");
9991 wpa
->keyver
&= 0xff;
9994 wpa
->eapol_size
= in
.eapol_size
;
9996 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
9998 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10000 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10002 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10004 if (wpa
->keyver
== 1)
10010 digest
[0] = byte_swap_32 (digest
[0]);
10011 digest
[1] = byte_swap_32 (digest
[1]);
10012 digest
[2] = byte_swap_32 (digest
[2]);
10013 digest
[3] = byte_swap_32 (digest
[3]);
10015 for (int i
= 0; i
< 64; i
++)
10017 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10021 salt
->salt_buf
[10] = digest
[1];
10022 salt
->salt_buf
[11] = digest
[2];
10024 return (PARSER_OK
);
10027 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10029 u32
*digest
= (u32
*) hash_buf
->digest
;
10031 salt_t
*salt
= hash_buf
->salt
;
10033 if (input_len
== 0)
10035 log_error ("Password Safe v2 container not specified");
10040 FILE *fp
= fopen (input_buf
, "rb");
10044 log_error ("%s: %s", input_buf
, strerror (errno
));
10051 memset (&buf
, 0, sizeof (psafe2_hdr
));
10053 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10057 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10059 salt
->salt_buf
[0] = buf
.random
[0];
10060 salt
->salt_buf
[1] = buf
.random
[1];
10062 salt
->salt_len
= 8;
10063 salt
->salt_iter
= 1000;
10065 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10066 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10067 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10068 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10069 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10071 return (PARSER_OK
);
10074 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10076 u32
*digest
= (u32
*) hash_buf
->digest
;
10078 salt_t
*salt
= hash_buf
->salt
;
10080 if (input_len
== 0)
10082 log_error (".psafe3 not specified");
10087 FILE *fp
= fopen (input_buf
, "rb");
10091 log_error ("%s: %s", input_buf
, strerror (errno
));
10098 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10102 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10104 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10106 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10108 salt
->salt_iter
= in
.iterations
+ 1;
10110 salt
->salt_buf
[0] = in
.salt_buf
[0];
10111 salt
->salt_buf
[1] = in
.salt_buf
[1];
10112 salt
->salt_buf
[2] = in
.salt_buf
[2];
10113 salt
->salt_buf
[3] = in
.salt_buf
[3];
10114 salt
->salt_buf
[4] = in
.salt_buf
[4];
10115 salt
->salt_buf
[5] = in
.salt_buf
[5];
10116 salt
->salt_buf
[6] = in
.salt_buf
[6];
10117 salt
->salt_buf
[7] = in
.salt_buf
[7];
10119 salt
->salt_len
= 32;
10121 digest
[0] = in
.hash_buf
[0];
10122 digest
[1] = in
.hash_buf
[1];
10123 digest
[2] = in
.hash_buf
[2];
10124 digest
[3] = in
.hash_buf
[3];
10125 digest
[4] = in
.hash_buf
[4];
10126 digest
[5] = in
.hash_buf
[5];
10127 digest
[6] = in
.hash_buf
[6];
10128 digest
[7] = in
.hash_buf
[7];
10130 digest
[0] = byte_swap_32 (digest
[0]);
10131 digest
[1] = byte_swap_32 (digest
[1]);
10132 digest
[2] = byte_swap_32 (digest
[2]);
10133 digest
[3] = byte_swap_32 (digest
[3]);
10134 digest
[4] = byte_swap_32 (digest
[4]);
10135 digest
[5] = byte_swap_32 (digest
[5]);
10136 digest
[6] = byte_swap_32 (digest
[6]);
10137 digest
[7] = byte_swap_32 (digest
[7]);
10139 return (PARSER_OK
);
10142 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10144 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10146 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10148 u32
*digest
= (u32
*) hash_buf
->digest
;
10150 salt_t
*salt
= hash_buf
->salt
;
10152 char *iter_pos
= input_buf
+ 3;
10154 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10156 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10158 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10160 salt
->salt_iter
= salt_iter
;
10162 char *salt_pos
= iter_pos
+ 1;
10166 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10168 salt
->salt_len
= salt_len
;
10170 char *hash_pos
= salt_pos
+ salt_len
;
10172 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10174 return (PARSER_OK
);
10177 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10179 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10181 u32
*digest
= (u32
*) hash_buf
->digest
;
10183 salt_t
*salt
= hash_buf
->salt
;
10185 char *salt_pos
= input_buf
+ 3;
10187 uint iterations_len
= 0;
10189 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10193 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10195 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10196 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10200 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10204 iterations_len
+= 8;
10208 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10211 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10213 char *hash_pos
= strchr (salt_pos
, '$');
10215 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10217 uint salt_len
= hash_pos
- salt_pos
;
10219 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10221 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10223 salt
->salt_len
= salt_len
;
10227 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10229 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10231 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10233 return (PARSER_OK
);
10236 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10238 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10240 u32
*digest
= (u32
*) hash_buf
->digest
;
10242 salt_t
*salt
= hash_buf
->salt
;
10244 char *salt_pos
= input_buf
+ 6;
10246 uint iterations_len
= 0;
10248 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10252 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10254 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10255 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10259 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10263 iterations_len
+= 8;
10267 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10270 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10272 char *hash_pos
= strchr (salt_pos
, '$');
10274 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10276 uint salt_len
= hash_pos
- salt_pos
;
10278 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10280 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10282 salt
->salt_len
= salt_len
;
10286 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10288 return (PARSER_OK
);
10291 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10293 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10295 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10297 u32
*digest
= (u32
*) hash_buf
->digest
;
10299 salt_t
*salt
= hash_buf
->salt
;
10301 char *salt_pos
= input_buf
+ 14;
10303 char *hash_pos
= strchr (salt_pos
, '*');
10305 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10309 uint salt_len
= hash_pos
- salt_pos
- 1;
10311 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10313 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10315 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10317 salt
->salt_len
= salt_len
;
10319 u8 tmp_buf
[100] = { 0 };
10321 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10323 memcpy (digest
, tmp_buf
, 20);
10325 digest
[0] = byte_swap_32 (digest
[0]);
10326 digest
[1] = byte_swap_32 (digest
[1]);
10327 digest
[2] = byte_swap_32 (digest
[2]);
10328 digest
[3] = byte_swap_32 (digest
[3]);
10329 digest
[4] = byte_swap_32 (digest
[4]);
10331 digest
[0] -= SHA1M_A
;
10332 digest
[1] -= SHA1M_B
;
10333 digest
[2] -= SHA1M_C
;
10334 digest
[3] -= SHA1M_D
;
10335 digest
[4] -= SHA1M_E
;
10337 return (PARSER_OK
);
10340 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10342 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10344 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10346 if (c12
& 3) return (PARSER_HASH_VALUE
);
10348 u32
*digest
= (u32
*) hash_buf
->digest
;
10350 salt_t
*salt
= hash_buf
->salt
;
10352 // for ascii_digest
10353 salt
->salt_sign
[0] = input_buf
[0];
10354 salt
->salt_sign
[1] = input_buf
[1];
10356 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10357 | itoa64_to_int (input_buf
[1]) << 6;
10359 salt
->salt_len
= 2;
10361 u8 tmp_buf
[100] = { 0 };
10363 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10365 memcpy (digest
, tmp_buf
, 8);
10369 IP (digest
[0], digest
[1], tt
);
10374 return (PARSER_OK
);
10377 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10379 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10381 u32
*digest
= (u32
*) hash_buf
->digest
;
10383 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10384 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10385 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10386 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10388 digest
[0] = byte_swap_32 (digest
[0]);
10389 digest
[1] = byte_swap_32 (digest
[1]);
10390 digest
[2] = byte_swap_32 (digest
[2]);
10391 digest
[3] = byte_swap_32 (digest
[3]);
10393 digest
[0] -= MD4M_A
;
10394 digest
[1] -= MD4M_B
;
10395 digest
[2] -= MD4M_C
;
10396 digest
[3] -= MD4M_D
;
10398 return (PARSER_OK
);
10401 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10403 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10405 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10409 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10412 u32
*digest
= (u32
*) hash_buf
->digest
;
10414 salt_t
*salt
= hash_buf
->salt
;
10416 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10417 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10418 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10419 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10421 digest
[0] = byte_swap_32 (digest
[0]);
10422 digest
[1] = byte_swap_32 (digest
[1]);
10423 digest
[2] = byte_swap_32 (digest
[2]);
10424 digest
[3] = byte_swap_32 (digest
[3]);
10426 digest
[0] -= MD4M_A
;
10427 digest
[1] -= MD4M_B
;
10428 digest
[2] -= MD4M_C
;
10429 digest
[3] -= MD4M_D
;
10431 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10433 uint salt_len
= input_len
- 32 - 1;
10435 char *salt_buf
= input_buf
+ 32 + 1;
10437 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10439 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10441 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10443 salt
->salt_len
= salt_len
;
10445 return (PARSER_OK
);
10448 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10450 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10452 u32
*digest
= (u32
*) hash_buf
->digest
;
10454 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10455 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10456 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10457 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10459 digest
[0] = byte_swap_32 (digest
[0]);
10460 digest
[1] = byte_swap_32 (digest
[1]);
10461 digest
[2] = byte_swap_32 (digest
[2]);
10462 digest
[3] = byte_swap_32 (digest
[3]);
10464 digest
[0] -= MD5M_A
;
10465 digest
[1] -= MD5M_B
;
10466 digest
[2] -= MD5M_C
;
10467 digest
[3] -= MD5M_D
;
10469 return (PARSER_OK
);
10472 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10474 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10476 u32
*digest
= (u32
*) hash_buf
->digest
;
10478 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10479 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10483 digest
[0] = byte_swap_32 (digest
[0]);
10484 digest
[1] = byte_swap_32 (digest
[1]);
10486 return (PARSER_OK
);
10489 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10491 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10493 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10497 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10500 u32
*digest
= (u32
*) hash_buf
->digest
;
10502 salt_t
*salt
= hash_buf
->salt
;
10504 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10505 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10506 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10507 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10509 digest
[0] = byte_swap_32 (digest
[0]);
10510 digest
[1] = byte_swap_32 (digest
[1]);
10511 digest
[2] = byte_swap_32 (digest
[2]);
10512 digest
[3] = byte_swap_32 (digest
[3]);
10514 digest
[0] -= MD5M_A
;
10515 digest
[1] -= MD5M_B
;
10516 digest
[2] -= MD5M_C
;
10517 digest
[3] -= MD5M_D
;
10519 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10521 uint salt_len
= input_len
- 32 - 1;
10523 char *salt_buf
= input_buf
+ 32 + 1;
10525 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10527 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10529 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10531 salt
->salt_len
= salt_len
;
10533 return (PARSER_OK
);
10536 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10538 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10540 u32
*digest
= (u32
*) hash_buf
->digest
;
10542 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10543 | itoa64_to_int (input_buf
[ 1]) << 6
10544 | itoa64_to_int (input_buf
[ 2]) << 12
10545 | itoa64_to_int (input_buf
[ 3]) << 18;
10546 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10547 | itoa64_to_int (input_buf
[ 5]) << 6
10548 | itoa64_to_int (input_buf
[ 6]) << 12
10549 | itoa64_to_int (input_buf
[ 7]) << 18;
10550 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10551 | itoa64_to_int (input_buf
[ 9]) << 6
10552 | itoa64_to_int (input_buf
[10]) << 12
10553 | itoa64_to_int (input_buf
[11]) << 18;
10554 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10555 | itoa64_to_int (input_buf
[13]) << 6
10556 | itoa64_to_int (input_buf
[14]) << 12
10557 | itoa64_to_int (input_buf
[15]) << 18;
10559 digest
[0] -= MD5M_A
;
10560 digest
[1] -= MD5M_B
;
10561 digest
[2] -= MD5M_C
;
10562 digest
[3] -= MD5M_D
;
10564 digest
[0] &= 0x00ffffff;
10565 digest
[1] &= 0x00ffffff;
10566 digest
[2] &= 0x00ffffff;
10567 digest
[3] &= 0x00ffffff;
10569 return (PARSER_OK
);
10572 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10574 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10576 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10580 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10583 u32
*digest
= (u32
*) hash_buf
->digest
;
10585 salt_t
*salt
= hash_buf
->salt
;
10587 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10588 | itoa64_to_int (input_buf
[ 1]) << 6
10589 | itoa64_to_int (input_buf
[ 2]) << 12
10590 | itoa64_to_int (input_buf
[ 3]) << 18;
10591 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10592 | itoa64_to_int (input_buf
[ 5]) << 6
10593 | itoa64_to_int (input_buf
[ 6]) << 12
10594 | itoa64_to_int (input_buf
[ 7]) << 18;
10595 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10596 | itoa64_to_int (input_buf
[ 9]) << 6
10597 | itoa64_to_int (input_buf
[10]) << 12
10598 | itoa64_to_int (input_buf
[11]) << 18;
10599 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10600 | itoa64_to_int (input_buf
[13]) << 6
10601 | itoa64_to_int (input_buf
[14]) << 12
10602 | itoa64_to_int (input_buf
[15]) << 18;
10604 digest
[0] -= MD5M_A
;
10605 digest
[1] -= MD5M_B
;
10606 digest
[2] -= MD5M_C
;
10607 digest
[3] -= MD5M_D
;
10609 digest
[0] &= 0x00ffffff;
10610 digest
[1] &= 0x00ffffff;
10611 digest
[2] &= 0x00ffffff;
10612 digest
[3] &= 0x00ffffff;
10614 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10616 uint salt_len
= input_len
- 16 - 1;
10618 char *salt_buf
= input_buf
+ 16 + 1;
10620 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10622 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10624 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10626 salt
->salt_len
= salt_len
;
10628 return (PARSER_OK
);
10631 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10633 key
[0] = (nthash
[0] >> 0);
10634 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10635 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10636 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10637 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10638 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10639 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10640 key
[7] = (nthash
[6] << 1);
10652 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10654 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10656 u32
*digest
= (u32
*) hash_buf
->digest
;
10658 salt_t
*salt
= hash_buf
->salt
;
10660 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10666 char *user_pos
= input_buf
;
10668 char *unused_pos
= strchr (user_pos
, ':');
10670 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10672 uint user_len
= unused_pos
- user_pos
;
10674 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10678 char *domain_pos
= strchr (unused_pos
, ':');
10680 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10682 uint unused_len
= domain_pos
- unused_pos
;
10684 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10688 char *srvchall_pos
= strchr (domain_pos
, ':');
10690 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10692 uint domain_len
= srvchall_pos
- domain_pos
;
10694 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10698 char *hash_pos
= strchr (srvchall_pos
, ':');
10700 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10702 uint srvchall_len
= hash_pos
- srvchall_pos
;
10704 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10708 char *clichall_pos
= strchr (hash_pos
, ':');
10710 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10712 uint hash_len
= clichall_pos
- hash_pos
;
10714 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10718 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10720 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10723 * store some data for later use
10726 netntlm
->user_len
= user_len
* 2;
10727 netntlm
->domain_len
= domain_len
* 2;
10728 netntlm
->srvchall_len
= srvchall_len
/ 2;
10729 netntlm
->clichall_len
= clichall_len
/ 2;
10731 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10732 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10735 * handle username and domainname
10738 for (uint i
= 0; i
< user_len
; i
++)
10740 *userdomain_ptr
++ = user_pos
[i
];
10741 *userdomain_ptr
++ = 0;
10744 for (uint i
= 0; i
< domain_len
; i
++)
10746 *userdomain_ptr
++ = domain_pos
[i
];
10747 *userdomain_ptr
++ = 0;
10751 * handle server challenge encoding
10754 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10756 const char p0
= srvchall_pos
[i
+ 0];
10757 const char p1
= srvchall_pos
[i
+ 1];
10759 *chall_ptr
++ = hex_convert (p1
) << 0
10760 | hex_convert (p0
) << 4;
10764 * handle client challenge encoding
10767 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10769 const char p0
= clichall_pos
[i
+ 0];
10770 const char p1
= clichall_pos
[i
+ 1];
10772 *chall_ptr
++ = hex_convert (p1
) << 0
10773 | hex_convert (p0
) << 4;
10780 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10782 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10784 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10786 salt
->salt_len
= salt_len
;
10788 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10789 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10790 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10791 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10793 digest
[0] = byte_swap_32 (digest
[0]);
10794 digest
[1] = byte_swap_32 (digest
[1]);
10795 digest
[2] = byte_swap_32 (digest
[2]);
10796 digest
[3] = byte_swap_32 (digest
[3]);
10798 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10800 uint digest_tmp
[2] = { 0 };
10802 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10803 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10805 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10806 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10808 /* special case 2: ESS */
10810 if (srvchall_len
== 48)
10812 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10814 uint w
[16] = { 0 };
10816 w
[ 0] = netntlm
->chall_buf
[6];
10817 w
[ 1] = netntlm
->chall_buf
[7];
10818 w
[ 2] = netntlm
->chall_buf
[0];
10819 w
[ 3] = netntlm
->chall_buf
[1];
10823 uint dgst
[4] = { 0 };
10832 salt
->salt_buf
[0] = dgst
[0];
10833 salt
->salt_buf
[1] = dgst
[1];
10837 /* precompute netntlmv1 exploit start */
10839 for (uint i
= 0; i
< 0x10000; i
++)
10841 uint key_md4
[2] = { i
, 0 };
10842 uint key_des
[2] = { 0, 0 };
10844 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10846 uint Kc
[16] = { 0 };
10847 uint Kd
[16] = { 0 };
10849 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10851 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10853 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10855 if (data3
[0] != digest_tmp
[0]) continue;
10856 if (data3
[1] != digest_tmp
[1]) continue;
10858 salt
->salt_buf
[2] = i
;
10860 salt
->salt_len
= 24;
10865 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10866 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10868 /* precompute netntlmv1 exploit stop */
10872 IP (digest
[0], digest
[1], tt
);
10873 IP (digest
[2], digest
[3], tt
);
10875 digest
[0] = rotr32 (digest
[0], 29);
10876 digest
[1] = rotr32 (digest
[1], 29);
10877 digest
[2] = rotr32 (digest
[2], 29);
10878 digest
[3] = rotr32 (digest
[3], 29);
10880 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10882 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10883 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10885 return (PARSER_OK
);
10888 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10890 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10892 u32
*digest
= (u32
*) hash_buf
->digest
;
10894 salt_t
*salt
= hash_buf
->salt
;
10896 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10902 char *user_pos
= input_buf
;
10904 char *unused_pos
= strchr (user_pos
, ':');
10906 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10908 uint user_len
= unused_pos
- user_pos
;
10910 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10914 char *domain_pos
= strchr (unused_pos
, ':');
10916 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10918 uint unused_len
= domain_pos
- unused_pos
;
10920 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10924 char *srvchall_pos
= strchr (domain_pos
, ':');
10926 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10928 uint domain_len
= srvchall_pos
- domain_pos
;
10930 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10934 char *hash_pos
= strchr (srvchall_pos
, ':');
10936 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10938 uint srvchall_len
= hash_pos
- srvchall_pos
;
10940 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10944 char *clichall_pos
= strchr (hash_pos
, ':');
10946 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10948 uint hash_len
= clichall_pos
- hash_pos
;
10950 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10954 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10956 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10958 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10961 * store some data for later use
10964 netntlm
->user_len
= user_len
* 2;
10965 netntlm
->domain_len
= domain_len
* 2;
10966 netntlm
->srvchall_len
= srvchall_len
/ 2;
10967 netntlm
->clichall_len
= clichall_len
/ 2;
10969 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10970 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10973 * handle username and domainname
10976 for (uint i
= 0; i
< user_len
; i
++)
10978 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10979 *userdomain_ptr
++ = 0;
10982 for (uint i
= 0; i
< domain_len
; i
++)
10984 *userdomain_ptr
++ = domain_pos
[i
];
10985 *userdomain_ptr
++ = 0;
10988 *userdomain_ptr
++ = 0x80;
10991 * handle server challenge encoding
10994 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10996 const char p0
= srvchall_pos
[i
+ 0];
10997 const char p1
= srvchall_pos
[i
+ 1];
10999 *chall_ptr
++ = hex_convert (p1
) << 0
11000 | hex_convert (p0
) << 4;
11004 * handle client challenge encoding
11007 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11009 const char p0
= clichall_pos
[i
+ 0];
11010 const char p1
= clichall_pos
[i
+ 1];
11012 *chall_ptr
++ = hex_convert (p1
) << 0
11013 | hex_convert (p0
) << 4;
11016 *chall_ptr
++ = 0x80;
11019 * handle hash itself
11022 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11023 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11024 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11025 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11027 digest
[0] = byte_swap_32 (digest
[0]);
11028 digest
[1] = byte_swap_32 (digest
[1]);
11029 digest
[2] = byte_swap_32 (digest
[2]);
11030 digest
[3] = byte_swap_32 (digest
[3]);
11033 * reuse challange data as salt_buf, its the buffer that is most likely unique
11036 salt
->salt_buf
[0] = 0;
11037 salt
->salt_buf
[1] = 0;
11038 salt
->salt_buf
[2] = 0;
11039 salt
->salt_buf
[3] = 0;
11040 salt
->salt_buf
[4] = 0;
11041 salt
->salt_buf
[5] = 0;
11042 salt
->salt_buf
[6] = 0;
11043 salt
->salt_buf
[7] = 0;
11047 uptr
= (uint
*) netntlm
->userdomain_buf
;
11049 for (uint i
= 0; i
< 16; i
+= 16)
11051 md5_64 (uptr
, salt
->salt_buf
);
11054 uptr
= (uint
*) netntlm
->chall_buf
;
11056 for (uint i
= 0; i
< 256; i
+= 16)
11058 md5_64 (uptr
, salt
->salt_buf
);
11061 salt
->salt_len
= 16;
11063 return (PARSER_OK
);
11066 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11068 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11070 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11074 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11077 u32
*digest
= (u32
*) hash_buf
->digest
;
11079 salt_t
*salt
= hash_buf
->salt
;
11081 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11082 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11083 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11084 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11086 digest
[0] = byte_swap_32 (digest
[0]);
11087 digest
[1] = byte_swap_32 (digest
[1]);
11088 digest
[2] = byte_swap_32 (digest
[2]);
11089 digest
[3] = byte_swap_32 (digest
[3]);
11091 digest
[0] -= MD5M_A
;
11092 digest
[1] -= MD5M_B
;
11093 digest
[2] -= MD5M_C
;
11094 digest
[3] -= MD5M_D
;
11096 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11098 uint salt_len
= input_len
- 32 - 1;
11100 char *salt_buf
= input_buf
+ 32 + 1;
11102 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11104 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11106 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11108 salt
->salt_len
= salt_len
;
11110 return (PARSER_OK
);
11113 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11115 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11117 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11121 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11124 u32
*digest
= (u32
*) hash_buf
->digest
;
11126 salt_t
*salt
= hash_buf
->salt
;
11128 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11129 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11130 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11131 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11133 digest
[0] = byte_swap_32 (digest
[0]);
11134 digest
[1] = byte_swap_32 (digest
[1]);
11135 digest
[2] = byte_swap_32 (digest
[2]);
11136 digest
[3] = byte_swap_32 (digest
[3]);
11138 digest
[0] -= MD5M_A
;
11139 digest
[1] -= MD5M_B
;
11140 digest
[2] -= MD5M_C
;
11141 digest
[3] -= MD5M_D
;
11143 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11145 uint salt_len
= input_len
- 32 - 1;
11147 char *salt_buf
= input_buf
+ 32 + 1;
11149 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11151 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11153 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11155 salt
->salt_len
= salt_len
;
11157 return (PARSER_OK
);
11160 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11162 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11164 u32
*digest
= (u32
*) hash_buf
->digest
;
11166 salt_t
*salt
= hash_buf
->salt
;
11168 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11169 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11170 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11171 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11173 digest
[0] = byte_swap_32 (digest
[0]);
11174 digest
[1] = byte_swap_32 (digest
[1]);
11175 digest
[2] = byte_swap_32 (digest
[2]);
11176 digest
[3] = byte_swap_32 (digest
[3]);
11178 digest
[0] -= MD5M_A
;
11179 digest
[1] -= MD5M_B
;
11180 digest
[2] -= MD5M_C
;
11181 digest
[3] -= MD5M_D
;
11184 * This is a virtual salt. While the algorithm is basically not salted
11185 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11186 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11189 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11191 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11193 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11195 salt
->salt_len
= salt_len
;
11197 return (PARSER_OK
);
11200 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11202 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11204 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11208 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11211 u32
*digest
= (u32
*) hash_buf
->digest
;
11213 salt_t
*salt
= hash_buf
->salt
;
11215 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11216 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11217 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11218 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11220 digest
[0] = byte_swap_32 (digest
[0]);
11221 digest
[1] = byte_swap_32 (digest
[1]);
11222 digest
[2] = byte_swap_32 (digest
[2]);
11223 digest
[3] = byte_swap_32 (digest
[3]);
11225 digest
[0] -= MD5M_A
;
11226 digest
[1] -= MD5M_B
;
11227 digest
[2] -= MD5M_C
;
11228 digest
[3] -= MD5M_D
;
11230 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11232 uint salt_len
= input_len
- 32 - 1;
11234 char *salt_buf
= input_buf
+ 32 + 1;
11236 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11238 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11240 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11242 salt
->salt_len
= salt_len
;
11244 return (PARSER_OK
);
11247 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11249 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11251 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11255 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11258 u32
*digest
= (u32
*) hash_buf
->digest
;
11260 salt_t
*salt
= hash_buf
->salt
;
11262 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11263 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11264 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11265 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11267 digest
[0] = byte_swap_32 (digest
[0]);
11268 digest
[1] = byte_swap_32 (digest
[1]);
11269 digest
[2] = byte_swap_32 (digest
[2]);
11270 digest
[3] = byte_swap_32 (digest
[3]);
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 dcc_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_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11297 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) 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 digest
[0] -= MD4M_A
;
11315 digest
[1] -= MD4M_B
;
11316 digest
[2] -= MD4M_C
;
11317 digest
[3] -= MD4M_D
;
11319 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11321 uint salt_len
= input_len
- 32 - 1;
11323 char *salt_buf
= input_buf
+ 32 + 1;
11325 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11327 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11329 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11331 salt
->salt_len
= salt_len
;
11333 return (PARSER_OK
);
11336 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11338 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11340 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11344 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11347 u32
*digest
= (u32
*) hash_buf
->digest
;
11349 salt_t
*salt
= hash_buf
->salt
;
11351 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11352 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11353 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11354 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11356 digest
[0] = byte_swap_32 (digest
[0]);
11357 digest
[1] = byte_swap_32 (digest
[1]);
11358 digest
[2] = byte_swap_32 (digest
[2]);
11359 digest
[3] = byte_swap_32 (digest
[3]);
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 uint salt_pc_block
[16] = { 0 };
11369 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11371 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11373 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11375 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11377 salt_pc_block
[14] = salt_len
* 8;
11379 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11381 md5_64 (salt_pc_block
, salt_pc_digest
);
11383 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11384 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11385 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11386 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11388 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11390 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11392 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11394 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11395 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11396 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11397 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11399 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11401 return (PARSER_OK
);
11404 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11406 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11408 u32
*digest
= (u32
*) hash_buf
->digest
;
11410 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11411 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11412 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11413 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11414 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11416 digest
[0] -= SHA1M_A
;
11417 digest
[1] -= SHA1M_B
;
11418 digest
[2] -= SHA1M_C
;
11419 digest
[3] -= SHA1M_D
;
11420 digest
[4] -= SHA1M_E
;
11422 return (PARSER_OK
);
11425 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11427 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11429 u32
*digest
= (u32
*) hash_buf
->digest
;
11431 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11432 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11433 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11434 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11435 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11437 return (PARSER_OK
);
11440 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11442 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11444 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11448 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11451 u32
*digest
= (u32
*) hash_buf
->digest
;
11453 salt_t
*salt
= hash_buf
->salt
;
11455 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11456 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11457 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11458 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11459 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11461 digest
[0] -= SHA1M_A
;
11462 digest
[1] -= SHA1M_B
;
11463 digest
[2] -= SHA1M_C
;
11464 digest
[3] -= SHA1M_D
;
11465 digest
[4] -= SHA1M_E
;
11467 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11469 uint salt_len
= input_len
- 40 - 1;
11471 char *salt_buf
= input_buf
+ 40 + 1;
11473 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11475 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11477 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11479 salt
->salt_len
= salt_len
;
11481 return (PARSER_OK
);
11484 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11486 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11488 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11490 u32
*digest
= (u32
*) hash_buf
->digest
;
11492 u8 tmp_buf
[100] = { 0 };
11494 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11496 memcpy (digest
, tmp_buf
, 20);
11498 digest
[0] = byte_swap_32 (digest
[0]);
11499 digest
[1] = byte_swap_32 (digest
[1]);
11500 digest
[2] = byte_swap_32 (digest
[2]);
11501 digest
[3] = byte_swap_32 (digest
[3]);
11502 digest
[4] = byte_swap_32 (digest
[4]);
11504 digest
[0] -= SHA1M_A
;
11505 digest
[1] -= SHA1M_B
;
11506 digest
[2] -= SHA1M_C
;
11507 digest
[3] -= SHA1M_D
;
11508 digest
[4] -= SHA1M_E
;
11510 return (PARSER_OK
);
11513 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11515 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11517 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11519 u32
*digest
= (u32
*) hash_buf
->digest
;
11521 salt_t
*salt
= hash_buf
->salt
;
11523 u8 tmp_buf
[100] = { 0 };
11525 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11527 memcpy (digest
, tmp_buf
, 20);
11529 salt
->salt_len
= tmp_len
- 20;
11531 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11533 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11535 char *ptr
= (char *) salt
->salt_buf
;
11537 ptr
[salt
->salt_len
] = 0x80;
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 mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11557 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11559 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11561 u32
*digest
= (u32
*) hash_buf
->digest
;
11563 salt_t
*salt
= hash_buf
->salt
;
11565 char *salt_buf
= input_buf
+ 6;
11569 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11571 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11573 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11575 salt
->salt_len
= salt_len
;
11577 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11579 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11580 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11581 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11582 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11583 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11585 digest
[0] -= SHA1M_A
;
11586 digest
[1] -= SHA1M_B
;
11587 digest
[2] -= SHA1M_C
;
11588 digest
[3] -= SHA1M_D
;
11589 digest
[4] -= SHA1M_E
;
11591 return (PARSER_OK
);
11594 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11596 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11598 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11600 u32
*digest
= (u32
*) hash_buf
->digest
;
11602 salt_t
*salt
= hash_buf
->salt
;
11604 char *salt_buf
= input_buf
+ 6;
11608 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11610 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11612 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11614 salt
->salt_len
= salt_len
;
11616 char *hash_pos
= input_buf
+ 6 + 8;
11618 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11619 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11620 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11621 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11622 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11624 digest
[0] -= SHA1M_A
;
11625 digest
[1] -= SHA1M_B
;
11626 digest
[2] -= SHA1M_C
;
11627 digest
[3] -= SHA1M_D
;
11628 digest
[4] -= SHA1M_E
;
11630 return (PARSER_OK
);
11633 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11635 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11637 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11639 u64
*digest
= (u64
*) hash_buf
->digest
;
11641 salt_t
*salt
= hash_buf
->salt
;
11643 char *salt_buf
= input_buf
+ 6;
11647 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11649 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11651 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11653 salt
->salt_len
= salt_len
;
11655 char *hash_pos
= input_buf
+ 6 + 8;
11657 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11658 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11659 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11660 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11661 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11662 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11663 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11664 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11666 digest
[0] -= SHA512M_A
;
11667 digest
[1] -= SHA512M_B
;
11668 digest
[2] -= SHA512M_C
;
11669 digest
[3] -= SHA512M_D
;
11670 digest
[4] -= SHA512M_E
;
11671 digest
[5] -= SHA512M_F
;
11672 digest
[6] -= SHA512M_G
;
11673 digest
[7] -= SHA512M_H
;
11675 return (PARSER_OK
);
11678 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11680 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11682 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11686 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11689 u32
*digest
= (u32
*) hash_buf
->digest
;
11691 salt_t
*salt
= hash_buf
->salt
;
11693 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11694 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11698 digest
[0] = byte_swap_32 (digest
[0]);
11699 digest
[1] = byte_swap_32 (digest
[1]);
11701 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11703 uint salt_len
= input_len
- 16 - 1;
11705 char *salt_buf
= input_buf
+ 16 + 1;
11707 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11709 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11711 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11713 salt
->salt_len
= salt_len
;
11715 return (PARSER_OK
);
11718 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11720 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11722 u32
*digest
= (u32
*) hash_buf
->digest
;
11724 salt_t
*salt
= hash_buf
->salt
;
11726 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11727 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11728 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11729 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11730 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11732 digest
[0] -= SHA1M_A
;
11733 digest
[1] -= SHA1M_B
;
11734 digest
[2] -= SHA1M_C
;
11735 digest
[3] -= SHA1M_D
;
11736 digest
[4] -= SHA1M_E
;
11738 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11740 uint salt_len
= input_len
- 40 - 1;
11742 char *salt_buf
= input_buf
+ 40 + 1;
11744 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11746 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11748 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11750 salt
->salt_len
= salt_len
;
11752 return (PARSER_OK
);
11755 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11757 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11759 u32
*digest
= (u32
*) hash_buf
->digest
;
11761 salt_t
*salt
= hash_buf
->salt
;
11763 char *hash_pos
= input_buf
;
11765 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11766 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11767 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11768 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11769 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11770 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11771 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11772 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11773 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11774 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11775 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11776 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11777 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11778 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11779 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11780 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11782 char *salt_pos
= input_buf
+ 128;
11784 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11785 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11786 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11787 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11789 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11790 salt
->salt_len
= 16;
11792 return (PARSER_OK
);
11795 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11797 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11799 u32
*digest
= (u32
*) hash_buf
->digest
;
11801 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11802 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11803 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11804 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11805 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11806 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11807 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11808 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11810 digest
[0] -= SHA256M_A
;
11811 digest
[1] -= SHA256M_B
;
11812 digest
[2] -= SHA256M_C
;
11813 digest
[3] -= SHA256M_D
;
11814 digest
[4] -= SHA256M_E
;
11815 digest
[5] -= SHA256M_F
;
11816 digest
[6] -= SHA256M_G
;
11817 digest
[7] -= SHA256M_H
;
11819 return (PARSER_OK
);
11822 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11824 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11826 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11830 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11833 u32
*digest
= (u32
*) hash_buf
->digest
;
11835 salt_t
*salt
= hash_buf
->salt
;
11837 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11838 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11839 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11840 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11841 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11842 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11843 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11844 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11846 digest
[0] -= SHA256M_A
;
11847 digest
[1] -= SHA256M_B
;
11848 digest
[2] -= SHA256M_C
;
11849 digest
[3] -= SHA256M_D
;
11850 digest
[4] -= SHA256M_E
;
11851 digest
[5] -= SHA256M_F
;
11852 digest
[6] -= SHA256M_G
;
11853 digest
[7] -= SHA256M_H
;
11855 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11857 uint salt_len
= input_len
- 64 - 1;
11859 char *salt_buf
= input_buf
+ 64 + 1;
11861 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11863 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11865 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11867 salt
->salt_len
= salt_len
;
11869 return (PARSER_OK
);
11872 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11874 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11876 u64
*digest
= (u64
*) hash_buf
->digest
;
11878 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11879 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11880 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11881 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11882 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11883 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11887 digest
[0] -= SHA384M_A
;
11888 digest
[1] -= SHA384M_B
;
11889 digest
[2] -= SHA384M_C
;
11890 digest
[3] -= SHA384M_D
;
11891 digest
[4] -= SHA384M_E
;
11892 digest
[5] -= SHA384M_F
;
11896 return (PARSER_OK
);
11899 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11901 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11903 u64
*digest
= (u64
*) hash_buf
->digest
;
11905 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11906 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11907 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11908 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11909 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11910 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11911 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11912 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11914 digest
[0] -= SHA512M_A
;
11915 digest
[1] -= SHA512M_B
;
11916 digest
[2] -= SHA512M_C
;
11917 digest
[3] -= SHA512M_D
;
11918 digest
[4] -= SHA512M_E
;
11919 digest
[5] -= SHA512M_F
;
11920 digest
[6] -= SHA512M_G
;
11921 digest
[7] -= SHA512M_H
;
11923 return (PARSER_OK
);
11926 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11928 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11930 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11934 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11937 u64
*digest
= (u64
*) hash_buf
->digest
;
11939 salt_t
*salt
= hash_buf
->salt
;
11941 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11942 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11943 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11944 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11945 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11946 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11947 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11948 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11950 digest
[0] -= SHA512M_A
;
11951 digest
[1] -= SHA512M_B
;
11952 digest
[2] -= SHA512M_C
;
11953 digest
[3] -= SHA512M_D
;
11954 digest
[4] -= SHA512M_E
;
11955 digest
[5] -= SHA512M_F
;
11956 digest
[6] -= SHA512M_G
;
11957 digest
[7] -= SHA512M_H
;
11959 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11961 uint salt_len
= input_len
- 128 - 1;
11963 char *salt_buf
= input_buf
+ 128 + 1;
11965 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11967 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11969 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11971 salt
->salt_len
= salt_len
;
11973 return (PARSER_OK
);
11976 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11978 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11980 u64
*digest
= (u64
*) hash_buf
->digest
;
11982 salt_t
*salt
= hash_buf
->salt
;
11984 char *salt_pos
= input_buf
+ 3;
11986 uint iterations_len
= 0;
11988 if (memcmp (salt_pos
, "rounds=", 7) == 0)
11992 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
11994 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
11995 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
11999 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12003 iterations_len
+= 8;
12007 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12010 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12012 char *hash_pos
= strchr (salt_pos
, '$');
12014 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12016 uint salt_len
= hash_pos
- salt_pos
;
12018 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12020 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12022 salt
->salt_len
= salt_len
;
12026 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12028 return (PARSER_OK
);
12031 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12033 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12035 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12037 u64
*digest
= (u64
*) hash_buf
->digest
;
12039 salt_t
*salt
= hash_buf
->salt
;
12041 uint keccak_mdlen
= input_len
/ 2;
12043 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12045 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12047 digest
[i
] = byte_swap_64 (digest
[i
]);
12050 salt
->keccak_mdlen
= keccak_mdlen
;
12052 return (PARSER_OK
);
12055 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12057 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12059 u32
*digest
= (u32
*) hash_buf
->digest
;
12061 salt_t
*salt
= hash_buf
->salt
;
12063 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12066 * Parse that strange long line
12071 size_t in_len
[9] = { 0 };
12073 in_off
[0] = strtok (input_buf
, ":");
12075 in_len
[0] = strlen (in_off
[0]);
12079 for (i
= 1; i
< 9; i
++)
12081 in_off
[i
] = strtok (NULL
, ":");
12083 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12085 in_len
[i
] = strlen (in_off
[i
]);
12088 char *ptr
= (char *) ikepsk
->msg_buf
;
12090 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12091 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12092 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12093 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12094 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12095 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12099 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12101 ptr
= (char *) ikepsk
->nr_buf
;
12103 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12104 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12108 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12111 * Store to database
12116 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12117 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12118 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12119 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12121 digest
[0] = byte_swap_32 (digest
[0]);
12122 digest
[1] = byte_swap_32 (digest
[1]);
12123 digest
[2] = byte_swap_32 (digest
[2]);
12124 digest
[3] = byte_swap_32 (digest
[3]);
12126 salt
->salt_len
= 32;
12128 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12129 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12130 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12131 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12132 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12133 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12134 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12135 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12137 return (PARSER_OK
);
12140 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12142 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12144 u32
*digest
= (u32
*) hash_buf
->digest
;
12146 salt_t
*salt
= hash_buf
->salt
;
12148 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12151 * Parse that strange long line
12156 size_t in_len
[9] = { 0 };
12158 in_off
[0] = strtok (input_buf
, ":");
12160 in_len
[0] = strlen (in_off
[0]);
12164 for (i
= 1; i
< 9; i
++)
12166 in_off
[i
] = strtok (NULL
, ":");
12168 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12170 in_len
[i
] = strlen (in_off
[i
]);
12173 char *ptr
= (char *) ikepsk
->msg_buf
;
12175 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12176 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12177 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12178 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12179 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12180 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12184 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12186 ptr
= (char *) ikepsk
->nr_buf
;
12188 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12189 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12193 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12196 * Store to database
12201 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12202 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12203 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12204 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12205 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12207 salt
->salt_len
= 32;
12209 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12210 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12211 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12212 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12213 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12214 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12215 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12216 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12218 return (PARSER_OK
);
12221 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12223 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12225 u32
*digest
= (u32
*) hash_buf
->digest
;
12227 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12228 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12229 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12230 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12231 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12233 digest
[0] = byte_swap_32 (digest
[0]);
12234 digest
[1] = byte_swap_32 (digest
[1]);
12235 digest
[2] = byte_swap_32 (digest
[2]);
12236 digest
[3] = byte_swap_32 (digest
[3]);
12237 digest
[4] = byte_swap_32 (digest
[4]);
12239 return (PARSER_OK
);
12242 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12244 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12246 u32
*digest
= (u32
*) hash_buf
->digest
;
12248 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12249 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12250 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12251 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12252 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12253 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12254 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12255 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12256 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12257 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12258 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12259 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12260 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12261 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12262 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12263 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12265 return (PARSER_OK
);
12268 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12270 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12272 u32
*digest
= (u32
*) hash_buf
->digest
;
12274 salt_t
*salt
= hash_buf
->salt
;
12276 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12277 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12278 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12279 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12280 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12282 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12284 uint salt_len
= input_len
- 40 - 1;
12286 char *salt_buf
= input_buf
+ 40 + 1;
12288 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12290 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12292 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12294 salt
->salt_len
= salt_len
;
12296 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12298 return (PARSER_OK
);
12301 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12303 u32
*digest
= (u32
*) hash_buf
->digest
;
12305 salt_t
*salt
= hash_buf
->salt
;
12307 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12309 if (input_len
== 0)
12311 log_error ("TrueCrypt container not specified");
12316 FILE *fp
= fopen (input_buf
, "rb");
12320 log_error ("%s: %s", input_buf
, strerror (errno
));
12325 char buf
[512] = { 0 };
12327 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12331 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12333 memcpy (tc
->salt_buf
, buf
, 64);
12335 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12337 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12339 salt
->salt_len
= 4;
12341 salt
->salt_iter
= 1000 - 1;
12343 digest
[0] = tc
->data_buf
[0];
12345 return (PARSER_OK
);
12348 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12350 u32
*digest
= (u32
*) hash_buf
->digest
;
12352 salt_t
*salt
= hash_buf
->salt
;
12354 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12356 if (input_len
== 0)
12358 log_error ("TrueCrypt container not specified");
12363 FILE *fp
= fopen (input_buf
, "rb");
12367 log_error ("%s: %s", input_buf
, strerror (errno
));
12372 char buf
[512] = { 0 };
12374 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12378 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12380 memcpy (tc
->salt_buf
, buf
, 64);
12382 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12384 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12386 salt
->salt_len
= 4;
12388 salt
->salt_iter
= 2000 - 1;
12390 digest
[0] = tc
->data_buf
[0];
12392 return (PARSER_OK
);
12395 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12397 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12399 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12401 u32
*digest
= (u32
*) hash_buf
->digest
;
12403 salt_t
*salt
= hash_buf
->salt
;
12405 char *salt_pos
= input_buf
+ 6;
12407 char *hash_pos
= strchr (salt_pos
, '$');
12409 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12411 uint salt_len
= hash_pos
- salt_pos
;
12413 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12415 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12417 salt
->salt_len
= salt_len
;
12419 salt
->salt_iter
= 1000;
12423 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12425 return (PARSER_OK
);
12428 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12430 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12432 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12434 u32
*digest
= (u32
*) hash_buf
->digest
;
12436 salt_t
*salt
= hash_buf
->salt
;
12438 char *iter_pos
= input_buf
+ 7;
12440 char *salt_pos
= strchr (iter_pos
, '$');
12442 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12446 char *hash_pos
= strchr (salt_pos
, '$');
12448 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12450 uint salt_len
= hash_pos
- salt_pos
;
12452 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12454 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12456 salt
->salt_len
= salt_len
;
12458 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12460 salt
->salt_sign
[0] = atoi (salt_iter
);
12462 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12466 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12468 digest
[0] = byte_swap_32 (digest
[0]);
12469 digest
[1] = byte_swap_32 (digest
[1]);
12470 digest
[2] = byte_swap_32 (digest
[2]);
12471 digest
[3] = byte_swap_32 (digest
[3]);
12472 digest
[4] = byte_swap_32 (digest
[4]);
12474 return (PARSER_OK
);
12477 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12479 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12481 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12483 u32
*digest
= (u32
*) hash_buf
->digest
;
12485 salt_t
*salt
= hash_buf
->salt
;
12487 char *iter_pos
= input_buf
+ 9;
12489 char *salt_pos
= strchr (iter_pos
, '$');
12491 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12495 char *hash_pos
= strchr (salt_pos
, '$');
12497 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12499 uint salt_len
= hash_pos
- salt_pos
;
12501 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12503 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12505 salt
->salt_len
= salt_len
;
12507 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12509 salt
->salt_sign
[0] = atoi (salt_iter
);
12511 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12515 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12517 digest
[0] = byte_swap_32 (digest
[0]);
12518 digest
[1] = byte_swap_32 (digest
[1]);
12519 digest
[2] = byte_swap_32 (digest
[2]);
12520 digest
[3] = byte_swap_32 (digest
[3]);
12521 digest
[4] = byte_swap_32 (digest
[4]);
12522 digest
[5] = byte_swap_32 (digest
[5]);
12523 digest
[6] = byte_swap_32 (digest
[6]);
12524 digest
[7] = byte_swap_32 (digest
[7]);
12526 return (PARSER_OK
);
12529 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12531 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12533 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12535 u64
*digest
= (u64
*) hash_buf
->digest
;
12537 salt_t
*salt
= hash_buf
->salt
;
12539 char *iter_pos
= input_buf
+ 9;
12541 char *salt_pos
= strchr (iter_pos
, '$');
12543 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12547 char *hash_pos
= strchr (salt_pos
, '$');
12549 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12551 uint salt_len
= hash_pos
- salt_pos
;
12553 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12555 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12557 salt
->salt_len
= salt_len
;
12559 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12561 salt
->salt_sign
[0] = atoi (salt_iter
);
12563 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12567 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12569 digest
[0] = byte_swap_64 (digest
[0]);
12570 digest
[1] = byte_swap_64 (digest
[1]);
12571 digest
[2] = byte_swap_64 (digest
[2]);
12572 digest
[3] = byte_swap_64 (digest
[3]);
12573 digest
[4] = byte_swap_64 (digest
[4]);
12574 digest
[5] = byte_swap_64 (digest
[5]);
12575 digest
[6] = byte_swap_64 (digest
[6]);
12576 digest
[7] = byte_swap_64 (digest
[7]);
12578 return (PARSER_OK
);
12581 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12583 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12585 u32
*digest
= (u32
*) hash_buf
->digest
;
12587 salt_t
*salt
= hash_buf
->salt
;
12589 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12595 char *iterations_pos
= input_buf
;
12597 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12599 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12601 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12603 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12607 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12609 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12611 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12613 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12615 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12617 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12622 * pbkdf2 iterations
12625 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12628 * handle salt encoding
12631 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12633 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12635 const char p0
= saltbuf_pos
[i
+ 0];
12636 const char p1
= saltbuf_pos
[i
+ 1];
12638 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12639 | hex_convert (p0
) << 4;
12642 salt
->salt_len
= saltbuf_len
/ 2;
12645 * handle cipher encoding
12648 uint
*tmp
= (uint
*) mymalloc (32);
12650 char *cipherbuf_ptr
= (char *) tmp
;
12652 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12654 const char p0
= cipherbuf_pos
[i
+ 0];
12655 const char p1
= cipherbuf_pos
[i
+ 1];
12657 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12658 | hex_convert (p0
) << 4;
12661 // iv is stored at salt_buf 4 (length 16)
12662 // data is stored at salt_buf 8 (length 16)
12664 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12665 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12666 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12667 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12669 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12670 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12671 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12672 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12676 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12678 const char p0
= cipherbuf_pos
[j
+ 0];
12679 const char p1
= cipherbuf_pos
[j
+ 1];
12681 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12682 | hex_convert (p0
) << 4;
12689 digest
[0] = 0x10101010;
12690 digest
[1] = 0x10101010;
12691 digest
[2] = 0x10101010;
12692 digest
[3] = 0x10101010;
12694 return (PARSER_OK
);
12697 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12699 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12701 u32
*digest
= (u32
*) hash_buf
->digest
;
12703 salt_t
*salt
= hash_buf
->salt
;
12705 char *hashbuf_pos
= input_buf
;
12707 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12709 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12711 uint hash_len
= iterations_pos
- hashbuf_pos
;
12713 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12717 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12719 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12721 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12725 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12727 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12729 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12731 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12733 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12735 salt
->salt_len
= salt_len
;
12737 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12739 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12740 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12741 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12742 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12744 return (PARSER_OK
);
12747 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12749 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12751 u32
*digest
= (u32
*) hash_buf
->digest
;
12753 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12754 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12755 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12756 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12757 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12758 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12759 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12760 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12762 digest
[0] = byte_swap_32 (digest
[0]);
12763 digest
[1] = byte_swap_32 (digest
[1]);
12764 digest
[2] = byte_swap_32 (digest
[2]);
12765 digest
[3] = byte_swap_32 (digest
[3]);
12766 digest
[4] = byte_swap_32 (digest
[4]);
12767 digest
[5] = byte_swap_32 (digest
[5]);
12768 digest
[6] = byte_swap_32 (digest
[6]);
12769 digest
[7] = byte_swap_32 (digest
[7]);
12771 return (PARSER_OK
);
12774 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12776 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12778 u32
*digest
= (u32
*) hash_buf
->digest
;
12780 salt_t
*salt
= hash_buf
->salt
;
12782 char *salt_pos
= input_buf
+ 3;
12784 uint iterations_len
= 0;
12786 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12790 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12792 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12793 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12797 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12801 iterations_len
+= 8;
12805 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12808 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12810 char *hash_pos
= strchr (salt_pos
, '$');
12812 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12814 uint salt_len
= hash_pos
- salt_pos
;
12816 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12818 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12820 salt
->salt_len
= salt_len
;
12824 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12826 return (PARSER_OK
);
12829 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12831 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12833 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12835 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12837 u64
*digest
= (u64
*) hash_buf
->digest
;
12839 salt_t
*salt
= hash_buf
->salt
;
12841 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12843 char *iter_pos
= input_buf
+ 4;
12845 char *salt_pos
= strchr (iter_pos
, '$');
12847 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12851 char *hash_pos
= strchr (salt_pos
, '$');
12853 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12855 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12859 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12860 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12861 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12862 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12863 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12864 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12865 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12866 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12868 uint salt_len
= hash_pos
- salt_pos
- 1;
12870 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12872 salt
->salt_len
= salt_len
/ 2;
12874 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12875 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12876 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12877 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12878 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12879 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12880 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12881 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12883 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12884 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12885 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12886 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12887 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12888 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12889 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12890 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12891 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12892 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12894 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12896 salt
->salt_iter
= atoi (iter_pos
) - 1;
12898 return (PARSER_OK
);
12901 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12903 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12905 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12907 u32
*digest
= (u32
*) hash_buf
->digest
;
12909 salt_t
*salt
= hash_buf
->salt
;
12911 char *salt_pos
= input_buf
+ 14;
12913 char *hash_pos
= strchr (salt_pos
, '*');
12915 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12919 uint salt_len
= hash_pos
- salt_pos
- 1;
12921 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12923 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12925 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12927 salt
->salt_len
= salt_len
;
12929 u8 tmp_buf
[100] = { 0 };
12931 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
12933 memcpy (digest
, tmp_buf
, 32);
12935 digest
[0] = byte_swap_32 (digest
[0]);
12936 digest
[1] = byte_swap_32 (digest
[1]);
12937 digest
[2] = byte_swap_32 (digest
[2]);
12938 digest
[3] = byte_swap_32 (digest
[3]);
12939 digest
[4] = byte_swap_32 (digest
[4]);
12940 digest
[5] = byte_swap_32 (digest
[5]);
12941 digest
[6] = byte_swap_32 (digest
[6]);
12942 digest
[7] = byte_swap_32 (digest
[7]);
12944 digest
[0] -= SHA256M_A
;
12945 digest
[1] -= SHA256M_B
;
12946 digest
[2] -= SHA256M_C
;
12947 digest
[3] -= SHA256M_D
;
12948 digest
[4] -= SHA256M_E
;
12949 digest
[5] -= SHA256M_F
;
12950 digest
[6] -= SHA256M_G
;
12951 digest
[7] -= SHA256M_H
;
12953 return (PARSER_OK
);
12956 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12958 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12960 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12962 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12964 u64
*digest
= (u64
*) hash_buf
->digest
;
12966 salt_t
*salt
= hash_buf
->salt
;
12968 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12970 char *iter_pos
= input_buf
+ 19;
12972 char *salt_pos
= strchr (iter_pos
, '.');
12974 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12978 char *hash_pos
= strchr (salt_pos
, '.');
12980 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12982 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12986 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12987 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12988 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12989 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12990 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12991 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12992 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12993 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12995 uint salt_len
= hash_pos
- salt_pos
- 1;
12999 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13003 for (i
= 0; i
< salt_len
; i
++)
13005 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13008 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13009 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13011 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13013 salt
->salt_len
= salt_len
;
13015 salt
->salt_iter
= atoi (iter_pos
) - 1;
13017 return (PARSER_OK
);
13020 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13022 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13024 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13026 u64
*digest
= (u64
*) hash_buf
->digest
;
13028 salt_t
*salt
= hash_buf
->salt
;
13030 u8 tmp_buf
[120] = { 0 };
13032 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13034 memcpy (digest
, tmp_buf
, 64);
13036 digest
[0] = byte_swap_64 (digest
[0]);
13037 digest
[1] = byte_swap_64 (digest
[1]);
13038 digest
[2] = byte_swap_64 (digest
[2]);
13039 digest
[3] = byte_swap_64 (digest
[3]);
13040 digest
[4] = byte_swap_64 (digest
[4]);
13041 digest
[5] = byte_swap_64 (digest
[5]);
13042 digest
[6] = byte_swap_64 (digest
[6]);
13043 digest
[7] = byte_swap_64 (digest
[7]);
13045 digest
[0] -= SHA512M_A
;
13046 digest
[1] -= SHA512M_B
;
13047 digest
[2] -= SHA512M_C
;
13048 digest
[3] -= SHA512M_D
;
13049 digest
[4] -= SHA512M_E
;
13050 digest
[5] -= SHA512M_F
;
13051 digest
[6] -= SHA512M_G
;
13052 digest
[7] -= SHA512M_H
;
13054 salt
->salt_len
= tmp_len
- 64;
13056 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13058 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13060 char *ptr
= (char *) salt
->salt_buf
;
13062 ptr
[salt
->salt_len
] = 0x80;
13065 return (PARSER_OK
);
13068 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13070 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13072 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13076 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13079 u32
*digest
= (u32
*) hash_buf
->digest
;
13081 salt_t
*salt
= hash_buf
->salt
;
13083 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13084 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13085 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13086 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13088 digest
[0] = byte_swap_32 (digest
[0]);
13089 digest
[1] = byte_swap_32 (digest
[1]);
13090 digest
[2] = byte_swap_32 (digest
[2]);
13091 digest
[3] = byte_swap_32 (digest
[3]);
13093 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13095 uint salt_len
= input_len
- 32 - 1;
13097 char *salt_buf
= input_buf
+ 32 + 1;
13099 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13101 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13103 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13105 salt
->salt_len
= salt_len
;
13107 return (PARSER_OK
);
13110 int hmacsha1_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_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13118 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) 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]);
13129 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13131 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13133 uint salt_len
= input_len
- 40 - 1;
13135 char *salt_buf
= input_buf
+ 40 + 1;
13137 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13139 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13141 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13143 salt
->salt_len
= salt_len
;
13145 return (PARSER_OK
);
13148 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13150 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13152 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13156 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13159 u32
*digest
= (u32
*) hash_buf
->digest
;
13161 salt_t
*salt
= hash_buf
->salt
;
13163 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13164 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13165 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13166 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13167 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13168 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13169 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13170 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13172 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13174 uint salt_len
= input_len
- 64 - 1;
13176 char *salt_buf
= input_buf
+ 64 + 1;
13178 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13180 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13182 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13184 salt
->salt_len
= salt_len
;
13186 return (PARSER_OK
);
13189 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13191 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13193 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13197 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13200 u64
*digest
= (u64
*) hash_buf
->digest
;
13202 salt_t
*salt
= hash_buf
->salt
;
13204 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13205 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13206 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13207 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13208 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13209 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13210 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13211 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13213 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13215 uint salt_len
= input_len
- 128 - 1;
13217 char *salt_buf
= input_buf
+ 128 + 1;
13219 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13221 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13223 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13225 salt
->salt_len
= salt_len
;
13227 return (PARSER_OK
);
13230 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13232 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13234 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13236 u32
*digest
= (u32
*) hash_buf
->digest
;
13238 salt_t
*salt
= hash_buf
->salt
;
13240 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13246 char *user_pos
= input_buf
+ 10 + 1;
13248 char *realm_pos
= strchr (user_pos
, '$');
13250 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13252 uint user_len
= realm_pos
- user_pos
;
13254 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13258 char *salt_pos
= strchr (realm_pos
, '$');
13260 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13262 uint realm_len
= salt_pos
- realm_pos
;
13264 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13268 char *data_pos
= strchr (salt_pos
, '$');
13270 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13272 uint salt_len
= data_pos
- salt_pos
;
13274 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13278 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13280 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13286 memcpy (krb5pa
->user
, user_pos
, user_len
);
13287 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13288 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13290 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13292 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13294 const char p0
= data_pos
[i
+ 0];
13295 const char p1
= data_pos
[i
+ 1];
13297 *timestamp_ptr
++ = hex_convert (p1
) << 0
13298 | hex_convert (p0
) << 4;
13301 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13303 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13305 const char p0
= data_pos
[i
+ 0];
13306 const char p1
= data_pos
[i
+ 1];
13308 *checksum_ptr
++ = hex_convert (p1
) << 0
13309 | hex_convert (p0
) << 4;
13313 * copy some data to generic buffers to make sorting happy
13316 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13317 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13318 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13319 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13320 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13321 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13322 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13323 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13324 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13326 salt
->salt_len
= 36;
13328 digest
[0] = krb5pa
->checksum
[0];
13329 digest
[1] = krb5pa
->checksum
[1];
13330 digest
[2] = krb5pa
->checksum
[2];
13331 digest
[3] = krb5pa
->checksum
[3];
13333 return (PARSER_OK
);
13336 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13338 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13340 u32
*digest
= (u32
*) hash_buf
->digest
;
13342 salt_t
*salt
= hash_buf
->salt
;
13348 char *salt_pos
= input_buf
;
13350 char *hash_pos
= strchr (salt_pos
, '$');
13352 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13354 uint salt_len
= hash_pos
- salt_pos
;
13356 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13360 uint hash_len
= input_len
- 1 - salt_len
;
13362 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13370 for (uint i
= 0; i
< salt_len
; i
++)
13372 if (salt_pos
[i
] == ' ') continue;
13377 // SAP user names cannot be longer than 12 characters
13378 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13380 // SAP user name cannot start with ! or ?
13381 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13387 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13389 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13391 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13393 salt
->salt_len
= salt_len
;
13395 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13396 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13400 digest
[0] = byte_swap_32 (digest
[0]);
13401 digest
[1] = byte_swap_32 (digest
[1]);
13403 return (PARSER_OK
);
13406 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13408 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13410 u32
*digest
= (u32
*) hash_buf
->digest
;
13412 salt_t
*salt
= hash_buf
->salt
;
13418 char *salt_pos
= input_buf
;
13420 char *hash_pos
= strchr (salt_pos
, '$');
13422 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13424 uint salt_len
= hash_pos
- salt_pos
;
13426 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13430 uint hash_len
= input_len
- 1 - salt_len
;
13432 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13440 for (uint i
= 0; i
< salt_len
; i
++)
13442 if (salt_pos
[i
] == ' ') continue;
13447 // SAP user names cannot be longer than 12 characters
13448 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13449 // so far nobody complained so we stay with this because it helps in optimization
13450 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13452 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13454 // SAP user name cannot start with ! or ?
13455 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13461 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13463 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13465 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13467 salt
->salt_len
= salt_len
;
13469 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13470 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13471 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13472 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13473 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13475 return (PARSER_OK
);
13478 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13480 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13482 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13484 u64
*digest
= (u64
*) hash_buf
->digest
;
13486 salt_t
*salt
= hash_buf
->salt
;
13488 char *iter_pos
= input_buf
+ 3;
13490 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13492 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13494 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13496 salt
->salt_iter
= salt_iter
;
13498 char *salt_pos
= iter_pos
+ 1;
13502 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13504 salt
->salt_len
= salt_len
;
13506 char *hash_pos
= salt_pos
+ salt_len
;
13508 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13512 char *tmp
= (char *) salt
->salt_buf_pc
;
13514 tmp
[0] = hash_pos
[42];
13518 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13519 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13520 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13521 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13527 return (PARSER_OK
);
13530 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13532 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13534 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13536 u32
*digest
= (u32
*) hash_buf
->digest
;
13538 salt_t
*salt
= hash_buf
->salt
;
13540 char *salt_buf
= input_buf
+ 6;
13542 uint salt_len
= 16;
13544 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13546 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13548 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13550 salt
->salt_len
= salt_len
;
13552 char *hash_pos
= input_buf
+ 6 + 16;
13554 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13555 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13556 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13557 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13558 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13559 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13560 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13561 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13563 return (PARSER_OK
);
13566 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13568 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13570 u32
*digest
= (u32
*) hash_buf
->digest
;
13572 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13573 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13577 return (PARSER_OK
);
13580 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13582 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13584 u32
*digest
= (u32
*) hash_buf
->digest
;
13586 salt_t
*salt
= hash_buf
->salt
;
13588 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13590 char *saltbuf_pos
= input_buf
;
13592 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13594 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13596 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13598 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13599 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13601 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13605 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13607 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13609 char *salt_ptr
= (char *) saltbuf_pos
;
13610 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13615 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13617 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13620 rakp_ptr
[j
] = 0x80;
13622 rakp
->salt_len
= j
;
13624 for (i
= 0; i
< 64; i
++)
13626 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13629 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13630 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13631 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13632 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13633 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13634 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13635 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13636 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13638 salt
->salt_len
= 32; // muss min. 32 haben
13640 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13641 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13642 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13643 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13644 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13646 return (PARSER_OK
);
13649 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13651 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13653 u32
*digest
= (u32
*) hash_buf
->digest
;
13655 salt_t
*salt
= hash_buf
->salt
;
13657 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13659 char *salt_pos
= input_buf
+ 1;
13661 memcpy (salt
->salt_buf
, salt_pos
, 8);
13663 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13664 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13666 salt
->salt_len
= 8;
13668 char *hash_pos
= salt_pos
+ 8;
13670 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13671 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13672 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13673 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13674 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13676 digest
[0] -= SHA1M_A
;
13677 digest
[1] -= SHA1M_B
;
13678 digest
[2] -= SHA1M_C
;
13679 digest
[3] -= SHA1M_D
;
13680 digest
[4] -= SHA1M_E
;
13682 return (PARSER_OK
);
13685 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13687 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13689 u32
*digest
= (u32
*) hash_buf
->digest
;
13691 salt_t
*salt
= hash_buf
->salt
;
13693 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13694 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13695 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13696 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13698 digest
[0] = byte_swap_32 (digest
[0]);
13699 digest
[1] = byte_swap_32 (digest
[1]);
13700 digest
[2] = byte_swap_32 (digest
[2]);
13701 digest
[3] = byte_swap_32 (digest
[3]);
13703 digest
[0] -= MD5M_A
;
13704 digest
[1] -= MD5M_B
;
13705 digest
[2] -= MD5M_C
;
13706 digest
[3] -= MD5M_D
;
13708 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13710 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13712 u32
*salt_buf
= salt
->salt_buf
;
13714 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13715 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13716 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13717 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13719 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13720 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13721 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13722 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13724 salt
->salt_len
= 16 + 1;
13726 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13728 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13730 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13732 return (PARSER_OK
);
13735 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13737 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13739 u32
*digest
= (u32
*) hash_buf
->digest
;
13741 salt_t
*salt
= hash_buf
->salt
;
13743 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13749 char *hashbuf_pos
= input_buf
;
13751 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13753 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13755 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13757 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13761 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13763 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13765 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13767 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13771 char *databuf_pos
= strchr (iteration_pos
, ':');
13773 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13775 const uint iteration_len
= databuf_pos
- iteration_pos
;
13777 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13778 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13780 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13782 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13783 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13789 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13790 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13791 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13792 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13793 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13794 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13795 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13796 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13800 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13802 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13804 const char p0
= saltbuf_pos
[i
+ 0];
13805 const char p1
= saltbuf_pos
[i
+ 1];
13807 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13808 | hex_convert (p0
) << 4;
13811 salt
->salt_buf
[4] = 0x01000000;
13812 salt
->salt_buf
[5] = 0x80;
13814 salt
->salt_len
= saltbuf_len
/ 2;
13818 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13822 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13824 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13826 const char p0
= databuf_pos
[i
+ 0];
13827 const char p1
= databuf_pos
[i
+ 1];
13829 *databuf_ptr
++ = hex_convert (p1
) << 0
13830 | hex_convert (p0
) << 4;
13833 *databuf_ptr
++ = 0x80;
13835 for (uint i
= 0; i
< 512; i
++)
13837 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13840 cloudkey
->data_len
= databuf_len
/ 2;
13842 return (PARSER_OK
);
13845 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13847 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13849 u32
*digest
= (u32
*) hash_buf
->digest
;
13851 salt_t
*salt
= hash_buf
->salt
;
13857 char *hashbuf_pos
= input_buf
;
13859 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13861 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13863 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13865 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13869 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13871 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13873 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13875 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13877 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13881 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13883 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13885 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13887 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13889 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13893 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13895 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13896 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13898 // ok, the plan for this algorithm is the following:
13899 // we have 2 salts here, the domain-name and a random salt
13900 // while both are used in the initial transformation,
13901 // only the random salt is used in the following iterations
13902 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13903 // and one that includes only the real salt (stored into salt_buf[]).
13904 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13906 u8 tmp_buf
[100] = { 0 };
13908 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
13910 memcpy (digest
, tmp_buf
, 20);
13912 digest
[0] = byte_swap_32 (digest
[0]);
13913 digest
[1] = byte_swap_32 (digest
[1]);
13914 digest
[2] = byte_swap_32 (digest
[2]);
13915 digest
[3] = byte_swap_32 (digest
[3]);
13916 digest
[4] = byte_swap_32 (digest
[4]);
13920 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13922 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13924 char *len_ptr
= NULL
;
13926 for (uint i
= 0; i
< domainbuf_len
; i
++)
13928 if (salt_buf_pc_ptr
[i
] == '.')
13930 len_ptr
= &salt_buf_pc_ptr
[i
];
13940 salt
->salt_buf_pc
[7] = domainbuf_len
;
13944 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13946 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13948 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13950 salt
->salt_len
= salt_len
;
13954 salt
->salt_iter
= atoi (iteration_pos
);
13956 return (PARSER_OK
);
13959 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13961 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13963 u32
*digest
= (u32
*) hash_buf
->digest
;
13965 salt_t
*salt
= hash_buf
->salt
;
13967 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13968 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13969 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13970 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13971 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13973 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13975 uint salt_len
= input_len
- 40 - 1;
13977 char *salt_buf
= input_buf
+ 40 + 1;
13979 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13981 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13983 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13985 salt
->salt_len
= salt_len
;
13987 return (PARSER_OK
);
13990 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13992 const u8 ascii_to_ebcdic
[] =
13994 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
13995 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
13996 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
13997 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
13998 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
13999 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14000 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14001 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14002 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14003 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14004 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14005 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14006 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14007 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14008 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14009 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14012 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14014 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14016 u32
*digest
= (u32
*) hash_buf
->digest
;
14018 salt_t
*salt
= hash_buf
->salt
;
14020 char *salt_pos
= input_buf
+ 6 + 1;
14022 char *digest_pos
= strchr (salt_pos
, '*');
14024 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14026 uint salt_len
= digest_pos
- salt_pos
;
14028 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14030 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14032 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14036 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14037 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14039 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14041 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14043 salt
->salt_len
= salt_len
;
14045 for (uint i
= 0; i
< salt_len
; i
++)
14047 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14049 for (uint i
= salt_len
; i
< 8; i
++)
14051 salt_buf_pc_ptr
[i
] = 0x40;
14056 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14058 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14059 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14061 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14062 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14064 digest
[0] = byte_swap_32 (digest
[0]);
14065 digest
[1] = byte_swap_32 (digest
[1]);
14067 IP (digest
[0], digest
[1], tt
);
14069 digest
[0] = rotr32 (digest
[0], 29);
14070 digest
[1] = rotr32 (digest
[1], 29);
14074 return (PARSER_OK
);
14077 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14079 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14081 u32
*digest
= (u32
*) hash_buf
->digest
;
14083 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14084 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14085 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14086 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14088 digest
[0] = byte_swap_32 (digest
[0]);
14089 digest
[1] = byte_swap_32 (digest
[1]);
14090 digest
[2] = byte_swap_32 (digest
[2]);
14091 digest
[3] = byte_swap_32 (digest
[3]);
14093 return (PARSER_OK
);
14096 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14098 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14100 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14102 u32
*digest
= (u32
*) hash_buf
->digest
;
14104 salt_t
*salt
= hash_buf
->salt
;
14106 u8 tmp_buf
[120] = { 0 };
14108 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14110 tmp_buf
[3] += -4; // dont ask!
14112 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14114 salt
->salt_len
= 5;
14116 memcpy (digest
, tmp_buf
+ 5, 9);
14118 // yes, only 9 byte are needed to crack, but 10 to display
14120 salt
->salt_buf_pc
[7] = input_buf
[20];
14122 return (PARSER_OK
);
14125 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14127 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14129 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14131 u32
*digest
= (u32
*) hash_buf
->digest
;
14133 salt_t
*salt
= hash_buf
->salt
;
14135 u8 tmp_buf
[120] = { 0 };
14137 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14139 tmp_buf
[3] += -4; // dont ask!
14143 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14145 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)
14149 char tmp_iter_buf
[11] = { 0 };
14151 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14153 tmp_iter_buf
[10] = 0;
14155 salt
->salt_iter
= atoi (tmp_iter_buf
);
14157 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14159 return (PARSER_SALT_ITERATION
);
14162 salt
->salt_iter
--; // first round in init
14164 // 2 additional bytes for display only
14166 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14167 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14171 memcpy (digest
, tmp_buf
+ 28, 8);
14173 digest
[0] = byte_swap_32 (digest
[0]);
14174 digest
[1] = byte_swap_32 (digest
[1]);
14178 return (PARSER_OK
);
14181 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14183 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14185 u32
*digest
= (u32
*) hash_buf
->digest
;
14187 salt_t
*salt
= hash_buf
->salt
;
14189 char *salt_buf_pos
= input_buf
;
14191 char *hash_buf_pos
= salt_buf_pos
+ 6;
14193 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14194 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14195 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14196 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14197 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14198 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14199 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14200 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14202 digest
[0] -= SHA256M_A
;
14203 digest
[1] -= SHA256M_B
;
14204 digest
[2] -= SHA256M_C
;
14205 digest
[3] -= SHA256M_D
;
14206 digest
[4] -= SHA256M_E
;
14207 digest
[5] -= SHA256M_F
;
14208 digest
[6] -= SHA256M_G
;
14209 digest
[7] -= SHA256M_H
;
14211 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14213 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14215 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14217 salt
->salt_len
= salt_len
;
14219 return (PARSER_OK
);
14222 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14224 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14226 u32
*digest
= (u32
*) hash_buf
->digest
;
14228 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14230 salt_t
*salt
= hash_buf
->salt
;
14232 char *salt_buf
= input_buf
+ 6;
14234 char *digest_buf
= strchr (salt_buf
, '$');
14236 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14238 uint salt_len
= digest_buf
- salt_buf
;
14240 digest_buf
++; // skip the '$' symbol
14242 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14244 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14246 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14248 salt
->salt_len
= salt_len
;
14250 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14251 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14252 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14253 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14255 digest
[0] = byte_swap_32 (digest
[0]);
14256 digest
[1] = byte_swap_32 (digest
[1]);
14257 digest
[2] = byte_swap_32 (digest
[2]);
14258 digest
[3] = byte_swap_32 (digest
[3]);
14260 digest
[0] -= MD5M_A
;
14261 digest
[1] -= MD5M_B
;
14262 digest
[2] -= MD5M_C
;
14263 digest
[3] -= MD5M_D
;
14265 return (PARSER_OK
);
14268 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14270 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14272 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14274 u32
*digest
= (u32
*) hash_buf
->digest
;
14276 salt_t
*salt
= hash_buf
->salt
;
14278 char *salt_buf
= input_buf
+ 3;
14280 char *digest_buf
= strchr (salt_buf
, '$');
14282 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14284 uint salt_len
= digest_buf
- salt_buf
;
14286 digest_buf
++; // skip the '$' symbol
14288 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14290 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14292 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14294 salt_buf_ptr
[salt_len
] = 0x2d;
14296 salt
->salt_len
= salt_len
+ 1;
14298 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14299 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14300 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14301 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14303 digest
[0] = byte_swap_32 (digest
[0]);
14304 digest
[1] = byte_swap_32 (digest
[1]);
14305 digest
[2] = byte_swap_32 (digest
[2]);
14306 digest
[3] = byte_swap_32 (digest
[3]);
14308 digest
[0] -= MD5M_A
;
14309 digest
[1] -= MD5M_B
;
14310 digest
[2] -= MD5M_C
;
14311 digest
[3] -= MD5M_D
;
14313 return (PARSER_OK
);
14316 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14318 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14320 u32
*digest
= (u32
*) hash_buf
->digest
;
14322 u8 tmp_buf
[100] = { 0 };
14324 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14326 memcpy (digest
, tmp_buf
, 20);
14328 digest
[0] = byte_swap_32 (digest
[0]);
14329 digest
[1] = byte_swap_32 (digest
[1]);
14330 digest
[2] = byte_swap_32 (digest
[2]);
14331 digest
[3] = byte_swap_32 (digest
[3]);
14332 digest
[4] = byte_swap_32 (digest
[4]);
14334 digest
[0] -= SHA1M_A
;
14335 digest
[1] -= SHA1M_B
;
14336 digest
[2] -= SHA1M_C
;
14337 digest
[3] -= SHA1M_D
;
14338 digest
[4] -= SHA1M_E
;
14340 return (PARSER_OK
);
14343 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14345 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14347 u32
*digest
= (u32
*) hash_buf
->digest
;
14349 salt_t
*salt
= hash_buf
->salt
;
14351 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14352 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14353 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14354 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14356 digest
[0] = byte_swap_32 (digest
[0]);
14357 digest
[1] = byte_swap_32 (digest
[1]);
14358 digest
[2] = byte_swap_32 (digest
[2]);
14359 digest
[3] = byte_swap_32 (digest
[3]);
14361 digest
[0] -= MD5M_A
;
14362 digest
[1] -= MD5M_B
;
14363 digest
[2] -= MD5M_C
;
14364 digest
[3] -= MD5M_D
;
14366 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14368 uint salt_len
= input_len
- 32 - 1;
14370 char *salt_buf
= input_buf
+ 32 + 1;
14372 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14374 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14376 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14379 * add static "salt" part
14382 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14386 salt
->salt_len
= salt_len
;
14388 return (PARSER_OK
);
14391 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14393 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14395 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14397 u32
*digest
= (u32
*) hash_buf
->digest
;
14399 salt_t
*salt
= hash_buf
->salt
;
14401 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14407 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14409 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14411 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14413 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14415 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14419 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14421 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14423 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14425 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14429 char *keybuf_pos
= strchr (keylen_pos
, '$');
14431 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14433 uint keylen_len
= keybuf_pos
- keylen_pos
;
14435 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14439 char *databuf_pos
= strchr (keybuf_pos
, '$');
14441 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14443 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14445 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14449 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14451 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14457 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14458 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14459 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14460 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14462 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14463 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14464 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14465 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14467 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14468 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14469 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14470 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14472 salt
->salt_len
= 16;
14473 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14475 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14477 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14480 return (PARSER_OK
);
14483 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14485 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14487 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14489 u32
*digest
= (u32
*) hash_buf
->digest
;
14491 salt_t
*salt
= hash_buf
->salt
;
14497 // first is the N salt parameter
14499 char *N_pos
= input_buf
+ 6;
14501 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14505 salt
->scrypt_N
= atoi (N_pos
);
14509 char *r_pos
= strchr (N_pos
, ':');
14511 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14515 salt
->scrypt_r
= atoi (r_pos
);
14519 char *p_pos
= strchr (r_pos
, ':');
14521 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14525 salt
->scrypt_p
= atoi (p_pos
);
14529 char *saltbuf_pos
= strchr (p_pos
, ':');
14531 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14535 char *hash_pos
= strchr (saltbuf_pos
, ':');
14537 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14543 u8 tmp_buf
[33] = { 0 };
14545 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14547 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14549 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14551 salt
->salt_len
= tmp_len
;
14552 salt
->salt_iter
= 1;
14554 // digest - base64 decode
14556 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14558 tmp_len
= input_len
- (hash_pos
- input_buf
);
14560 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14562 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14564 memcpy (digest
, tmp_buf
, 32);
14566 return (PARSER_OK
);
14569 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14571 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14573 u32
*digest
= (u32
*) hash_buf
->digest
;
14575 salt_t
*salt
= hash_buf
->salt
;
14581 char decrypted
[76] = { 0 }; // iv + hash
14583 juniper_decrypt_hash (input_buf
, decrypted
);
14585 char *md5crypt_hash
= decrypted
+ 12;
14587 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14589 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14591 char *salt_pos
= md5crypt_hash
+ 3;
14593 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14595 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14597 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14601 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14603 return (PARSER_OK
);
14606 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14608 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14610 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14612 u32
*digest
= (u32
*) hash_buf
->digest
;
14614 salt_t
*salt
= hash_buf
->salt
;
14616 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14622 // first is *raw* salt
14624 char *salt_pos
= input_buf
+ 3;
14626 char *hash_pos
= strchr (salt_pos
, '$');
14628 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14630 uint salt_len
= hash_pos
- salt_pos
;
14632 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14636 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14638 memcpy (salt_buf_ptr
, salt_pos
, 14);
14640 salt_buf_ptr
[17] = 0x01;
14641 salt_buf_ptr
[18] = 0x80;
14643 // add some stuff to normal salt to make sorted happy
14645 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14646 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14647 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14648 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14650 salt
->salt_len
= salt_len
;
14651 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14653 // base64 decode hash
14655 u8 tmp_buf
[100] = { 0 };
14657 uint hash_len
= input_len
- 3 - salt_len
- 1;
14659 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14661 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14663 memcpy (digest
, tmp_buf
, 32);
14665 digest
[0] = byte_swap_32 (digest
[0]);
14666 digest
[1] = byte_swap_32 (digest
[1]);
14667 digest
[2] = byte_swap_32 (digest
[2]);
14668 digest
[3] = byte_swap_32 (digest
[3]);
14669 digest
[4] = byte_swap_32 (digest
[4]);
14670 digest
[5] = byte_swap_32 (digest
[5]);
14671 digest
[6] = byte_swap_32 (digest
[6]);
14672 digest
[7] = byte_swap_32 (digest
[7]);
14674 return (PARSER_OK
);
14677 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14679 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14681 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14683 u32
*digest
= (u32
*) hash_buf
->digest
;
14685 salt_t
*salt
= hash_buf
->salt
;
14691 // first is *raw* salt
14693 char *salt_pos
= input_buf
+ 3;
14695 char *hash_pos
= strchr (salt_pos
, '$');
14697 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14699 uint salt_len
= hash_pos
- salt_pos
;
14701 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14703 salt
->salt_len
= salt_len
;
14706 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14708 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14709 salt_buf_ptr
[salt_len
] = 0;
14711 // base64 decode hash
14713 u8 tmp_buf
[100] = { 0 };
14715 uint hash_len
= input_len
- 3 - salt_len
- 1;
14717 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14719 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14721 memcpy (digest
, tmp_buf
, 32);
14724 salt
->scrypt_N
= 16384;
14725 salt
->scrypt_r
= 1;
14726 salt
->scrypt_p
= 1;
14727 salt
->salt_iter
= 1;
14729 return (PARSER_OK
);
14732 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14734 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14736 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14738 u32
*digest
= (u32
*) hash_buf
->digest
;
14740 salt_t
*salt
= hash_buf
->salt
;
14742 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14748 char *version_pos
= input_buf
+ 8 + 1;
14750 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14752 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14754 u32 version_len
= verifierHashSize_pos
- version_pos
;
14756 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14758 verifierHashSize_pos
++;
14760 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14762 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14764 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14766 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14770 char *saltSize_pos
= strchr (keySize_pos
, '*');
14772 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14774 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14776 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14780 char *osalt_pos
= strchr (saltSize_pos
, '*');
14782 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14784 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14786 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14790 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14792 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14794 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14796 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14798 encryptedVerifier_pos
++;
14800 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14802 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14804 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14806 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14808 encryptedVerifierHash_pos
++;
14810 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;
14812 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14814 const uint version
= atoi (version_pos
);
14816 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14818 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14820 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14822 const uint keySize
= atoi (keySize_pos
);
14824 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14826 office2007
->keySize
= keySize
;
14828 const uint saltSize
= atoi (saltSize_pos
);
14830 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14836 salt
->salt_len
= 16;
14837 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14839 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14840 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14841 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14842 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14848 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14849 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14850 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14851 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14853 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14854 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14855 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14856 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14857 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14863 digest
[0] = office2007
->encryptedVerifierHash
[0];
14864 digest
[1] = office2007
->encryptedVerifierHash
[1];
14865 digest
[2] = office2007
->encryptedVerifierHash
[2];
14866 digest
[3] = office2007
->encryptedVerifierHash
[3];
14868 return (PARSER_OK
);
14871 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14873 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14875 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14877 u32
*digest
= (u32
*) hash_buf
->digest
;
14879 salt_t
*salt
= hash_buf
->salt
;
14881 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14887 char *version_pos
= input_buf
+ 8 + 1;
14889 char *spinCount_pos
= strchr (version_pos
, '*');
14891 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14893 u32 version_len
= spinCount_pos
- version_pos
;
14895 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14899 char *keySize_pos
= strchr (spinCount_pos
, '*');
14901 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14903 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
14905 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14909 char *saltSize_pos
= strchr (keySize_pos
, '*');
14911 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14913 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14915 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14919 char *osalt_pos
= strchr (saltSize_pos
, '*');
14921 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14923 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14925 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14929 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14931 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14933 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14935 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14937 encryptedVerifier_pos
++;
14939 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14941 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14943 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14945 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14947 encryptedVerifierHash_pos
++;
14949 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;
14951 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14953 const uint version
= atoi (version_pos
);
14955 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14957 const uint spinCount
= atoi (spinCount_pos
);
14959 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14961 const uint keySize
= atoi (keySize_pos
);
14963 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14965 const uint saltSize
= atoi (saltSize_pos
);
14967 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14973 salt
->salt_len
= 16;
14974 salt
->salt_iter
= spinCount
;
14976 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14977 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14978 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14979 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14985 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14986 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14987 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14988 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14990 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14991 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14992 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14993 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14994 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14995 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
14996 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
14997 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15003 digest
[0] = office2010
->encryptedVerifierHash
[0];
15004 digest
[1] = office2010
->encryptedVerifierHash
[1];
15005 digest
[2] = office2010
->encryptedVerifierHash
[2];
15006 digest
[3] = office2010
->encryptedVerifierHash
[3];
15008 return (PARSER_OK
);
15011 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15013 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15015 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15017 u32
*digest
= (u32
*) hash_buf
->digest
;
15019 salt_t
*salt
= hash_buf
->salt
;
15021 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15027 char *version_pos
= input_buf
+ 8 + 1;
15029 char *spinCount_pos
= strchr (version_pos
, '*');
15031 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15033 u32 version_len
= spinCount_pos
- version_pos
;
15035 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15039 char *keySize_pos
= strchr (spinCount_pos
, '*');
15041 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15043 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15045 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15049 char *saltSize_pos
= strchr (keySize_pos
, '*');
15051 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15053 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15055 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15059 char *osalt_pos
= strchr (saltSize_pos
, '*');
15061 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15063 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15065 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15069 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15071 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15073 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15075 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15077 encryptedVerifier_pos
++;
15079 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15081 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15083 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15085 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15087 encryptedVerifierHash_pos
++;
15089 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;
15091 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15093 const uint version
= atoi (version_pos
);
15095 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15097 const uint spinCount
= atoi (spinCount_pos
);
15099 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15101 const uint keySize
= atoi (keySize_pos
);
15103 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15105 const uint saltSize
= atoi (saltSize_pos
);
15107 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15113 salt
->salt_len
= 16;
15114 salt
->salt_iter
= spinCount
;
15116 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15117 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15118 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15119 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15125 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15126 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15127 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15128 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15130 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15131 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15132 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15133 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15134 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15135 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15136 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15137 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15143 digest
[0] = office2013
->encryptedVerifierHash
[0];
15144 digest
[1] = office2013
->encryptedVerifierHash
[1];
15145 digest
[2] = office2013
->encryptedVerifierHash
[2];
15146 digest
[3] = office2013
->encryptedVerifierHash
[3];
15148 return (PARSER_OK
);
15151 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15153 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15155 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15157 u32
*digest
= (u32
*) hash_buf
->digest
;
15159 salt_t
*salt
= hash_buf
->salt
;
15161 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15167 char *version_pos
= input_buf
+ 11;
15169 char *osalt_pos
= strchr (version_pos
, '*');
15171 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15173 u32 version_len
= osalt_pos
- version_pos
;
15175 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15179 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15181 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15183 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15185 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15187 encryptedVerifier_pos
++;
15189 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15191 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15193 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15195 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15197 encryptedVerifierHash_pos
++;
15199 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15201 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15203 const uint version
= *version_pos
- 0x30;
15205 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15211 oldoffice01
->version
= version
;
15213 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15214 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15215 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15216 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15218 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15219 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15220 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15221 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15223 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15224 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15225 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15226 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15228 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15229 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15230 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15231 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15237 salt
->salt_len
= 16;
15239 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15240 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15241 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15242 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15244 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15245 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15246 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15247 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15249 // this is a workaround as office produces multiple documents with the same salt
15251 salt
->salt_len
+= 32;
15253 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15254 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15255 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15256 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15257 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15258 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15259 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15260 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15266 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15267 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15268 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15269 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15271 return (PARSER_OK
);
15274 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15276 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15279 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15281 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15283 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15285 u32
*digest
= (u32
*) hash_buf
->digest
;
15287 salt_t
*salt
= hash_buf
->salt
;
15289 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15295 char *version_pos
= input_buf
+ 11;
15297 char *osalt_pos
= strchr (version_pos
, '*');
15299 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15301 u32 version_len
= osalt_pos
- version_pos
;
15303 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15307 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15309 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15311 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15313 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15315 encryptedVerifier_pos
++;
15317 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15319 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15321 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15323 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15325 encryptedVerifierHash_pos
++;
15327 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15329 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15331 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15333 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15337 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15339 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15341 const uint version
= *version_pos
- 0x30;
15343 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15349 oldoffice01
->version
= version
;
15351 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15352 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15353 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15354 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15356 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15357 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15358 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15359 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15361 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15362 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15363 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15364 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15366 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15367 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15368 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15369 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15371 oldoffice01
->rc4key
[1] = 0;
15372 oldoffice01
->rc4key
[0] = 0;
15374 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15375 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15376 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15377 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15378 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15379 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15380 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15381 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15382 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15383 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15385 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15386 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15392 salt
->salt_len
= 16;
15394 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15395 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15396 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15397 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15399 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15400 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15401 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15402 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15404 // this is a workaround as office produces multiple documents with the same salt
15406 salt
->salt_len
+= 32;
15408 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15409 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15410 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15411 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15412 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15413 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15414 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15415 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15421 digest
[0] = oldoffice01
->rc4key
[0];
15422 digest
[1] = oldoffice01
->rc4key
[1];
15426 return (PARSER_OK
);
15429 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15431 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15433 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15435 u32
*digest
= (u32
*) hash_buf
->digest
;
15437 salt_t
*salt
= hash_buf
->salt
;
15439 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15445 char *version_pos
= input_buf
+ 11;
15447 char *osalt_pos
= strchr (version_pos
, '*');
15449 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15451 u32 version_len
= osalt_pos
- version_pos
;
15453 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15457 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15459 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15461 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15463 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15465 encryptedVerifier_pos
++;
15467 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15469 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15471 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15473 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15475 encryptedVerifierHash_pos
++;
15477 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15479 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15481 const uint version
= *version_pos
- 0x30;
15483 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15489 oldoffice34
->version
= version
;
15491 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15492 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15493 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15494 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15496 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15497 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15498 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15499 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15501 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15502 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15503 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15504 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15505 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15507 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15508 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15509 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15510 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15511 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15517 salt
->salt_len
= 16;
15519 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15520 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15521 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15522 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15524 // this is a workaround as office produces multiple documents with the same salt
15526 salt
->salt_len
+= 32;
15528 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15529 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15530 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15531 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15532 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15533 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15534 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15535 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15541 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15542 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15543 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15544 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15546 return (PARSER_OK
);
15549 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15551 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15553 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15556 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15558 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15560 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15562 u32
*digest
= (u32
*) hash_buf
->digest
;
15564 salt_t
*salt
= hash_buf
->salt
;
15566 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15572 char *version_pos
= input_buf
+ 11;
15574 char *osalt_pos
= strchr (version_pos
, '*');
15576 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15578 u32 version_len
= osalt_pos
- version_pos
;
15580 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15584 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15586 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15588 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15590 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15592 encryptedVerifier_pos
++;
15594 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15596 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15598 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15600 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15602 encryptedVerifierHash_pos
++;
15604 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15606 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15608 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15610 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15614 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15616 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15618 const uint version
= *version_pos
- 0x30;
15620 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15626 oldoffice34
->version
= version
;
15628 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15629 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15630 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15631 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15633 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15634 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15635 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15636 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15638 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15639 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15640 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15641 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15642 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15644 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15645 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15646 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15647 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15648 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15650 oldoffice34
->rc4key
[1] = 0;
15651 oldoffice34
->rc4key
[0] = 0;
15653 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15654 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15655 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15656 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15657 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15658 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15659 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15660 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15661 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15662 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15664 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15665 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15671 salt
->salt_len
= 16;
15673 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15674 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15675 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15676 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15678 // this is a workaround as office produces multiple documents with the same salt
15680 salt
->salt_len
+= 32;
15682 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15683 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15684 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15685 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15686 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15687 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15688 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15689 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15695 digest
[0] = oldoffice34
->rc4key
[0];
15696 digest
[1] = oldoffice34
->rc4key
[1];
15700 return (PARSER_OK
);
15703 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15705 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15707 u32
*digest
= (u32
*) hash_buf
->digest
;
15709 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15710 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15711 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15712 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15714 digest
[0] = byte_swap_32 (digest
[0]);
15715 digest
[1] = byte_swap_32 (digest
[1]);
15716 digest
[2] = byte_swap_32 (digest
[2]);
15717 digest
[3] = byte_swap_32 (digest
[3]);
15719 return (PARSER_OK
);
15722 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15724 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15726 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15728 u32
*digest
= (u32
*) hash_buf
->digest
;
15730 salt_t
*salt
= hash_buf
->salt
;
15732 char *signature_pos
= input_buf
;
15734 char *salt_pos
= strchr (signature_pos
, '$');
15736 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15738 u32 signature_len
= salt_pos
- signature_pos
;
15740 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15744 char *hash_pos
= strchr (salt_pos
, '$');
15746 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15748 u32 salt_len
= hash_pos
- salt_pos
;
15750 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15754 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15756 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15758 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15759 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15760 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15761 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15762 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15764 digest
[0] -= SHA1M_A
;
15765 digest
[1] -= SHA1M_B
;
15766 digest
[2] -= SHA1M_C
;
15767 digest
[3] -= SHA1M_D
;
15768 digest
[4] -= SHA1M_E
;
15770 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15772 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15774 salt
->salt_len
= salt_len
;
15776 return (PARSER_OK
);
15779 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15781 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15783 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15785 u32
*digest
= (u32
*) hash_buf
->digest
;
15787 salt_t
*salt
= hash_buf
->salt
;
15789 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15795 char *iter_pos
= input_buf
+ 14;
15797 const int iter
= atoi (iter_pos
);
15799 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15801 salt
->salt_iter
= iter
- 1;
15803 char *salt_pos
= strchr (iter_pos
, '$');
15805 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15809 char *hash_pos
= strchr (salt_pos
, '$');
15811 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15813 const uint salt_len
= hash_pos
- salt_pos
;
15817 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15819 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15821 salt
->salt_len
= salt_len
;
15823 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15824 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15826 // add some stuff to normal salt to make sorted happy
15828 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15829 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15830 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15831 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15832 salt
->salt_buf
[4] = salt
->salt_iter
;
15834 // base64 decode hash
15836 u8 tmp_buf
[100] = { 0 };
15838 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15840 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15842 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15844 memcpy (digest
, tmp_buf
, 32);
15846 digest
[0] = byte_swap_32 (digest
[0]);
15847 digest
[1] = byte_swap_32 (digest
[1]);
15848 digest
[2] = byte_swap_32 (digest
[2]);
15849 digest
[3] = byte_swap_32 (digest
[3]);
15850 digest
[4] = byte_swap_32 (digest
[4]);
15851 digest
[5] = byte_swap_32 (digest
[5]);
15852 digest
[6] = byte_swap_32 (digest
[6]);
15853 digest
[7] = byte_swap_32 (digest
[7]);
15855 return (PARSER_OK
);
15858 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15860 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15862 u32
*digest
= (u32
*) hash_buf
->digest
;
15864 salt_t
*salt
= hash_buf
->salt
;
15866 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15867 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15871 digest
[0] = byte_swap_32 (digest
[0]);
15872 digest
[1] = byte_swap_32 (digest
[1]);
15874 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15875 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15876 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15878 char iter_c
= input_buf
[17];
15879 char iter_d
= input_buf
[19];
15881 // atm only defaults, let's see if there's more request
15882 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15883 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15885 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15887 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15888 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15889 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15890 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15892 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15893 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15894 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15895 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15897 salt
->salt_len
= 16;
15899 return (PARSER_OK
);
15902 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15904 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15906 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15908 u32
*digest
= (u32
*) hash_buf
->digest
;
15910 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15912 salt_t
*salt
= hash_buf
->salt
;
15914 char *salt_pos
= input_buf
+ 10;
15916 char *hash_pos
= strchr (salt_pos
, '$');
15918 uint salt_len
= hash_pos
- salt_pos
;
15920 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15924 uint hash_len
= input_len
- 10 - salt_len
- 1;
15926 // base64 decode salt
15928 u8 tmp_buf
[100] = { 0 };
15930 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
15932 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15934 tmp_buf
[salt_len
] = 0x80;
15936 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15938 salt
->salt_len
= salt_len
;
15940 // base64 decode salt
15942 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15944 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15946 uint user_len
= hash_len
- 32;
15948 const u8
*tmp_hash
= tmp_buf
+ user_len
;
15950 user_len
--; // skip the trailing space
15952 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
15953 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
15954 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
15955 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
15957 digest
[0] = byte_swap_32 (digest
[0]);
15958 digest
[1] = byte_swap_32 (digest
[1]);
15959 digest
[2] = byte_swap_32 (digest
[2]);
15960 digest
[3] = byte_swap_32 (digest
[3]);
15962 // store username for host only (output hash if cracked)
15964 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15965 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15967 return (PARSER_OK
);
15970 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15972 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15974 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15976 u32
*digest
= (u32
*) hash_buf
->digest
;
15978 salt_t
*salt
= hash_buf
->salt
;
15980 char *iter_pos
= input_buf
+ 10;
15982 u32 iter
= atoi (iter_pos
);
15986 return (PARSER_SALT_ITERATION
);
15989 iter
--; // first iteration is special
15991 salt
->salt_iter
= iter
;
15993 char *base64_pos
= strchr (iter_pos
, '}');
15995 if (base64_pos
== NULL
)
15997 return (PARSER_SIGNATURE_UNMATCHED
);
16002 // base64 decode salt
16004 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16006 u8 tmp_buf
[100] = { 0 };
16008 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16010 if (decoded_len
< 24)
16012 return (PARSER_SALT_LENGTH
);
16017 uint salt_len
= decoded_len
- 20;
16019 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16020 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16022 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16024 salt
->salt_len
= salt_len
;
16028 u32
*digest_ptr
= (u32
*) tmp_buf
;
16030 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16031 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16032 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16033 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16034 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16036 return (PARSER_OK
);
16039 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16041 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16043 u32
*digest
= (u32
*) hash_buf
->digest
;
16045 salt_t
*salt
= hash_buf
->salt
;
16047 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16048 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16049 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16050 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16051 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16053 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16055 uint salt_len
= input_len
- 40 - 1;
16057 char *salt_buf
= input_buf
+ 40 + 1;
16059 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16061 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16063 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16065 salt
->salt_len
= salt_len
;
16067 return (PARSER_OK
);
16070 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16072 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16074 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16076 u32
*digest
= (u32
*) hash_buf
->digest
;
16078 salt_t
*salt
= hash_buf
->salt
;
16080 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16086 char *V_pos
= input_buf
+ 5;
16088 char *R_pos
= strchr (V_pos
, '*');
16090 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16092 u32 V_len
= R_pos
- V_pos
;
16096 char *bits_pos
= strchr (R_pos
, '*');
16098 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16100 u32 R_len
= bits_pos
- R_pos
;
16104 char *P_pos
= strchr (bits_pos
, '*');
16106 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16108 u32 bits_len
= P_pos
- bits_pos
;
16112 char *enc_md_pos
= strchr (P_pos
, '*');
16114 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16116 u32 P_len
= enc_md_pos
- P_pos
;
16120 char *id_len_pos
= strchr (enc_md_pos
, '*');
16122 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16124 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16128 char *id_buf_pos
= strchr (id_len_pos
, '*');
16130 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16132 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16136 char *u_len_pos
= strchr (id_buf_pos
, '*');
16138 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16140 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16142 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16146 char *u_buf_pos
= strchr (u_len_pos
, '*');
16148 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16150 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16154 char *o_len_pos
= strchr (u_buf_pos
, '*');
16156 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16158 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16160 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16164 char *o_buf_pos
= strchr (o_len_pos
, '*');
16166 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16168 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16172 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;
16174 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16178 const int V
= atoi (V_pos
);
16179 const int R
= atoi (R_pos
);
16180 const int P
= atoi (P_pos
);
16182 if (V
!= 1) return (PARSER_SALT_VALUE
);
16183 if (R
!= 2) return (PARSER_SALT_VALUE
);
16185 const int enc_md
= atoi (enc_md_pos
);
16187 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16189 const int id_len
= atoi (id_len_pos
);
16190 const int u_len
= atoi (u_len_pos
);
16191 const int o_len
= atoi (o_len_pos
);
16193 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16194 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16195 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16197 const int bits
= atoi (bits_pos
);
16199 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16201 // copy data to esalt
16207 pdf
->enc_md
= enc_md
;
16209 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16210 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16211 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16212 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16213 pdf
->id_len
= id_len
;
16215 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16216 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16217 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16218 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16219 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16220 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16221 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16222 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16223 pdf
->u_len
= u_len
;
16225 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16226 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16227 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16228 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16229 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16230 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16231 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16232 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16233 pdf
->o_len
= o_len
;
16235 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16236 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16237 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16238 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16240 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16241 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16242 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16243 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16244 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16245 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16246 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16247 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16249 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16250 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16251 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16252 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16253 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16254 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16255 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16256 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16258 // we use ID for salt, maybe needs to change, we will see...
16260 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16261 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16262 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16263 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16264 salt
->salt_len
= pdf
->id_len
;
16266 digest
[0] = pdf
->u_buf
[0];
16267 digest
[1] = pdf
->u_buf
[1];
16268 digest
[2] = pdf
->u_buf
[2];
16269 digest
[3] = pdf
->u_buf
[3];
16271 return (PARSER_OK
);
16274 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16276 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16279 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16281 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16283 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16285 u32
*digest
= (u32
*) hash_buf
->digest
;
16287 salt_t
*salt
= hash_buf
->salt
;
16289 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16295 char *V_pos
= input_buf
+ 5;
16297 char *R_pos
= strchr (V_pos
, '*');
16299 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16301 u32 V_len
= R_pos
- V_pos
;
16305 char *bits_pos
= strchr (R_pos
, '*');
16307 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16309 u32 R_len
= bits_pos
- R_pos
;
16313 char *P_pos
= strchr (bits_pos
, '*');
16315 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16317 u32 bits_len
= P_pos
- bits_pos
;
16321 char *enc_md_pos
= strchr (P_pos
, '*');
16323 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16325 u32 P_len
= enc_md_pos
- P_pos
;
16329 char *id_len_pos
= strchr (enc_md_pos
, '*');
16331 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16333 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16337 char *id_buf_pos
= strchr (id_len_pos
, '*');
16339 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16341 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16345 char *u_len_pos
= strchr (id_buf_pos
, '*');
16347 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16349 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16351 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16355 char *u_buf_pos
= strchr (u_len_pos
, '*');
16357 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16359 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16363 char *o_len_pos
= strchr (u_buf_pos
, '*');
16365 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16367 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16369 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16373 char *o_buf_pos
= strchr (o_len_pos
, '*');
16375 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16377 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16381 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16383 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16385 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16387 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16391 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;
16393 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16397 const int V
= atoi (V_pos
);
16398 const int R
= atoi (R_pos
);
16399 const int P
= atoi (P_pos
);
16401 if (V
!= 1) return (PARSER_SALT_VALUE
);
16402 if (R
!= 2) return (PARSER_SALT_VALUE
);
16404 const int enc_md
= atoi (enc_md_pos
);
16406 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16408 const int id_len
= atoi (id_len_pos
);
16409 const int u_len
= atoi (u_len_pos
);
16410 const int o_len
= atoi (o_len_pos
);
16412 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16413 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16414 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16416 const int bits
= atoi (bits_pos
);
16418 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16420 // copy data to esalt
16426 pdf
->enc_md
= enc_md
;
16428 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16429 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16430 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16431 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16432 pdf
->id_len
= id_len
;
16434 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16435 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16436 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16437 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16438 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16439 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16440 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16441 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16442 pdf
->u_len
= u_len
;
16444 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16445 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16446 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16447 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16448 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16449 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16450 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16451 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16452 pdf
->o_len
= o_len
;
16454 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16455 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16456 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16457 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16459 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16460 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16461 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16462 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16463 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16464 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16465 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16466 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16468 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16469 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16470 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16471 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16472 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16473 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16474 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16475 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16477 pdf
->rc4key
[1] = 0;
16478 pdf
->rc4key
[0] = 0;
16480 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16481 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16482 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16483 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16484 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16485 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16486 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16487 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16488 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16489 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16491 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16492 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16494 // we use ID for salt, maybe needs to change, we will see...
16496 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16497 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16498 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16499 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16500 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16501 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16502 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16503 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16504 salt
->salt_len
= pdf
->id_len
+ 16;
16506 digest
[0] = pdf
->rc4key
[0];
16507 digest
[1] = pdf
->rc4key
[1];
16511 return (PARSER_OK
);
16514 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16516 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16518 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16520 u32
*digest
= (u32
*) hash_buf
->digest
;
16522 salt_t
*salt
= hash_buf
->salt
;
16524 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16530 char *V_pos
= input_buf
+ 5;
16532 char *R_pos
= strchr (V_pos
, '*');
16534 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16536 u32 V_len
= R_pos
- V_pos
;
16540 char *bits_pos
= strchr (R_pos
, '*');
16542 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16544 u32 R_len
= bits_pos
- R_pos
;
16548 char *P_pos
= strchr (bits_pos
, '*');
16550 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16552 u32 bits_len
= P_pos
- bits_pos
;
16556 char *enc_md_pos
= strchr (P_pos
, '*');
16558 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16560 u32 P_len
= enc_md_pos
- P_pos
;
16564 char *id_len_pos
= strchr (enc_md_pos
, '*');
16566 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16568 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16572 char *id_buf_pos
= strchr (id_len_pos
, '*');
16574 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16576 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16580 char *u_len_pos
= strchr (id_buf_pos
, '*');
16582 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16584 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16586 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16590 char *u_buf_pos
= strchr (u_len_pos
, '*');
16592 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16594 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16598 char *o_len_pos
= strchr (u_buf_pos
, '*');
16600 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16602 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16604 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16608 char *o_buf_pos
= strchr (o_len_pos
, '*');
16610 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16612 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16616 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;
16618 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16622 const int V
= atoi (V_pos
);
16623 const int R
= atoi (R_pos
);
16624 const int P
= atoi (P_pos
);
16628 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16629 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16631 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16633 const int id_len
= atoi (id_len_pos
);
16634 const int u_len
= atoi (u_len_pos
);
16635 const int o_len
= atoi (o_len_pos
);
16637 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16639 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16640 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16642 const int bits
= atoi (bits_pos
);
16644 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16650 enc_md
= atoi (enc_md_pos
);
16653 // copy data to esalt
16659 pdf
->enc_md
= enc_md
;
16661 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16662 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16663 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16664 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16668 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16669 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16670 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16671 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16674 pdf
->id_len
= id_len
;
16676 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16677 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16678 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16679 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16680 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16681 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16682 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16683 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16684 pdf
->u_len
= u_len
;
16686 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16687 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16688 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16689 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16690 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16691 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16692 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16693 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16694 pdf
->o_len
= o_len
;
16696 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16697 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16698 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16699 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16703 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16704 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16705 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16706 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16709 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16710 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16711 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16712 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16713 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16714 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16715 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16716 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16718 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16719 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16720 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16721 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16722 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16723 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16724 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16725 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16727 // precompute rc4 data for later use
16743 uint salt_pc_block
[32] = { 0 };
16745 char *salt_pc_ptr
= (char *) salt_pc_block
;
16747 memcpy (salt_pc_ptr
, padding
, 32);
16748 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16750 uint salt_pc_digest
[4] = { 0 };
16752 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16754 pdf
->rc4data
[0] = salt_pc_digest
[0];
16755 pdf
->rc4data
[1] = salt_pc_digest
[1];
16757 // we use ID for salt, maybe needs to change, we will see...
16759 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16760 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16761 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16762 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16763 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16764 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16765 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16766 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16767 salt
->salt_len
= pdf
->id_len
+ 16;
16769 salt
->salt_iter
= ROUNDS_PDF14
;
16771 digest
[0] = pdf
->u_buf
[0];
16772 digest
[1] = pdf
->u_buf
[1];
16776 return (PARSER_OK
);
16779 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16781 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16783 if (ret
!= PARSER_OK
)
16788 u32
*digest
= (u32
*) hash_buf
->digest
;
16790 salt_t
*salt
= hash_buf
->salt
;
16792 digest
[0] -= SHA256M_A
;
16793 digest
[1] -= SHA256M_B
;
16794 digest
[2] -= SHA256M_C
;
16795 digest
[3] -= SHA256M_D
;
16796 digest
[4] -= SHA256M_E
;
16797 digest
[5] -= SHA256M_F
;
16798 digest
[6] -= SHA256M_G
;
16799 digest
[7] -= SHA256M_H
;
16801 salt
->salt_buf
[2] = 0x80;
16803 return (PARSER_OK
);
16806 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16808 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16810 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16812 u32
*digest
= (u32
*) hash_buf
->digest
;
16814 salt_t
*salt
= hash_buf
->salt
;
16816 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16822 char *V_pos
= input_buf
+ 5;
16824 char *R_pos
= strchr (V_pos
, '*');
16826 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16828 u32 V_len
= R_pos
- V_pos
;
16832 char *bits_pos
= strchr (R_pos
, '*');
16834 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16836 u32 R_len
= bits_pos
- R_pos
;
16840 char *P_pos
= strchr (bits_pos
, '*');
16842 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16844 u32 bits_len
= P_pos
- bits_pos
;
16848 char *enc_md_pos
= strchr (P_pos
, '*');
16850 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16852 u32 P_len
= enc_md_pos
- P_pos
;
16856 char *id_len_pos
= strchr (enc_md_pos
, '*');
16858 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16860 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16864 char *id_buf_pos
= strchr (id_len_pos
, '*');
16866 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16868 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16872 char *u_len_pos
= strchr (id_buf_pos
, '*');
16874 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16876 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16880 char *u_buf_pos
= strchr (u_len_pos
, '*');
16882 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16884 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16888 char *o_len_pos
= strchr (u_buf_pos
, '*');
16890 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16892 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16896 char *o_buf_pos
= strchr (o_len_pos
, '*');
16898 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16900 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16904 char *last
= strchr (o_buf_pos
, '*');
16906 if (last
== NULL
) last
= input_buf
+ input_len
;
16908 u32 o_buf_len
= last
- o_buf_pos
;
16912 const int V
= atoi (V_pos
);
16913 const int R
= atoi (R_pos
);
16917 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16918 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16920 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16922 const int bits
= atoi (bits_pos
);
16924 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16926 int enc_md
= atoi (enc_md_pos
);
16928 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16930 const uint id_len
= atoi (id_len_pos
);
16931 const uint u_len
= atoi (u_len_pos
);
16932 const uint o_len
= atoi (o_len_pos
);
16934 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16935 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16936 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16937 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16938 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16939 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16940 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16941 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16943 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16944 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16945 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16947 // copy data to esalt
16949 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16951 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16953 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
16956 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16957 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16959 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16960 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16962 salt
->salt_len
= 8;
16963 salt
->salt_iter
= ROUNDS_PDF17L8
;
16965 digest
[0] = pdf
->u_buf
[0];
16966 digest
[1] = pdf
->u_buf
[1];
16967 digest
[2] = pdf
->u_buf
[2];
16968 digest
[3] = pdf
->u_buf
[3];
16969 digest
[4] = pdf
->u_buf
[4];
16970 digest
[5] = pdf
->u_buf
[5];
16971 digest
[6] = pdf
->u_buf
[6];
16972 digest
[7] = pdf
->u_buf
[7];
16974 return (PARSER_OK
);
16977 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16979 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
16981 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
16983 u32
*digest
= (u32
*) hash_buf
->digest
;
16985 salt_t
*salt
= hash_buf
->salt
;
16987 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16995 char *iter_pos
= input_buf
+ 7;
16997 u32 iter
= atoi (iter_pos
);
16999 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17000 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17002 // first is *raw* salt
17004 char *salt_pos
= strchr (iter_pos
, ':');
17006 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17010 char *hash_pos
= strchr (salt_pos
, ':');
17012 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17014 u32 salt_len
= hash_pos
- salt_pos
;
17016 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17020 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17022 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17026 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17028 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17030 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17032 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17033 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17035 salt
->salt_len
= salt_len
;
17036 salt
->salt_iter
= iter
- 1;
17040 u8 tmp_buf
[100] = { 0 };
17042 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17044 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17046 memcpy (digest
, tmp_buf
, 16);
17048 digest
[0] = byte_swap_32 (digest
[0]);
17049 digest
[1] = byte_swap_32 (digest
[1]);
17050 digest
[2] = byte_swap_32 (digest
[2]);
17051 digest
[3] = byte_swap_32 (digest
[3]);
17053 // add some stuff to normal salt to make sorted happy
17055 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17056 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17057 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17058 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17059 salt
->salt_buf
[4] = salt
->salt_iter
;
17061 return (PARSER_OK
);
17064 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17066 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17068 u32
*digest
= (u32
*) hash_buf
->digest
;
17070 salt_t
*salt
= hash_buf
->salt
;
17072 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17073 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17074 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17075 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17077 digest
[0] = byte_swap_32 (digest
[0]);
17078 digest
[1] = byte_swap_32 (digest
[1]);
17079 digest
[2] = byte_swap_32 (digest
[2]);
17080 digest
[3] = byte_swap_32 (digest
[3]);
17082 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17084 uint salt_len
= input_len
- 32 - 1;
17086 char *salt_buf
= input_buf
+ 32 + 1;
17088 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17090 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17092 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17094 salt
->salt_len
= salt_len
;
17096 return (PARSER_OK
);
17099 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17101 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17103 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17105 u32
*digest
= (u32
*) hash_buf
->digest
;
17107 salt_t
*salt
= hash_buf
->salt
;
17109 char *user_pos
= input_buf
+ 10;
17111 char *salt_pos
= strchr (user_pos
, '*');
17113 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17117 char *hash_pos
= strchr (salt_pos
, '*');
17121 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17123 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17125 uint user_len
= salt_pos
- user_pos
- 1;
17127 uint salt_len
= hash_pos
- salt_pos
- 1;
17129 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17135 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17136 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17137 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17138 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17140 digest
[0] = byte_swap_32 (digest
[0]);
17141 digest
[1] = byte_swap_32 (digest
[1]);
17142 digest
[2] = byte_swap_32 (digest
[2]);
17143 digest
[3] = byte_swap_32 (digest
[3]);
17145 digest
[0] -= MD5M_A
;
17146 digest
[1] -= MD5M_B
;
17147 digest
[2] -= MD5M_C
;
17148 digest
[3] -= MD5M_D
;
17154 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17156 // first 4 bytes are the "challenge"
17158 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17159 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17160 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17161 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17163 // append the user name
17165 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17167 salt
->salt_len
= 4 + user_len
;
17169 return (PARSER_OK
);
17172 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17174 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17176 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17178 u32
*digest
= (u32
*) hash_buf
->digest
;
17180 salt_t
*salt
= hash_buf
->salt
;
17182 char *salt_pos
= input_buf
+ 9;
17184 char *hash_pos
= strchr (salt_pos
, '*');
17186 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17190 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17192 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17194 uint salt_len
= hash_pos
- salt_pos
- 1;
17196 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17202 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17203 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17204 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17205 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17206 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17212 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17214 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17216 salt
->salt_len
= salt_len
;
17218 return (PARSER_OK
);
17221 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17223 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17225 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17227 u32
*digest
= (u32
*) hash_buf
->digest
;
17229 salt_t
*salt
= hash_buf
->salt
;
17231 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17237 char *cry_master_len_pos
= input_buf
+ 9;
17239 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17241 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17243 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17245 cry_master_buf_pos
++;
17247 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17249 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17251 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17253 cry_salt_len_pos
++;
17255 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17257 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17259 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17261 cry_salt_buf_pos
++;
17263 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17265 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17267 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17271 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17273 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17275 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17279 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17281 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17283 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17287 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17289 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17291 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17293 public_key_len_pos
++;
17295 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17297 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17299 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17301 public_key_buf_pos
++;
17303 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;
17305 const uint cry_master_len
= atoi (cry_master_len_pos
);
17306 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17307 const uint ckey_len
= atoi (ckey_len_pos
);
17308 const uint public_key_len
= atoi (public_key_len_pos
);
17310 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17311 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17312 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17313 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17315 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17317 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17319 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17322 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17324 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17326 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17329 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17331 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17333 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17336 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17337 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17338 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17341 * store digest (should be unique enought, hopefully)
17344 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17345 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17346 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17347 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17353 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17355 const uint cry_rounds
= atoi (cry_rounds_pos
);
17357 salt
->salt_iter
= cry_rounds
- 1;
17359 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17361 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17363 salt
->salt_len
= salt_len
;
17365 return (PARSER_OK
);
17368 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17370 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17372 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17374 u32
*digest
= (u32
*) hash_buf
->digest
;
17376 salt_t
*salt
= hash_buf
->salt
;
17378 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17380 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17382 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17384 memcpy (temp_input_buf
, input_buf
, input_len
);
17388 char *URI_server_pos
= temp_input_buf
+ 6;
17390 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17392 if (URI_client_pos
== NULL
)
17394 myfree (temp_input_buf
);
17396 return (PARSER_SEPARATOR_UNMATCHED
);
17399 URI_client_pos
[0] = 0;
17402 uint URI_server_len
= strlen (URI_server_pos
);
17404 if (URI_server_len
> 512)
17406 myfree (temp_input_buf
);
17408 return (PARSER_SALT_LENGTH
);
17413 char *user_pos
= strchr (URI_client_pos
, '*');
17415 if (user_pos
== NULL
)
17417 myfree (temp_input_buf
);
17419 return (PARSER_SEPARATOR_UNMATCHED
);
17425 uint URI_client_len
= strlen (URI_client_pos
);
17427 if (URI_client_len
> 512)
17429 myfree (temp_input_buf
);
17431 return (PARSER_SALT_LENGTH
);
17436 char *realm_pos
= strchr (user_pos
, '*');
17438 if (realm_pos
== NULL
)
17440 myfree (temp_input_buf
);
17442 return (PARSER_SEPARATOR_UNMATCHED
);
17448 uint user_len
= strlen (user_pos
);
17450 if (user_len
> 116)
17452 myfree (temp_input_buf
);
17454 return (PARSER_SALT_LENGTH
);
17459 char *method_pos
= strchr (realm_pos
, '*');
17461 if (method_pos
== NULL
)
17463 myfree (temp_input_buf
);
17465 return (PARSER_SEPARATOR_UNMATCHED
);
17471 uint realm_len
= strlen (realm_pos
);
17473 if (realm_len
> 116)
17475 myfree (temp_input_buf
);
17477 return (PARSER_SALT_LENGTH
);
17482 char *URI_prefix_pos
= strchr (method_pos
, '*');
17484 if (URI_prefix_pos
== NULL
)
17486 myfree (temp_input_buf
);
17488 return (PARSER_SEPARATOR_UNMATCHED
);
17491 URI_prefix_pos
[0] = 0;
17494 uint method_len
= strlen (method_pos
);
17496 if (method_len
> 246)
17498 myfree (temp_input_buf
);
17500 return (PARSER_SALT_LENGTH
);
17505 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17507 if (URI_resource_pos
== NULL
)
17509 myfree (temp_input_buf
);
17511 return (PARSER_SEPARATOR_UNMATCHED
);
17514 URI_resource_pos
[0] = 0;
17515 URI_resource_pos
++;
17517 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17519 if (URI_prefix_len
> 245)
17521 myfree (temp_input_buf
);
17523 return (PARSER_SALT_LENGTH
);
17528 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17530 if (URI_suffix_pos
== NULL
)
17532 myfree (temp_input_buf
);
17534 return (PARSER_SEPARATOR_UNMATCHED
);
17537 URI_suffix_pos
[0] = 0;
17540 uint URI_resource_len
= strlen (URI_resource_pos
);
17542 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17544 myfree (temp_input_buf
);
17546 return (PARSER_SALT_LENGTH
);
17551 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17553 if (nonce_pos
== NULL
)
17555 myfree (temp_input_buf
);
17557 return (PARSER_SEPARATOR_UNMATCHED
);
17563 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17565 if (URI_suffix_len
> 245)
17567 myfree (temp_input_buf
);
17569 return (PARSER_SALT_LENGTH
);
17574 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17576 if (nonce_client_pos
== NULL
)
17578 myfree (temp_input_buf
);
17580 return (PARSER_SEPARATOR_UNMATCHED
);
17583 nonce_client_pos
[0] = 0;
17584 nonce_client_pos
++;
17586 uint nonce_len
= strlen (nonce_pos
);
17588 if (nonce_len
< 1 || nonce_len
> 50)
17590 myfree (temp_input_buf
);
17592 return (PARSER_SALT_LENGTH
);
17597 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17599 if (nonce_count_pos
== NULL
)
17601 myfree (temp_input_buf
);
17603 return (PARSER_SEPARATOR_UNMATCHED
);
17606 nonce_count_pos
[0] = 0;
17609 uint nonce_client_len
= strlen (nonce_client_pos
);
17611 if (nonce_client_len
> 50)
17613 myfree (temp_input_buf
);
17615 return (PARSER_SALT_LENGTH
);
17620 char *qop_pos
= strchr (nonce_count_pos
, '*');
17622 if (qop_pos
== NULL
)
17624 myfree (temp_input_buf
);
17626 return (PARSER_SEPARATOR_UNMATCHED
);
17632 uint nonce_count_len
= strlen (nonce_count_pos
);
17634 if (nonce_count_len
> 50)
17636 myfree (temp_input_buf
);
17638 return (PARSER_SALT_LENGTH
);
17643 char *directive_pos
= strchr (qop_pos
, '*');
17645 if (directive_pos
== NULL
)
17647 myfree (temp_input_buf
);
17649 return (PARSER_SEPARATOR_UNMATCHED
);
17652 directive_pos
[0] = 0;
17655 uint qop_len
= strlen (qop_pos
);
17659 myfree (temp_input_buf
);
17661 return (PARSER_SALT_LENGTH
);
17666 char *digest_pos
= strchr (directive_pos
, '*');
17668 if (digest_pos
== NULL
)
17670 myfree (temp_input_buf
);
17672 return (PARSER_SEPARATOR_UNMATCHED
);
17678 uint directive_len
= strlen (directive_pos
);
17680 if (directive_len
!= 3)
17682 myfree (temp_input_buf
);
17684 return (PARSER_SALT_LENGTH
);
17687 if (memcmp (directive_pos
, "MD5", 3))
17689 log_info ("ERROR: only the MD5 directive is currently supported\n");
17691 myfree (temp_input_buf
);
17693 return (PARSER_SIP_AUTH_DIRECTIVE
);
17697 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17702 uint md5_max_len
= 4 * 64;
17704 uint md5_remaining_len
= md5_max_len
;
17706 uint tmp_md5_buf
[64] = { 0 };
17708 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17710 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17712 md5_len
+= method_len
+ 1;
17713 tmp_md5_ptr
+= method_len
+ 1;
17715 if (URI_prefix_len
> 0)
17717 md5_remaining_len
= md5_max_len
- md5_len
;
17719 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17721 md5_len
+= URI_prefix_len
+ 1;
17722 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17725 md5_remaining_len
= md5_max_len
- md5_len
;
17727 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17729 md5_len
+= URI_resource_len
;
17730 tmp_md5_ptr
+= URI_resource_len
;
17732 if (URI_suffix_len
> 0)
17734 md5_remaining_len
= md5_max_len
- md5_len
;
17736 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17738 md5_len
+= 1 + URI_suffix_len
;
17741 uint tmp_digest
[4] = { 0 };
17743 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17745 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17746 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17747 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17748 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17754 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17756 uint esalt_len
= 0;
17758 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17760 // there are 2 possibilities for the esalt:
17762 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17764 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17766 if (esalt_len
> max_esalt_len
)
17768 myfree (temp_input_buf
);
17770 return (PARSER_SALT_LENGTH
);
17773 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17785 esalt_len
= 1 + nonce_len
+ 1 + 32;
17787 if (esalt_len
> max_esalt_len
)
17789 myfree (temp_input_buf
);
17791 return (PARSER_SALT_LENGTH
);
17794 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17802 // add 0x80 to esalt
17804 esalt_buf_ptr
[esalt_len
] = 0x80;
17806 sip
->esalt_len
= esalt_len
;
17812 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17814 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17816 uint max_salt_len
= 119;
17818 if (salt_len
> max_salt_len
)
17820 myfree (temp_input_buf
);
17822 return (PARSER_SALT_LENGTH
);
17825 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17827 sip
->salt_len
= salt_len
;
17830 * fake salt (for sorting)
17833 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17837 uint fake_salt_len
= salt_len
;
17839 if (fake_salt_len
> max_salt_len
)
17841 fake_salt_len
= max_salt_len
;
17844 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17846 salt
->salt_len
= fake_salt_len
;
17852 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17853 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17854 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17855 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17857 digest
[0] = byte_swap_32 (digest
[0]);
17858 digest
[1] = byte_swap_32 (digest
[1]);
17859 digest
[2] = byte_swap_32 (digest
[2]);
17860 digest
[3] = byte_swap_32 (digest
[3]);
17862 myfree (temp_input_buf
);
17864 return (PARSER_OK
);
17867 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17869 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17871 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17873 u32
*digest
= (u32
*) hash_buf
->digest
;
17875 salt_t
*salt
= hash_buf
->salt
;
17879 char *digest_pos
= input_buf
;
17881 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17888 char *salt_buf
= input_buf
+ 8 + 1;
17892 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17894 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17896 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17898 salt
->salt_len
= salt_len
;
17900 return (PARSER_OK
);
17903 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17905 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17907 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17909 u32
*digest
= (u32
*) hash_buf
->digest
;
17911 salt_t
*salt
= hash_buf
->salt
;
17913 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17919 char *p_buf_pos
= input_buf
+ 4;
17921 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17923 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17925 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17927 NumCyclesPower_pos
++;
17929 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17931 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17933 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17937 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17939 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17941 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
17945 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17947 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17949 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17953 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17955 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17957 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
17961 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17963 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17965 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17969 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17971 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17973 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
17977 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17979 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17981 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
17985 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17987 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17989 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17993 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;
17995 const uint iter
= atoi (NumCyclesPower_pos
);
17996 const uint crc
= atoi (crc_buf_pos
);
17997 const uint p_buf
= atoi (p_buf_pos
);
17998 const uint salt_len
= atoi (salt_len_pos
);
17999 const uint iv_len
= atoi (iv_len_pos
);
18000 const uint unpack_size
= atoi (unpack_size_pos
);
18001 const uint data_len
= atoi (data_len_pos
);
18007 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18008 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18010 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18012 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18014 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18020 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18021 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18022 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18023 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18025 seven_zip
->iv_len
= iv_len
;
18027 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18029 seven_zip
->salt_len
= 0;
18031 seven_zip
->crc
= crc
;
18033 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18035 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18037 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18040 seven_zip
->data_len
= data_len
;
18042 seven_zip
->unpack_size
= unpack_size
;
18046 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18047 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18048 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18049 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18051 salt
->salt_len
= 16;
18053 salt
->salt_sign
[0] = iter
;
18055 salt
->salt_iter
= 1 << iter
;
18066 return (PARSER_OK
);
18069 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18071 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18073 u32
*digest
= (u32
*) hash_buf
->digest
;
18075 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18076 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18077 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18078 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18079 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18080 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18081 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18082 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18084 digest
[0] = byte_swap_32 (digest
[0]);
18085 digest
[1] = byte_swap_32 (digest
[1]);
18086 digest
[2] = byte_swap_32 (digest
[2]);
18087 digest
[3] = byte_swap_32 (digest
[3]);
18088 digest
[4] = byte_swap_32 (digest
[4]);
18089 digest
[5] = byte_swap_32 (digest
[5]);
18090 digest
[6] = byte_swap_32 (digest
[6]);
18091 digest
[7] = byte_swap_32 (digest
[7]);
18093 return (PARSER_OK
);
18096 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18098 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18100 u32
*digest
= (u32
*) hash_buf
->digest
;
18102 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18103 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18104 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18105 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18106 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18107 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18108 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18109 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18110 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18111 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18112 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18113 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18114 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18115 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18116 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18117 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18119 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18120 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18121 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18122 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18123 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18124 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18125 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18126 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18127 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18128 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18129 digest
[10] = byte_swap_32 (digest
[10]);
18130 digest
[11] = byte_swap_32 (digest
[11]);
18131 digest
[12] = byte_swap_32 (digest
[12]);
18132 digest
[13] = byte_swap_32 (digest
[13]);
18133 digest
[14] = byte_swap_32 (digest
[14]);
18134 digest
[15] = byte_swap_32 (digest
[15]);
18136 return (PARSER_OK
);
18139 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18141 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18143 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18145 u32
*digest
= (u32
*) hash_buf
->digest
;
18147 salt_t
*salt
= hash_buf
->salt
;
18149 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18157 char *iter_pos
= input_buf
+ 4;
18159 u32 iter
= atoi (iter_pos
);
18161 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18162 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18164 // first is *raw* salt
18166 char *salt_pos
= strchr (iter_pos
, ':');
18168 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18172 char *hash_pos
= strchr (salt_pos
, ':');
18174 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18176 u32 salt_len
= hash_pos
- salt_pos
;
18178 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18182 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18184 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18188 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18190 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18192 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18194 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18195 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18197 salt
->salt_len
= salt_len
;
18198 salt
->salt_iter
= iter
- 1;
18202 u8 tmp_buf
[100] = { 0 };
18204 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18206 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18208 memcpy (digest
, tmp_buf
, 16);
18210 // add some stuff to normal salt to make sorted happy
18212 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18213 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18214 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18215 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18216 salt
->salt_buf
[4] = salt
->salt_iter
;
18218 return (PARSER_OK
);
18221 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18223 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18225 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18227 u32
*digest
= (u32
*) hash_buf
->digest
;
18229 salt_t
*salt
= hash_buf
->salt
;
18231 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18239 char *iter_pos
= input_buf
+ 5;
18241 u32 iter
= atoi (iter_pos
);
18243 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18244 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18246 // first is *raw* salt
18248 char *salt_pos
= strchr (iter_pos
, ':');
18250 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18254 char *hash_pos
= strchr (salt_pos
, ':');
18256 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18258 u32 salt_len
= hash_pos
- salt_pos
;
18260 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18264 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18266 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18270 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18272 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18274 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18276 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18277 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18279 salt
->salt_len
= salt_len
;
18280 salt
->salt_iter
= iter
- 1;
18284 u8 tmp_buf
[100] = { 0 };
18286 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18288 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18290 memcpy (digest
, tmp_buf
, 16);
18292 digest
[0] = byte_swap_32 (digest
[0]);
18293 digest
[1] = byte_swap_32 (digest
[1]);
18294 digest
[2] = byte_swap_32 (digest
[2]);
18295 digest
[3] = byte_swap_32 (digest
[3]);
18297 // add some stuff to normal salt to make sorted happy
18299 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18300 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18301 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18302 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18303 salt
->salt_buf
[4] = salt
->salt_iter
;
18305 return (PARSER_OK
);
18308 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18310 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18312 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18314 u64
*digest
= (u64
*) hash_buf
->digest
;
18316 salt_t
*salt
= hash_buf
->salt
;
18318 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18326 char *iter_pos
= input_buf
+ 7;
18328 u32 iter
= atoi (iter_pos
);
18330 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18331 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18333 // first is *raw* salt
18335 char *salt_pos
= strchr (iter_pos
, ':');
18337 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18341 char *hash_pos
= strchr (salt_pos
, ':');
18343 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18345 u32 salt_len
= hash_pos
- salt_pos
;
18347 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18351 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18353 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18357 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18359 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18361 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18363 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18364 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18366 salt
->salt_len
= salt_len
;
18367 salt
->salt_iter
= iter
- 1;
18371 u8 tmp_buf
[100] = { 0 };
18373 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18375 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18377 memcpy (digest
, tmp_buf
, 64);
18379 digest
[0] = byte_swap_64 (digest
[0]);
18380 digest
[1] = byte_swap_64 (digest
[1]);
18381 digest
[2] = byte_swap_64 (digest
[2]);
18382 digest
[3] = byte_swap_64 (digest
[3]);
18383 digest
[4] = byte_swap_64 (digest
[4]);
18384 digest
[5] = byte_swap_64 (digest
[5]);
18385 digest
[6] = byte_swap_64 (digest
[6]);
18386 digest
[7] = byte_swap_64 (digest
[7]);
18388 // add some stuff to normal salt to make sorted happy
18390 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18391 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18392 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18393 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18394 salt
->salt_buf
[4] = salt
->salt_iter
;
18396 return (PARSER_OK
);
18399 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18401 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18403 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18405 uint
*digest
= (uint
*) hash_buf
->digest
;
18407 salt_t
*salt
= hash_buf
->salt
;
18413 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18415 char *hash_pos
= strchr (salt_pos
, '$');
18417 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18419 u32 salt_len
= hash_pos
- salt_pos
;
18421 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18425 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18427 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18431 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18432 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18450 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18451 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18453 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18454 salt
->salt_len
= 8;
18456 return (PARSER_OK
);
18459 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18461 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18463 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18465 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18467 if (c19
& 3) return (PARSER_HASH_VALUE
);
18469 salt_t
*salt
= hash_buf
->salt
;
18471 u32
*digest
= (u32
*) hash_buf
->digest
;
18475 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18476 | itoa64_to_int (input_buf
[2]) << 6
18477 | itoa64_to_int (input_buf
[3]) << 12
18478 | itoa64_to_int (input_buf
[4]) << 18;
18482 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18483 | itoa64_to_int (input_buf
[6]) << 6
18484 | itoa64_to_int (input_buf
[7]) << 12
18485 | itoa64_to_int (input_buf
[8]) << 18;
18487 salt
->salt_len
= 4;
18489 u8 tmp_buf
[100] = { 0 };
18491 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18493 memcpy (digest
, tmp_buf
, 8);
18497 IP (digest
[0], digest
[1], tt
);
18499 digest
[0] = rotr32 (digest
[0], 31);
18500 digest
[1] = rotr32 (digest
[1], 31);
18504 return (PARSER_OK
);
18507 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18509 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18511 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18513 u32
*digest
= (u32
*) hash_buf
->digest
;
18515 salt_t
*salt
= hash_buf
->salt
;
18521 char *type_pos
= input_buf
+ 6 + 1;
18523 char *salt_pos
= strchr (type_pos
, '*');
18525 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18527 u32 type_len
= salt_pos
- type_pos
;
18529 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18533 char *crypted_pos
= strchr (salt_pos
, '*');
18535 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18537 u32 salt_len
= crypted_pos
- salt_pos
;
18539 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18543 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18545 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18551 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18552 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18554 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18555 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18557 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18558 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18559 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18560 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18562 salt
->salt_len
= 24;
18563 salt
->salt_iter
= ROUNDS_RAR3
;
18565 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18566 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18568 digest
[0] = 0xc43d7b00;
18569 digest
[1] = 0x40070000;
18573 return (PARSER_OK
);
18576 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18578 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18580 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18582 u32
*digest
= (u32
*) hash_buf
->digest
;
18584 salt_t
*salt
= hash_buf
->salt
;
18586 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18592 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18594 char *param1_pos
= strchr (param0_pos
, '$');
18596 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18598 u32 param0_len
= param1_pos
- param0_pos
;
18602 char *param2_pos
= strchr (param1_pos
, '$');
18604 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18606 u32 param1_len
= param2_pos
- param1_pos
;
18610 char *param3_pos
= strchr (param2_pos
, '$');
18612 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18614 u32 param2_len
= param3_pos
- param2_pos
;
18618 char *param4_pos
= strchr (param3_pos
, '$');
18620 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18622 u32 param3_len
= param4_pos
- param3_pos
;
18626 char *param5_pos
= strchr (param4_pos
, '$');
18628 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18630 u32 param4_len
= param5_pos
- param4_pos
;
18634 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18636 char *salt_buf
= param1_pos
;
18637 char *iv
= param3_pos
;
18638 char *pswcheck
= param5_pos
;
18640 const uint salt_len
= atoi (param0_pos
);
18641 const uint iterations
= atoi (param2_pos
);
18642 const uint pswcheck_len
= atoi (param4_pos
);
18648 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18649 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18650 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18652 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18653 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18654 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18660 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18661 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18662 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18663 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18665 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18666 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18667 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18668 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18670 salt
->salt_len
= 16;
18672 salt
->salt_sign
[0] = iterations
;
18674 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18680 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18681 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18685 return (PARSER_OK
);
18688 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18690 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18692 u32
*digest
= (u32
*) hash_buf
->digest
;
18694 salt_t
*salt
= hash_buf
->salt
;
18696 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18697 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18698 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18699 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18700 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18701 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18702 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18703 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18705 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18707 uint salt_len
= input_len
- 64 - 1;
18709 char *salt_buf
= input_buf
+ 64 + 1;
18711 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18713 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18715 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18717 salt
->salt_len
= salt_len
;
18720 * we can precompute the first sha256 transform
18723 uint w
[16] = { 0 };
18725 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18726 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18727 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18728 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18729 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18730 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18731 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18732 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18733 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18734 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18735 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18736 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18737 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18738 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18739 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18740 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18742 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
18744 sha256_64 (w
, pc256
);
18746 salt
->salt_buf_pc
[0] = pc256
[0];
18747 salt
->salt_buf_pc
[1] = pc256
[1];
18748 salt
->salt_buf_pc
[2] = pc256
[2];
18749 salt
->salt_buf_pc
[3] = pc256
[3];
18750 salt
->salt_buf_pc
[4] = pc256
[4];
18751 salt
->salt_buf_pc
[5] = pc256
[5];
18752 salt
->salt_buf_pc
[6] = pc256
[6];
18753 salt
->salt_buf_pc
[7] = pc256
[7];
18755 digest
[0] -= pc256
[0];
18756 digest
[1] -= pc256
[1];
18757 digest
[2] -= pc256
[2];
18758 digest
[3] -= pc256
[3];
18759 digest
[4] -= pc256
[4];
18760 digest
[5] -= pc256
[5];
18761 digest
[6] -= pc256
[6];
18762 digest
[7] -= pc256
[7];
18764 return (PARSER_OK
);
18767 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18769 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18771 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18773 u32
*digest
= (u32
*) hash_buf
->digest
;
18775 salt_t
*salt
= hash_buf
->salt
;
18781 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18783 char *data_buf_pos
= strchr (data_len_pos
, '$');
18785 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18787 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18789 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18790 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18794 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18796 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18798 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18800 u32 data_len
= atoi (data_len_pos
);
18802 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18808 char *salt_pos
= data_buf_pos
;
18810 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18811 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18812 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
18813 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
18815 // this is actually the CT, which is also the hash later (if matched)
18817 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
18818 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
18819 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
18820 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
18822 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18824 salt
->salt_iter
= 10 - 1;
18830 digest
[0] = salt
->salt_buf
[4];
18831 digest
[1] = salt
->salt_buf
[5];
18832 digest
[2] = salt
->salt_buf
[6];
18833 digest
[3] = salt
->salt_buf
[7];
18835 return (PARSER_OK
);
18838 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18840 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18842 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18844 u32
*digest
= (u32
*) hash_buf
->digest
;
18846 salt_t
*salt
= hash_buf
->salt
;
18852 char *salt_pos
= input_buf
+ 11 + 1;
18854 char *iter_pos
= strchr (salt_pos
, ',');
18856 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18858 u32 salt_len
= iter_pos
- salt_pos
;
18860 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18864 char *hash_pos
= strchr (iter_pos
, ',');
18866 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18868 u32 iter_len
= hash_pos
- iter_pos
;
18870 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18874 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18876 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18882 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18883 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18884 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
18885 salt
->salt_buf
[3] = 0x00018000;
18887 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18888 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18889 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18890 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18892 salt
->salt_len
= salt_len
/ 2;
18894 salt
->salt_iter
= atoi (iter_pos
) - 1;
18900 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18901 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18902 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18903 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18904 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18905 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18906 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18907 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18909 return (PARSER_OK
);
18912 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18914 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
18916 u32
*digest
= (u32
*) hash_buf
->digest
;
18918 salt_t
*salt
= hash_buf
->salt
;
18924 char *hash_pos
= input_buf
+ 64;
18925 char *salt1_pos
= input_buf
+ 128;
18926 char *salt2_pos
= input_buf
;
18932 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
18933 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
18934 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
18935 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
18937 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
18938 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
18939 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
18940 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
18942 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
18943 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
18944 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
18945 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
18947 salt
->salt_len
= 48;
18949 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
18955 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18956 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18957 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18958 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18959 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18960 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
18961 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
18962 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
18964 return (PARSER_OK
);
18968 * parallel running threads
18973 BOOL WINAPI
sigHandler_default (DWORD sig
)
18977 case CTRL_CLOSE_EVENT
:
18980 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18981 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18982 * function otherwise it is too late (e.g. after returning from this function)
18987 SetConsoleCtrlHandler (NULL
, TRUE
);
18994 case CTRL_LOGOFF_EVENT
:
18995 case CTRL_SHUTDOWN_EVENT
:
18999 SetConsoleCtrlHandler (NULL
, TRUE
);
19007 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19011 case CTRL_CLOSE_EVENT
:
19015 SetConsoleCtrlHandler (NULL
, TRUE
);
19022 case CTRL_LOGOFF_EVENT
:
19023 case CTRL_SHUTDOWN_EVENT
:
19027 SetConsoleCtrlHandler (NULL
, TRUE
);
19035 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19037 if (callback
== NULL
)
19039 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19043 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19049 void sigHandler_default (int sig
)
19053 signal (sig
, NULL
);
19056 void sigHandler_benchmark (int sig
)
19060 signal (sig
, NULL
);
19063 void hc_signal (void (callback
) (int))
19065 if (callback
== NULL
) callback
= SIG_DFL
;
19067 signal (SIGINT
, callback
);
19068 signal (SIGTERM
, callback
);
19069 signal (SIGABRT
, callback
);
19074 void status_display ();
19076 void *thread_keypress (void *p
)
19078 int benchmark
= *((int *) p
);
19080 uint quiet
= data
.quiet
;
19084 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19086 int ch
= tty_getchar();
19088 if (ch
== -1) break;
19090 if (ch
== 0) continue;
19096 hc_thread_mutex_lock (mux_display
);
19111 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19112 if (quiet
== 0) fflush (stdout
);
19124 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19125 if (quiet
== 0) fflush (stdout
);
19137 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19138 if (quiet
== 0) fflush (stdout
);
19150 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19151 if (quiet
== 0) fflush (stdout
);
19159 if (benchmark
== 1) break;
19161 stop_at_checkpoint ();
19165 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19166 if (quiet
== 0) fflush (stdout
);
19174 if (benchmark
== 1)
19186 hc_thread_mutex_unlock (mux_display
);
19198 bool class_num (const u8 c
)
19200 return ((c
>= '0') && (c
<= '9'));
19203 bool class_lower (const u8 c
)
19205 return ((c
>= 'a') && (c
<= 'z'));
19208 bool class_upper (const u8 c
)
19210 return ((c
>= 'A') && (c
<= 'Z'));
19213 bool class_alpha (const u8 c
)
19215 return (class_lower (c
) || class_upper (c
));
19218 int conv_ctoi (const u8 c
)
19224 else if (class_upper (c
))
19226 return c
- 'A' + 10;
19232 int conv_itoc (const u8 c
)
19240 return c
+ 'A' - 10;
19250 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19251 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19252 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19253 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19254 #define MAX_KERNEL_RULES 255
19255 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19256 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19257 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19259 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19260 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19261 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19262 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19264 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19269 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19271 switch (rule_buf
[rule_pos
])
19277 case RULE_OP_MANGLE_NOOP
:
19278 SET_NAME (rule
, rule_buf
[rule_pos
]);
19281 case RULE_OP_MANGLE_LREST
:
19282 SET_NAME (rule
, rule_buf
[rule_pos
]);
19285 case RULE_OP_MANGLE_UREST
:
19286 SET_NAME (rule
, rule_buf
[rule_pos
]);
19289 case RULE_OP_MANGLE_LREST_UFIRST
:
19290 SET_NAME (rule
, rule_buf
[rule_pos
]);
19293 case RULE_OP_MANGLE_UREST_LFIRST
:
19294 SET_NAME (rule
, rule_buf
[rule_pos
]);
19297 case RULE_OP_MANGLE_TREST
:
19298 SET_NAME (rule
, rule_buf
[rule_pos
]);
19301 case RULE_OP_MANGLE_TOGGLE_AT
:
19302 SET_NAME (rule
, rule_buf
[rule_pos
]);
19303 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19306 case RULE_OP_MANGLE_REVERSE
:
19307 SET_NAME (rule
, rule_buf
[rule_pos
]);
19310 case RULE_OP_MANGLE_DUPEWORD
:
19311 SET_NAME (rule
, rule_buf
[rule_pos
]);
19314 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19315 SET_NAME (rule
, rule_buf
[rule_pos
]);
19316 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19319 case RULE_OP_MANGLE_REFLECT
:
19320 SET_NAME (rule
, rule_buf
[rule_pos
]);
19323 case RULE_OP_MANGLE_ROTATE_LEFT
:
19324 SET_NAME (rule
, rule_buf
[rule_pos
]);
19327 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19328 SET_NAME (rule
, rule_buf
[rule_pos
]);
19331 case RULE_OP_MANGLE_APPEND
:
19332 SET_NAME (rule
, rule_buf
[rule_pos
]);
19333 SET_P0 (rule
, rule_buf
[rule_pos
]);
19336 case RULE_OP_MANGLE_PREPEND
:
19337 SET_NAME (rule
, rule_buf
[rule_pos
]);
19338 SET_P0 (rule
, rule_buf
[rule_pos
]);
19341 case RULE_OP_MANGLE_DELETE_FIRST
:
19342 SET_NAME (rule
, rule_buf
[rule_pos
]);
19345 case RULE_OP_MANGLE_DELETE_LAST
:
19346 SET_NAME (rule
, rule_buf
[rule_pos
]);
19349 case RULE_OP_MANGLE_DELETE_AT
:
19350 SET_NAME (rule
, rule_buf
[rule_pos
]);
19351 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19354 case RULE_OP_MANGLE_EXTRACT
:
19355 SET_NAME (rule
, rule_buf
[rule_pos
]);
19356 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19357 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19360 case RULE_OP_MANGLE_OMIT
:
19361 SET_NAME (rule
, rule_buf
[rule_pos
]);
19362 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19363 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19366 case RULE_OP_MANGLE_INSERT
:
19367 SET_NAME (rule
, rule_buf
[rule_pos
]);
19368 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19369 SET_P1 (rule
, rule_buf
[rule_pos
]);
19372 case RULE_OP_MANGLE_OVERSTRIKE
:
19373 SET_NAME (rule
, rule_buf
[rule_pos
]);
19374 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19375 SET_P1 (rule
, rule_buf
[rule_pos
]);
19378 case RULE_OP_MANGLE_TRUNCATE_AT
:
19379 SET_NAME (rule
, rule_buf
[rule_pos
]);
19380 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19383 case RULE_OP_MANGLE_REPLACE
:
19384 SET_NAME (rule
, rule_buf
[rule_pos
]);
19385 SET_P0 (rule
, rule_buf
[rule_pos
]);
19386 SET_P1 (rule
, rule_buf
[rule_pos
]);
19389 case RULE_OP_MANGLE_PURGECHAR
:
19393 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19397 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19398 SET_NAME (rule
, rule_buf
[rule_pos
]);
19399 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19402 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19403 SET_NAME (rule
, rule_buf
[rule_pos
]);
19404 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19407 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19408 SET_NAME (rule
, rule_buf
[rule_pos
]);
19411 case RULE_OP_MANGLE_SWITCH_FIRST
:
19412 SET_NAME (rule
, rule_buf
[rule_pos
]);
19415 case RULE_OP_MANGLE_SWITCH_LAST
:
19416 SET_NAME (rule
, rule_buf
[rule_pos
]);
19419 case RULE_OP_MANGLE_SWITCH_AT
:
19420 SET_NAME (rule
, rule_buf
[rule_pos
]);
19421 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19422 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19425 case RULE_OP_MANGLE_CHR_SHIFTL
:
19426 SET_NAME (rule
, rule_buf
[rule_pos
]);
19427 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19430 case RULE_OP_MANGLE_CHR_SHIFTR
:
19431 SET_NAME (rule
, rule_buf
[rule_pos
]);
19432 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19435 case RULE_OP_MANGLE_CHR_INCR
:
19436 SET_NAME (rule
, rule_buf
[rule_pos
]);
19437 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19440 case RULE_OP_MANGLE_CHR_DECR
:
19441 SET_NAME (rule
, rule_buf
[rule_pos
]);
19442 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19445 case RULE_OP_MANGLE_REPLACE_NP1
:
19446 SET_NAME (rule
, rule_buf
[rule_pos
]);
19447 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19450 case RULE_OP_MANGLE_REPLACE_NM1
:
19451 SET_NAME (rule
, rule_buf
[rule_pos
]);
19452 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19455 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19456 SET_NAME (rule
, rule_buf
[rule_pos
]);
19457 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19460 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19461 SET_NAME (rule
, rule_buf
[rule_pos
]);
19462 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19465 case RULE_OP_MANGLE_TITLE
:
19466 SET_NAME (rule
, rule_buf
[rule_pos
]);
19475 if (rule_pos
< rule_len
) return (-1);
19480 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19484 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19488 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19492 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19496 case RULE_OP_MANGLE_NOOP
:
19497 rule_buf
[rule_pos
] = rule_cmd
;
19500 case RULE_OP_MANGLE_LREST
:
19501 rule_buf
[rule_pos
] = rule_cmd
;
19504 case RULE_OP_MANGLE_UREST
:
19505 rule_buf
[rule_pos
] = rule_cmd
;
19508 case RULE_OP_MANGLE_LREST_UFIRST
:
19509 rule_buf
[rule_pos
] = rule_cmd
;
19512 case RULE_OP_MANGLE_UREST_LFIRST
:
19513 rule_buf
[rule_pos
] = rule_cmd
;
19516 case RULE_OP_MANGLE_TREST
:
19517 rule_buf
[rule_pos
] = rule_cmd
;
19520 case RULE_OP_MANGLE_TOGGLE_AT
:
19521 rule_buf
[rule_pos
] = rule_cmd
;
19522 GET_P0_CONV (rule
);
19525 case RULE_OP_MANGLE_REVERSE
:
19526 rule_buf
[rule_pos
] = rule_cmd
;
19529 case RULE_OP_MANGLE_DUPEWORD
:
19530 rule_buf
[rule_pos
] = rule_cmd
;
19533 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19534 rule_buf
[rule_pos
] = rule_cmd
;
19535 GET_P0_CONV (rule
);
19538 case RULE_OP_MANGLE_REFLECT
:
19539 rule_buf
[rule_pos
] = rule_cmd
;
19542 case RULE_OP_MANGLE_ROTATE_LEFT
:
19543 rule_buf
[rule_pos
] = rule_cmd
;
19546 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19547 rule_buf
[rule_pos
] = rule_cmd
;
19550 case RULE_OP_MANGLE_APPEND
:
19551 rule_buf
[rule_pos
] = rule_cmd
;
19555 case RULE_OP_MANGLE_PREPEND
:
19556 rule_buf
[rule_pos
] = rule_cmd
;
19560 case RULE_OP_MANGLE_DELETE_FIRST
:
19561 rule_buf
[rule_pos
] = rule_cmd
;
19564 case RULE_OP_MANGLE_DELETE_LAST
:
19565 rule_buf
[rule_pos
] = rule_cmd
;
19568 case RULE_OP_MANGLE_DELETE_AT
:
19569 rule_buf
[rule_pos
] = rule_cmd
;
19570 GET_P0_CONV (rule
);
19573 case RULE_OP_MANGLE_EXTRACT
:
19574 rule_buf
[rule_pos
] = rule_cmd
;
19575 GET_P0_CONV (rule
);
19576 GET_P1_CONV (rule
);
19579 case RULE_OP_MANGLE_OMIT
:
19580 rule_buf
[rule_pos
] = rule_cmd
;
19581 GET_P0_CONV (rule
);
19582 GET_P1_CONV (rule
);
19585 case RULE_OP_MANGLE_INSERT
:
19586 rule_buf
[rule_pos
] = rule_cmd
;
19587 GET_P0_CONV (rule
);
19591 case RULE_OP_MANGLE_OVERSTRIKE
:
19592 rule_buf
[rule_pos
] = rule_cmd
;
19593 GET_P0_CONV (rule
);
19597 case RULE_OP_MANGLE_TRUNCATE_AT
:
19598 rule_buf
[rule_pos
] = rule_cmd
;
19599 GET_P0_CONV (rule
);
19602 case RULE_OP_MANGLE_REPLACE
:
19603 rule_buf
[rule_pos
] = rule_cmd
;
19608 case RULE_OP_MANGLE_PURGECHAR
:
19612 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19616 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19617 rule_buf
[rule_pos
] = rule_cmd
;
19618 GET_P0_CONV (rule
);
19621 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19622 rule_buf
[rule_pos
] = rule_cmd
;
19623 GET_P0_CONV (rule
);
19626 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19627 rule_buf
[rule_pos
] = rule_cmd
;
19630 case RULE_OP_MANGLE_SWITCH_FIRST
:
19631 rule_buf
[rule_pos
] = rule_cmd
;
19634 case RULE_OP_MANGLE_SWITCH_LAST
:
19635 rule_buf
[rule_pos
] = rule_cmd
;
19638 case RULE_OP_MANGLE_SWITCH_AT
:
19639 rule_buf
[rule_pos
] = rule_cmd
;
19640 GET_P0_CONV (rule
);
19641 GET_P1_CONV (rule
);
19644 case RULE_OP_MANGLE_CHR_SHIFTL
:
19645 rule_buf
[rule_pos
] = rule_cmd
;
19646 GET_P0_CONV (rule
);
19649 case RULE_OP_MANGLE_CHR_SHIFTR
:
19650 rule_buf
[rule_pos
] = rule_cmd
;
19651 GET_P0_CONV (rule
);
19654 case RULE_OP_MANGLE_CHR_INCR
:
19655 rule_buf
[rule_pos
] = rule_cmd
;
19656 GET_P0_CONV (rule
);
19659 case RULE_OP_MANGLE_CHR_DECR
:
19660 rule_buf
[rule_pos
] = rule_cmd
;
19661 GET_P0_CONV (rule
);
19664 case RULE_OP_MANGLE_REPLACE_NP1
:
19665 rule_buf
[rule_pos
] = rule_cmd
;
19666 GET_P0_CONV (rule
);
19669 case RULE_OP_MANGLE_REPLACE_NM1
:
19670 rule_buf
[rule_pos
] = rule_cmd
;
19671 GET_P0_CONV (rule
);
19674 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19675 rule_buf
[rule_pos
] = rule_cmd
;
19676 GET_P0_CONV (rule
);
19679 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19680 rule_buf
[rule_pos
] = rule_cmd
;
19681 GET_P0_CONV (rule
);
19684 case RULE_OP_MANGLE_TITLE
:
19685 rule_buf
[rule_pos
] = rule_cmd
;
19689 return rule_pos
- 1;
19707 * CPU rules : this is from hashcat sources, cpu based rules
19710 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19711 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19713 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19714 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19715 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19717 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19718 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19719 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19721 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19725 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19730 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19734 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19739 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19743 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19748 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19753 for (l
= 0; l
< arr_len
; l
++)
19755 r
= arr_len
- 1 - l
;
19759 MANGLE_SWITCH (arr
, l
, r
);
19765 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19767 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19769 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19771 return (arr_len
* 2);
19774 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19776 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19778 int orig_len
= arr_len
;
19782 for (i
= 0; i
< times
; i
++)
19784 memcpy (&arr
[arr_len
], arr
, orig_len
);
19786 arr_len
+= orig_len
;
19792 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19794 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19796 mangle_double (arr
, arr_len
);
19798 mangle_reverse (arr
+ arr_len
, arr_len
);
19800 return (arr_len
* 2);
19803 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19808 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19810 MANGLE_SWITCH (arr
, l
, r
);
19816 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19821 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19823 MANGLE_SWITCH (arr
, l
, r
);
19829 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19831 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19835 return (arr_len
+ 1);
19838 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19840 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19844 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19846 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19851 return (arr_len
+ 1);
19854 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19856 if (upos
>= arr_len
) return (arr_len
);
19860 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19862 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19865 return (arr_len
- 1);
19868 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19870 if (upos
>= arr_len
) return (arr_len
);
19872 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19876 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19878 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19884 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19886 if (upos
>= arr_len
) return (arr_len
);
19888 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19892 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19894 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19897 return (arr_len
- ulen
);
19900 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19902 if (upos
>= arr_len
) return (arr_len
);
19904 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19908 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19910 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19915 return (arr_len
+ 1);
19918 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
)
19920 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19922 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19924 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19926 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19928 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19930 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19932 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19934 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19936 return (arr_len
+ arr2_cpy
);
19939 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19941 if (upos
>= arr_len
) return (arr_len
);
19948 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19950 if (upos
>= arr_len
) return (arr_len
);
19952 memset (arr
+ upos
, 0, arr_len
- upos
);
19957 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19961 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19963 if (arr
[arr_pos
] != oldc
) continue;
19965 arr
[arr_pos
] = newc
;
19971 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19977 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19979 if (arr
[arr_pos
] == c
) continue;
19981 arr
[ret_len
] = arr
[arr_pos
];
19989 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19991 if (ulen
> arr_len
) return (arr_len
);
19993 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19995 char cs
[100] = { 0 };
19997 memcpy (cs
, arr
, ulen
);
20001 for (i
= 0; i
< ulen
; i
++)
20005 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20011 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20013 if (ulen
> arr_len
) return (arr_len
);
20015 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20017 int upos
= arr_len
- ulen
;
20021 for (i
= 0; i
< ulen
; i
++)
20023 char c
= arr
[upos
+ i
];
20025 arr_len
= mangle_append (arr
, arr_len
, c
);
20031 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20033 if ( arr_len
== 0) return (arr_len
);
20034 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20036 char c
= arr
[upos
];
20040 for (i
= 0; i
< ulen
; i
++)
20042 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20048 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20050 if ( arr_len
== 0) return (arr_len
);
20051 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20055 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20057 int new_pos
= arr_pos
* 2;
20059 arr
[new_pos
] = arr
[arr_pos
];
20061 arr
[new_pos
+ 1] = arr
[arr_pos
];
20064 return (arr_len
* 2);
20067 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20069 if (upos
>= arr_len
) return (arr_len
);
20070 if (upos2
>= arr_len
) return (arr_len
);
20072 MANGLE_SWITCH (arr
, upos
, upos2
);
20077 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20079 MANGLE_SWITCH (arr
, upos
, upos2
);
20084 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20086 if (upos
>= arr_len
) return (arr_len
);
20093 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20095 if (upos
>= arr_len
) return (arr_len
);
20102 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20104 if (upos
>= arr_len
) return (arr_len
);
20111 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20113 if (upos
>= arr_len
) return (arr_len
);
20120 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20122 int upper_next
= 1;
20126 for (pos
= 0; pos
< arr_len
; pos
++)
20128 if (arr
[pos
] == ' ')
20139 MANGLE_UPPER_AT (arr
, pos
);
20143 MANGLE_LOWER_AT (arr
, pos
);
20150 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20152 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20158 for (j
= 0; j
< rp_gen_num
; j
++)
20165 switch ((char) get_random_num (0, 9))
20168 r
= get_random_num (0, sizeof (grp_op_nop
));
20169 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20173 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20174 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20175 p1
= get_random_num (0, sizeof (grp_pos
));
20176 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20180 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20181 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20182 p1
= get_random_num (1, 6);
20183 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20187 r
= get_random_num (0, sizeof (grp_op_chr
));
20188 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20189 p1
= get_random_num (0x20, 0x7e);
20190 rule_buf
[rule_pos
++] = (char) p1
;
20194 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20195 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20196 p1
= get_random_num (0x20, 0x7e);
20197 rule_buf
[rule_pos
++] = (char) p1
;
20198 p2
= get_random_num (0x20, 0x7e);
20200 p2
= get_random_num (0x20, 0x7e);
20201 rule_buf
[rule_pos
++] = (char) p2
;
20205 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20206 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20207 p1
= get_random_num (0, sizeof (grp_pos
));
20208 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20209 p2
= get_random_num (0x20, 0x7e);
20210 rule_buf
[rule_pos
++] = (char) p2
;
20214 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20215 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20216 p1
= get_random_num (0, sizeof (grp_pos
));
20217 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20218 p2
= get_random_num (0, sizeof (grp_pos
));
20220 p2
= get_random_num (0, sizeof (grp_pos
));
20221 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20225 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20226 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20227 p1
= get_random_num (0, sizeof (grp_pos
));
20228 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20229 p2
= get_random_num (1, sizeof (grp_pos
));
20231 p2
= get_random_num (1, sizeof (grp_pos
));
20232 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20236 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20237 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20238 p1
= get_random_num (0, sizeof (grp_pos
));
20239 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20240 p2
= get_random_num (1, sizeof (grp_pos
));
20241 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20242 p3
= get_random_num (0, sizeof (grp_pos
));
20243 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20251 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20253 char mem
[BLOCK_SIZE
] = { 0 };
20255 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20257 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20259 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20261 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20263 int out_len
= in_len
;
20264 int mem_len
= in_len
;
20266 memcpy (out
, in
, out_len
);
20270 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20275 switch (rule
[rule_pos
])
20280 case RULE_OP_MANGLE_NOOP
:
20283 case RULE_OP_MANGLE_LREST
:
20284 out_len
= mangle_lrest (out
, out_len
);
20287 case RULE_OP_MANGLE_UREST
:
20288 out_len
= mangle_urest (out
, out_len
);
20291 case RULE_OP_MANGLE_LREST_UFIRST
:
20292 out_len
= mangle_lrest (out
, out_len
);
20293 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20296 case RULE_OP_MANGLE_UREST_LFIRST
:
20297 out_len
= mangle_urest (out
, out_len
);
20298 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20301 case RULE_OP_MANGLE_TREST
:
20302 out_len
= mangle_trest (out
, out_len
);
20305 case RULE_OP_MANGLE_TOGGLE_AT
:
20306 NEXT_RULEPOS (rule_pos
);
20307 NEXT_RPTOI (rule
, rule_pos
, upos
);
20308 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20311 case RULE_OP_MANGLE_REVERSE
:
20312 out_len
= mangle_reverse (out
, out_len
);
20315 case RULE_OP_MANGLE_DUPEWORD
:
20316 out_len
= mangle_double (out
, out_len
);
20319 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20320 NEXT_RULEPOS (rule_pos
);
20321 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20322 out_len
= mangle_double_times (out
, out_len
, ulen
);
20325 case RULE_OP_MANGLE_REFLECT
:
20326 out_len
= mangle_reflect (out
, out_len
);
20329 case RULE_OP_MANGLE_ROTATE_LEFT
:
20330 mangle_rotate_left (out
, out_len
);
20333 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20334 mangle_rotate_right (out
, out_len
);
20337 case RULE_OP_MANGLE_APPEND
:
20338 NEXT_RULEPOS (rule_pos
);
20339 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20342 case RULE_OP_MANGLE_PREPEND
:
20343 NEXT_RULEPOS (rule_pos
);
20344 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20347 case RULE_OP_MANGLE_DELETE_FIRST
:
20348 out_len
= mangle_delete_at (out
, out_len
, 0);
20351 case RULE_OP_MANGLE_DELETE_LAST
:
20352 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20355 case RULE_OP_MANGLE_DELETE_AT
:
20356 NEXT_RULEPOS (rule_pos
);
20357 NEXT_RPTOI (rule
, rule_pos
, upos
);
20358 out_len
= mangle_delete_at (out
, out_len
, upos
);
20361 case RULE_OP_MANGLE_EXTRACT
:
20362 NEXT_RULEPOS (rule_pos
);
20363 NEXT_RPTOI (rule
, rule_pos
, upos
);
20364 NEXT_RULEPOS (rule_pos
);
20365 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20366 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20369 case RULE_OP_MANGLE_OMIT
:
20370 NEXT_RULEPOS (rule_pos
);
20371 NEXT_RPTOI (rule
, rule_pos
, upos
);
20372 NEXT_RULEPOS (rule_pos
);
20373 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20374 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20377 case RULE_OP_MANGLE_INSERT
:
20378 NEXT_RULEPOS (rule_pos
);
20379 NEXT_RPTOI (rule
, rule_pos
, upos
);
20380 NEXT_RULEPOS (rule_pos
);
20381 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20384 case RULE_OP_MANGLE_OVERSTRIKE
:
20385 NEXT_RULEPOS (rule_pos
);
20386 NEXT_RPTOI (rule
, rule_pos
, upos
);
20387 NEXT_RULEPOS (rule_pos
);
20388 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20391 case RULE_OP_MANGLE_TRUNCATE_AT
:
20392 NEXT_RULEPOS (rule_pos
);
20393 NEXT_RPTOI (rule
, rule_pos
, upos
);
20394 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20397 case RULE_OP_MANGLE_REPLACE
:
20398 NEXT_RULEPOS (rule_pos
);
20399 NEXT_RULEPOS (rule_pos
);
20400 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20403 case RULE_OP_MANGLE_PURGECHAR
:
20404 NEXT_RULEPOS (rule_pos
);
20405 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20408 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20412 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20413 NEXT_RULEPOS (rule_pos
);
20414 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20415 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20418 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20419 NEXT_RULEPOS (rule_pos
);
20420 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20421 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20424 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20425 out_len
= mangle_dupechar (out
, out_len
);
20428 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20429 NEXT_RULEPOS (rule_pos
);
20430 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20431 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20434 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20435 NEXT_RULEPOS (rule_pos
);
20436 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20437 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20440 case RULE_OP_MANGLE_SWITCH_FIRST
:
20441 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20444 case RULE_OP_MANGLE_SWITCH_LAST
:
20445 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20448 case RULE_OP_MANGLE_SWITCH_AT
:
20449 NEXT_RULEPOS (rule_pos
);
20450 NEXT_RPTOI (rule
, rule_pos
, upos
);
20451 NEXT_RULEPOS (rule_pos
);
20452 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20453 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20456 case RULE_OP_MANGLE_CHR_SHIFTL
:
20457 NEXT_RULEPOS (rule_pos
);
20458 NEXT_RPTOI (rule
, rule_pos
, upos
);
20459 mangle_chr_shiftl (out
, out_len
, upos
);
20462 case RULE_OP_MANGLE_CHR_SHIFTR
:
20463 NEXT_RULEPOS (rule_pos
);
20464 NEXT_RPTOI (rule
, rule_pos
, upos
);
20465 mangle_chr_shiftr (out
, out_len
, upos
);
20468 case RULE_OP_MANGLE_CHR_INCR
:
20469 NEXT_RULEPOS (rule_pos
);
20470 NEXT_RPTOI (rule
, rule_pos
, upos
);
20471 mangle_chr_incr (out
, out_len
, upos
);
20474 case RULE_OP_MANGLE_CHR_DECR
:
20475 NEXT_RULEPOS (rule_pos
);
20476 NEXT_RPTOI (rule
, rule_pos
, upos
);
20477 mangle_chr_decr (out
, out_len
, upos
);
20480 case RULE_OP_MANGLE_REPLACE_NP1
:
20481 NEXT_RULEPOS (rule_pos
);
20482 NEXT_RPTOI (rule
, rule_pos
, upos
);
20483 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20486 case RULE_OP_MANGLE_REPLACE_NM1
:
20487 NEXT_RULEPOS (rule_pos
);
20488 NEXT_RPTOI (rule
, rule_pos
, upos
);
20489 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20492 case RULE_OP_MANGLE_TITLE
:
20493 out_len
= mangle_title (out
, out_len
);
20496 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20497 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20498 NEXT_RULEPOS (rule_pos
);
20499 NEXT_RPTOI (rule
, rule_pos
, upos
);
20500 NEXT_RULEPOS (rule_pos
);
20501 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20502 NEXT_RULEPOS (rule_pos
);
20503 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20504 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20507 case RULE_OP_MANGLE_APPEND_MEMORY
:
20508 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20509 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20510 memcpy (out
+ out_len
, mem
, mem_len
);
20511 out_len
+= mem_len
;
20514 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20515 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20516 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20517 memcpy (mem
+ mem_len
, out
, out_len
);
20518 out_len
+= mem_len
;
20519 memcpy (out
, mem
, out_len
);
20522 case RULE_OP_MEMORIZE_WORD
:
20523 memcpy (mem
, out
, out_len
);
20527 case RULE_OP_REJECT_LESS
:
20528 NEXT_RULEPOS (rule_pos
);
20529 NEXT_RPTOI (rule
, rule_pos
, upos
);
20530 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20533 case RULE_OP_REJECT_GREATER
:
20534 NEXT_RULEPOS (rule_pos
);
20535 NEXT_RPTOI (rule
, rule_pos
, upos
);
20536 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20539 case RULE_OP_REJECT_CONTAIN
:
20540 NEXT_RULEPOS (rule_pos
);
20541 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20544 case RULE_OP_REJECT_NOT_CONTAIN
:
20545 NEXT_RULEPOS (rule_pos
);
20546 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20549 case RULE_OP_REJECT_EQUAL_FIRST
:
20550 NEXT_RULEPOS (rule_pos
);
20551 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20554 case RULE_OP_REJECT_EQUAL_LAST
:
20555 NEXT_RULEPOS (rule_pos
);
20556 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20559 case RULE_OP_REJECT_EQUAL_AT
:
20560 NEXT_RULEPOS (rule_pos
);
20561 NEXT_RPTOI (rule
, rule_pos
, upos
);
20562 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20563 NEXT_RULEPOS (rule_pos
);
20564 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20567 case RULE_OP_REJECT_CONTAINS
:
20568 NEXT_RULEPOS (rule_pos
);
20569 NEXT_RPTOI (rule
, rule_pos
, upos
);
20570 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20571 NEXT_RULEPOS (rule_pos
);
20572 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20573 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20576 case RULE_OP_REJECT_MEMORY
:
20577 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20581 return (RULE_RC_SYNTAX_ERROR
);
20586 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);